Trendsic Platform Service

<back to all web services

FormSubmissionRequestInfoRequest

Requires Authentication
The following routes are available for this service:
POST/v1/forms/submissions/{SubmissionUID}/request-info
import 'package:servicestack/servicestack.dart';

class FormStageInfo implements IConvertible
{
    String? Id;
    String? Label;
    String? Tone;
    String? Kind;

    FormStageInfo({this.Id,this.Label,this.Tone,this.Kind});
    FormStageInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Id = json['Id'];
        Label = json['Label'];
        Tone = json['Tone'];
        Kind = json['Kind'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'Label': Label,
        'Tone': Tone,
        'Kind': Kind
    };

    getTypeName() => "FormStageInfo";
    TypeContext? context = _ctx;
}

class FormPerson implements IConvertible
{
    int? AgentId;
    String? AgentName;

    FormPerson({this.AgentId,this.AgentName});
    FormPerson.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        AgentId = json['AgentId'];
        AgentName = json['AgentName'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'AgentId': AgentId,
        'AgentName': AgentName
    };

    getTypeName() => "FormPerson";
    TypeContext? context = _ctx;
}

class FormRecordFile implements IConvertible
{
    String? AttachmentId;
    String? Name;
    String? Kind;
    String? Size;
    bool? Sensitive;
    bool? Locked;

    FormRecordFile({this.AttachmentId,this.Name,this.Kind,this.Size,this.Sensitive,this.Locked});
    FormRecordFile.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        AttachmentId = json['AttachmentId'];
        Name = json['Name'];
        Kind = json['Kind'];
        Size = json['Size'];
        Sensitive = json['Sensitive'];
        Locked = json['Locked'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'AttachmentId': AttachmentId,
        'Name': Name,
        'Kind': Kind,
        'Size': Size,
        'Sensitive': Sensitive,
        'Locked': Locked
    };

    getTypeName() => "FormRecordFile";
    TypeContext? context = _ctx;
}

class FormRecordSig implements IConvertible
{
    bool? Pending;
    String? Mode;
    String? SignerName;
    String? Role;
    int? RecordId;
    String? ImageHash;
    String? DocumentDigest;
    String? Ip;
    String? Browser;
    bool? ConsentStored;
    String? SignedText;
    bool? HasImage;

    FormRecordSig({this.Pending,this.Mode,this.SignerName,this.Role,this.RecordId,this.ImageHash,this.DocumentDigest,this.Ip,this.Browser,this.ConsentStored,this.SignedText,this.HasImage});
    FormRecordSig.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Pending = json['Pending'];
        Mode = json['Mode'];
        SignerName = json['SignerName'];
        Role = json['Role'];
        RecordId = json['RecordId'];
        ImageHash = json['ImageHash'];
        DocumentDigest = json['DocumentDigest'];
        Ip = json['Ip'];
        Browser = json['Browser'];
        ConsentStored = json['ConsentStored'];
        SignedText = json['SignedText'];
        HasImage = json['HasImage'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Pending': Pending,
        'Mode': Mode,
        'SignerName': SignerName,
        'Role': Role,
        'RecordId': RecordId,
        'ImageHash': ImageHash,
        'DocumentDigest': DocumentDigest,
        'Ip': Ip,
        'Browser': Browser,
        'ConsentStored': ConsentStored,
        'SignedText': SignedText,
        'HasImage': HasImage
    };

    getTypeName() => "FormRecordSig";
    TypeContext? context = _ctx;
}

class FormRecordRow implements IConvertible
{
    String? K;
    String? L;
    String? T;
    String? Kind;
    String? V;
    bool? Sensitive;
    bool? CanReveal;
    bool? Locked;
    List<FormRecordFile>? Files = [];
    bool? NoFiles;
    FormRecordSig? Sig;
    bool? Asked;
    bool? Changed;
    String? Prev;

    FormRecordRow({this.K,this.L,this.T,this.Kind,this.V,this.Sensitive,this.CanReveal,this.Locked,this.Files,this.NoFiles,this.Sig,this.Asked,this.Changed,this.Prev});
    FormRecordRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        K = json['K'];
        L = json['L'];
        T = json['T'];
        Kind = json['Kind'];
        V = json['V'];
        Sensitive = json['Sensitive'];
        CanReveal = json['CanReveal'];
        Locked = json['Locked'];
        Files = JsonConverters.fromJson(json['Files'],'List<FormRecordFile>',context!);
        NoFiles = json['NoFiles'];
        Sig = JsonConverters.fromJson(json['Sig'],'FormRecordSig',context!);
        Asked = json['Asked'];
        Changed = json['Changed'];
        Prev = json['Prev'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'K': K,
        'L': L,
        'T': T,
        'Kind': Kind,
        'V': V,
        'Sensitive': Sensitive,
        'CanReveal': CanReveal,
        'Locked': Locked,
        'Files': JsonConverters.toJson(Files,'List<FormRecordFile>',context!),
        'NoFiles': NoFiles,
        'Sig': JsonConverters.toJson(Sig,'FormRecordSig',context!),
        'Asked': Asked,
        'Changed': Changed,
        'Prev': Prev
    };

    getTypeName() => "FormRecordRow";
    TypeContext? context = _ctx;
}

class FormRecordSection implements IConvertible
{
    String? Title;
    List<FormRecordRow>? Rows = [];

    FormRecordSection({this.Title,this.Rows});
    FormRecordSection.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Title = json['Title'];
        Rows = JsonConverters.fromJson(json['Rows'],'List<FormRecordRow>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Title': Title,
        'Rows': JsonConverters.toJson(Rows,'List<FormRecordRow>',context!)
    };

    getTypeName() => "FormRecordSection";
    TypeContext? context = _ctx;
}

class FormRecordDoc implements IConvertible
{
    String? Name;
    bool? Ok;
    String? Tag;
    String? Tone;

    FormRecordDoc({this.Name,this.Ok,this.Tag,this.Tone});
    FormRecordDoc.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Name = json['Name'];
        Ok = json['Ok'];
        Tag = json['Tag'];
        Tone = json['Tone'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Name': Name,
        'Ok': Ok,
        'Tag': Tag,
        'Tone': Tone
    };

    getTypeName() => "FormRecordDoc";
    TypeContext? context = _ctx;
}

class FormRecordComputed implements IConvertible
{
    String? L;
    String? V;

    FormRecordComputed({this.L,this.V});
    FormRecordComputed.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        L = json['L'];
        V = json['V'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'L': L,
        'V': V
    };

    getTypeName() => "FormRecordComputed";
    TypeContext? context = _ctx;
}

class FormRecordEvent implements IConvertible
{
    String? Who;
    String? X;
    String? T;
    DateTime? At;
    String? Dot;

    FormRecordEvent({this.Who,this.X,this.T,this.At,this.Dot});
    FormRecordEvent.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Who = json['Who'];
        X = json['X'];
        T = json['T'];
        At = JsonConverters.fromJson(json['At'],'DateTime',context!);
        Dot = json['Dot'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Who': Who,
        'X': X,
        'T': T,
        'At': JsonConverters.toJson(At,'DateTime',context!),
        'Dot': Dot
    };

    getTypeName() => "FormRecordEvent";
    TypeContext? context = _ctx;
}

class FormRecordRequest implements IConvertible
{
    String? RequestUID;
    List<String>? Keys = [];
    List<String>? Resign = [];
    String? Note;
    String? By;
    String? At;

    FormRecordRequest({this.RequestUID,this.Keys,this.Resign,this.Note,this.By,this.At});
    FormRecordRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RequestUID = json['RequestUID'];
        Keys = JsonConverters.fromJson(json['Keys'],'List<String>',context!);
        Resign = JsonConverters.fromJson(json['Resign'],'List<String>',context!);
        Note = json['Note'];
        By = json['By'];
        At = json['At'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RequestUID': RequestUID,
        'Keys': JsonConverters.toJson(Keys,'List<String>',context!),
        'Resign': JsonConverters.toJson(Resign,'List<String>',context!),
        'Note': Note,
        'By': By,
        'At': At
    };

    getTypeName() => "FormRecordRequest";
    TypeContext? context = _ctx;
}

class FormRecordDecision implements IConvertible
{
    String? Outcome;
    String? Tone;
    String? Reason;
    String? Note;
    String? Text;
    bool? HasCounter;
    bool? Typed;
    bool? Drawn;
    String? SigName;
    String? SigMeta;

    FormRecordDecision({this.Outcome,this.Tone,this.Reason,this.Note,this.Text,this.HasCounter,this.Typed,this.Drawn,this.SigName,this.SigMeta});
    FormRecordDecision.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Outcome = json['Outcome'];
        Tone = json['Tone'];
        Reason = json['Reason'];
        Note = json['Note'];
        Text = json['Text'];
        HasCounter = json['HasCounter'];
        Typed = json['Typed'];
        Drawn = json['Drawn'];
        SigName = json['SigName'];
        SigMeta = json['SigMeta'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Outcome': Outcome,
        'Tone': Tone,
        'Reason': Reason,
        'Note': Note,
        'Text': Text,
        'HasCounter': HasCounter,
        'Typed': Typed,
        'Drawn': Drawn,
        'SigName': SigName,
        'SigMeta': SigMeta
    };

    getTypeName() => "FormRecordDecision";
    TypeContext? context = _ctx;
}

class FormRecordEarlierDecision implements IConvertible
{
    String? Outcome;
    String? Tone;
    String? Reason;
    String? Note;
    String? Text;
    String? Counter;
    String? Reopened;

    FormRecordEarlierDecision({this.Outcome,this.Tone,this.Reason,this.Note,this.Text,this.Counter,this.Reopened});
    FormRecordEarlierDecision.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Outcome = json['Outcome'];
        Tone = json['Tone'];
        Reason = json['Reason'];
        Note = json['Note'];
        Text = json['Text'];
        Counter = json['Counter'];
        Reopened = json['Reopened'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Outcome': Outcome,
        'Tone': Tone,
        'Reason': Reason,
        'Note': Note,
        'Text': Text,
        'Counter': Counter,
        'Reopened': Reopened
    };

    getTypeName() => "FormRecordEarlierDecision";
    TypeContext? context = _ctx;
}

class FormRecordSigEntry implements IConvertible
{
    int? RecordId;
    String? Key;
    String? Label;
    String? Role;
    String? SignerName;
    String? Mode;
    bool? HasImage;
    bool? ConsentStored;
    bool? Replaced;
    bool? Counter;
    bool? Reopened;
    String? Meta;

    FormRecordSigEntry({this.RecordId,this.Key,this.Label,this.Role,this.SignerName,this.Mode,this.HasImage,this.ConsentStored,this.Replaced,this.Counter,this.Reopened,this.Meta});
    FormRecordSigEntry.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RecordId = json['RecordId'];
        Key = json['Key'];
        Label = json['Label'];
        Role = json['Role'];
        SignerName = json['SignerName'];
        Mode = json['Mode'];
        HasImage = json['HasImage'];
        ConsentStored = json['ConsentStored'];
        Replaced = json['Replaced'];
        Counter = json['Counter'];
        Reopened = json['Reopened'];
        Meta = json['Meta'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RecordId': RecordId,
        'Key': Key,
        'Label': Label,
        'Role': Role,
        'SignerName': SignerName,
        'Mode': Mode,
        'HasImage': HasImage,
        'ConsentStored': ConsentStored,
        'Replaced': Replaced,
        'Counter': Counter,
        'Reopened': Reopened,
        'Meta': Meta
    };

    getTypeName() => "FormRecordSigEntry";
    TypeContext? context = _ctx;
}

class FormRecordReplacedRow implements IConvertible
{
    String? K;
    String? L;
    String? Kind;
    String? V;
    bool? Sensitive;
    bool? CanReveal;
    bool? Locked;
    List<FormRecordFile>? Files = [];

    FormRecordReplacedRow({this.K,this.L,this.Kind,this.V,this.Sensitive,this.CanReveal,this.Locked,this.Files});
    FormRecordReplacedRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        K = json['K'];
        L = json['L'];
        Kind = json['Kind'];
        V = json['V'];
        Sensitive = json['Sensitive'];
        CanReveal = json['CanReveal'];
        Locked = json['Locked'];
        Files = JsonConverters.fromJson(json['Files'],'List<FormRecordFile>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'K': K,
        'L': L,
        'Kind': Kind,
        'V': V,
        'Sensitive': Sensitive,
        'CanReveal': CanReveal,
        'Locked': Locked,
        'Files': JsonConverters.toJson(Files,'List<FormRecordFile>',context!)
    };

    getTypeName() => "FormRecordReplacedRow";
    TypeContext? context = _ctx;
}

class FormRecordReplaced implements IConvertible
{
    String? RequestUID;
    String? AskedBy;
    String? AskedAt;
    String? AnsweredAt;
    String? Covering;
    List<FormRecordReplacedRow>? Rows = [];

    FormRecordReplaced({this.RequestUID,this.AskedBy,this.AskedAt,this.AnsweredAt,this.Covering,this.Rows});
    FormRecordReplaced.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RequestUID = json['RequestUID'];
        AskedBy = json['AskedBy'];
        AskedAt = json['AskedAt'];
        AnsweredAt = json['AnsweredAt'];
        Covering = json['Covering'];
        Rows = JsonConverters.fromJson(json['Rows'],'List<FormRecordReplacedRow>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RequestUID': RequestUID,
        'AskedBy': AskedBy,
        'AskedAt': AskedAt,
        'AnsweredAt': AnsweredAt,
        'Covering': Covering,
        'Rows': JsonConverters.toJson(Rows,'List<FormRecordReplacedRow>',context!)
    };

    getTypeName() => "FormRecordReplaced";
    TypeContext? context = _ctx;
}

class FormSubmissionRecord implements IConvertible
{
    String? SubmissionUID;
    String? FormUID;
    String? FormName;
    String? Noun;
    String? Number;
    String? ApplicantName;
    FormStageInfo? Stage;
    List<String>? Tags = [];
    int? AssigneeAgentId;
    String? AssigneeName;
    String? BranchName;
    DateTime? SubmittedAt;
    int? VersionNo;
    int? CurrentVersionNo;
    String? Email;
    String? Phone;
    String? ContactName;
    String? Meta;
    List<FormStageInfo>? Stages = [];
    List<FormStageInfo>? Moves = [];
    List<FormPerson>? People = [];
    bool? CanEdit;
    bool? CanSensitive;
    List<FormRecordSection>? Sections = [];
    List<FormRecordDoc>? Docs = [];
    String? DocCount;
    List<FormRecordComputed>? Computed = [];
    List<FormRecordEvent>? Timeline = [];
    List<FormRecordEvent>? Notes = [];
    List<FormRecordEvent>? Audit = [];
    bool? IsTest;
    String? VersionText;
    String? TenantName;
    String? SubmittedIso;
    FormRecordRequest? OpenRequest;
    bool? CanRequest;
    String? RequestTip;
    FormRecordDecision? Decision;
    List<FormRecordEarlierDecision>? Earlier = [];
    bool? CanDecide;
    String? DecideTip;
    String? MoveTip;
    DateTime? DueAt;
    bool? Overdue;
    String? AgeText;
    String? DueText;
    List<FormRecordSigEntry>? Signatures = [];
    List<FormRecordReplaced>? Replaced = [];

    FormSubmissionRecord({this.SubmissionUID,this.FormUID,this.FormName,this.Noun,this.Number,this.ApplicantName,this.Stage,this.Tags,this.AssigneeAgentId,this.AssigneeName,this.BranchName,this.SubmittedAt,this.VersionNo,this.CurrentVersionNo,this.Email,this.Phone,this.ContactName,this.Meta,this.Stages,this.Moves,this.People,this.CanEdit,this.CanSensitive,this.Sections,this.Docs,this.DocCount,this.Computed,this.Timeline,this.Notes,this.Audit,this.IsTest,this.VersionText,this.TenantName,this.SubmittedIso,this.OpenRequest,this.CanRequest,this.RequestTip,this.Decision,this.Earlier,this.CanDecide,this.DecideTip,this.MoveTip,this.DueAt,this.Overdue,this.AgeText,this.DueText,this.Signatures,this.Replaced});
    FormSubmissionRecord.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        SubmissionUID = json['SubmissionUID'];
        FormUID = json['FormUID'];
        FormName = json['FormName'];
        Noun = json['Noun'];
        Number = json['Number'];
        ApplicantName = json['ApplicantName'];
        Stage = JsonConverters.fromJson(json['Stage'],'FormStageInfo',context!);
        Tags = JsonConverters.fromJson(json['Tags'],'List<String>',context!);
        AssigneeAgentId = json['AssigneeAgentId'];
        AssigneeName = json['AssigneeName'];
        BranchName = json['BranchName'];
        SubmittedAt = JsonConverters.fromJson(json['SubmittedAt'],'DateTime',context!);
        VersionNo = json['VersionNo'];
        CurrentVersionNo = json['CurrentVersionNo'];
        Email = json['Email'];
        Phone = json['Phone'];
        ContactName = json['ContactName'];
        Meta = json['Meta'];
        Stages = JsonConverters.fromJson(json['Stages'],'List<FormStageInfo>',context!);
        Moves = JsonConverters.fromJson(json['Moves'],'List<FormStageInfo>',context!);
        People = JsonConverters.fromJson(json['People'],'List<FormPerson>',context!);
        CanEdit = json['CanEdit'];
        CanSensitive = json['CanSensitive'];
        Sections = JsonConverters.fromJson(json['Sections'],'List<FormRecordSection>',context!);
        Docs = JsonConverters.fromJson(json['Docs'],'List<FormRecordDoc>',context!);
        DocCount = json['DocCount'];
        Computed = JsonConverters.fromJson(json['Computed'],'List<FormRecordComputed>',context!);
        Timeline = JsonConverters.fromJson(json['Timeline'],'List<FormRecordEvent>',context!);
        Notes = JsonConverters.fromJson(json['Notes'],'List<FormRecordEvent>',context!);
        Audit = JsonConverters.fromJson(json['Audit'],'List<FormRecordEvent>',context!);
        IsTest = json['IsTest'];
        VersionText = json['VersionText'];
        TenantName = json['TenantName'];
        SubmittedIso = json['SubmittedIso'];
        OpenRequest = JsonConverters.fromJson(json['OpenRequest'],'FormRecordRequest',context!);
        CanRequest = json['CanRequest'];
        RequestTip = json['RequestTip'];
        Decision = JsonConverters.fromJson(json['Decision'],'FormRecordDecision',context!);
        Earlier = JsonConverters.fromJson(json['Earlier'],'List<FormRecordEarlierDecision>',context!);
        CanDecide = json['CanDecide'];
        DecideTip = json['DecideTip'];
        MoveTip = json['MoveTip'];
        DueAt = JsonConverters.fromJson(json['DueAt'],'DateTime',context!);
        Overdue = json['Overdue'];
        AgeText = json['AgeText'];
        DueText = json['DueText'];
        Signatures = JsonConverters.fromJson(json['Signatures'],'List<FormRecordSigEntry>',context!);
        Replaced = JsonConverters.fromJson(json['Replaced'],'List<FormRecordReplaced>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'SubmissionUID': SubmissionUID,
        'FormUID': FormUID,
        'FormName': FormName,
        'Noun': Noun,
        'Number': Number,
        'ApplicantName': ApplicantName,
        'Stage': JsonConverters.toJson(Stage,'FormStageInfo',context!),
        'Tags': JsonConverters.toJson(Tags,'List<String>',context!),
        'AssigneeAgentId': AssigneeAgentId,
        'AssigneeName': AssigneeName,
        'BranchName': BranchName,
        'SubmittedAt': JsonConverters.toJson(SubmittedAt,'DateTime',context!),
        'VersionNo': VersionNo,
        'CurrentVersionNo': CurrentVersionNo,
        'Email': Email,
        'Phone': Phone,
        'ContactName': ContactName,
        'Meta': Meta,
        'Stages': JsonConverters.toJson(Stages,'List<FormStageInfo>',context!),
        'Moves': JsonConverters.toJson(Moves,'List<FormStageInfo>',context!),
        'People': JsonConverters.toJson(People,'List<FormPerson>',context!),
        'CanEdit': CanEdit,
        'CanSensitive': CanSensitive,
        'Sections': JsonConverters.toJson(Sections,'List<FormRecordSection>',context!),
        'Docs': JsonConverters.toJson(Docs,'List<FormRecordDoc>',context!),
        'DocCount': DocCount,
        'Computed': JsonConverters.toJson(Computed,'List<FormRecordComputed>',context!),
        'Timeline': JsonConverters.toJson(Timeline,'List<FormRecordEvent>',context!),
        'Notes': JsonConverters.toJson(Notes,'List<FormRecordEvent>',context!),
        'Audit': JsonConverters.toJson(Audit,'List<FormRecordEvent>',context!),
        'IsTest': IsTest,
        'VersionText': VersionText,
        'TenantName': TenantName,
        'SubmittedIso': SubmittedIso,
        'OpenRequest': JsonConverters.toJson(OpenRequest,'FormRecordRequest',context!),
        'CanRequest': CanRequest,
        'RequestTip': RequestTip,
        'Decision': JsonConverters.toJson(Decision,'FormRecordDecision',context!),
        'Earlier': JsonConverters.toJson(Earlier,'List<FormRecordEarlierDecision>',context!),
        'CanDecide': CanDecide,
        'DecideTip': DecideTip,
        'MoveTip': MoveTip,
        'DueAt': JsonConverters.toJson(DueAt,'DateTime',context!),
        'Overdue': Overdue,
        'AgeText': AgeText,
        'DueText': DueText,
        'Signatures': JsonConverters.toJson(Signatures,'List<FormRecordSigEntry>',context!),
        'Replaced': JsonConverters.toJson(Replaced,'List<FormRecordReplaced>',context!)
    };

    getTypeName() => "FormSubmissionRecord";
    TypeContext? context = _ctx;
}

class FormSubmissionRecordResponse implements IConvertible
{
    FormSubmissionRecord? Record;
    ResponseStatus? ResponseStatus;

    FormSubmissionRecordResponse({this.Record,this.ResponseStatus});
    FormSubmissionRecordResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Record = JsonConverters.fromJson(json['Record'],'FormSubmissionRecord',context!);
        ResponseStatus = JsonConverters.fromJson(json['ResponseStatus'],'ResponseStatus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Record': JsonConverters.toJson(Record,'FormSubmissionRecord',context!),
        'ResponseStatus': JsonConverters.toJson(ResponseStatus,'ResponseStatus',context!)
    };

    getTypeName() => "FormSubmissionRecordResponse";
    TypeContext? context = _ctx;
}

class FormFillReceiptLine implements IConvertible
{
    String? Channel;
    String? To;
    String? Outcome;

    FormFillReceiptLine({this.Channel,this.To,this.Outcome});
    FormFillReceiptLine.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Channel = json['Channel'];
        To = json['To'];
        Outcome = json['Outcome'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Channel': Channel,
        'To': To,
        'Outcome': Outcome
    };

    getTypeName() => "FormFillReceiptLine";
    TypeContext? context = _ctx;
}

class FormSubmissionRequestInfoResponse extends FormSubmissionRecordResponse implements IConvertible
{
    List<FormFillReceiptLine>? Sent = [];

    FormSubmissionRequestInfoResponse({this.Sent});
    FormSubmissionRequestInfoResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        Sent = JsonConverters.fromJson(json['Sent'],'List<FormFillReceiptLine>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'Sent': JsonConverters.toJson(Sent,'List<FormFillReceiptLine>',context!)
    });

    getTypeName() => "FormSubmissionRequestInfoResponse";
    TypeContext? context = _ctx;
}

class FormSubmissionRequestInfoRequest implements IConvertible
{
    String? SubmissionUID;
    List<String>? Keys = [];
    String? Note;
    String? From;

    FormSubmissionRequestInfoRequest({this.SubmissionUID,this.Keys,this.Note,this.From});
    FormSubmissionRequestInfoRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        SubmissionUID = json['SubmissionUID'];
        Keys = JsonConverters.fromJson(json['Keys'],'List<String>',context!);
        Note = json['Note'];
        From = json['From'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'SubmissionUID': SubmissionUID,
        'Keys': JsonConverters.toJson(Keys,'List<String>',context!),
        'Note': Note,
        'From': From
    };

    getTypeName() => "FormSubmissionRequestInfoRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.dev.dynamics.trendsic.com', types: <String, TypeInfo> {
    'FormStageInfo': TypeInfo(TypeOf.Class, create:() => FormStageInfo()),
    'FormPerson': TypeInfo(TypeOf.Class, create:() => FormPerson()),
    'FormRecordFile': TypeInfo(TypeOf.Class, create:() => FormRecordFile()),
    'FormRecordSig': TypeInfo(TypeOf.Class, create:() => FormRecordSig()),
    'FormRecordRow': TypeInfo(TypeOf.Class, create:() => FormRecordRow()),
    'List<FormRecordFile>': TypeInfo(TypeOf.Class, create:() => <FormRecordFile>[]),
    'FormRecordSection': TypeInfo(TypeOf.Class, create:() => FormRecordSection()),
    'List<FormRecordRow>': TypeInfo(TypeOf.Class, create:() => <FormRecordRow>[]),
    'FormRecordDoc': TypeInfo(TypeOf.Class, create:() => FormRecordDoc()),
    'FormRecordComputed': TypeInfo(TypeOf.Class, create:() => FormRecordComputed()),
    'FormRecordEvent': TypeInfo(TypeOf.Class, create:() => FormRecordEvent()),
    'FormRecordRequest': TypeInfo(TypeOf.Class, create:() => FormRecordRequest()),
    'FormRecordDecision': TypeInfo(TypeOf.Class, create:() => FormRecordDecision()),
    'FormRecordEarlierDecision': TypeInfo(TypeOf.Class, create:() => FormRecordEarlierDecision()),
    'FormRecordSigEntry': TypeInfo(TypeOf.Class, create:() => FormRecordSigEntry()),
    'FormRecordReplacedRow': TypeInfo(TypeOf.Class, create:() => FormRecordReplacedRow()),
    'FormRecordReplaced': TypeInfo(TypeOf.Class, create:() => FormRecordReplaced()),
    'List<FormRecordReplacedRow>': TypeInfo(TypeOf.Class, create:() => <FormRecordReplacedRow>[]),
    'FormSubmissionRecord': TypeInfo(TypeOf.Class, create:() => FormSubmissionRecord()),
    'List<FormStageInfo>': TypeInfo(TypeOf.Class, create:() => <FormStageInfo>[]),
    'List<FormPerson>': TypeInfo(TypeOf.Class, create:() => <FormPerson>[]),
    'List<FormRecordSection>': TypeInfo(TypeOf.Class, create:() => <FormRecordSection>[]),
    'List<FormRecordDoc>': TypeInfo(TypeOf.Class, create:() => <FormRecordDoc>[]),
    'List<FormRecordComputed>': TypeInfo(TypeOf.Class, create:() => <FormRecordComputed>[]),
    'List<FormRecordEvent>': TypeInfo(TypeOf.Class, create:() => <FormRecordEvent>[]),
    'List<FormRecordEarlierDecision>': TypeInfo(TypeOf.Class, create:() => <FormRecordEarlierDecision>[]),
    'List<FormRecordSigEntry>': TypeInfo(TypeOf.Class, create:() => <FormRecordSigEntry>[]),
    'List<FormRecordReplaced>': TypeInfo(TypeOf.Class, create:() => <FormRecordReplaced>[]),
    'FormSubmissionRecordResponse': TypeInfo(TypeOf.Class, create:() => FormSubmissionRecordResponse()),
    'FormFillReceiptLine': TypeInfo(TypeOf.Class, create:() => FormFillReceiptLine()),
    'FormSubmissionRequestInfoResponse': TypeInfo(TypeOf.Class, create:() => FormSubmissionRequestInfoResponse()),
    'List<FormFillReceiptLine>': TypeInfo(TypeOf.Class, create:() => <FormFillReceiptLine>[]),
    'FormSubmissionRequestInfoRequest': TypeInfo(TypeOf.Class, create:() => FormSubmissionRequestInfoRequest()),
});

Dart FormSubmissionRequestInfoRequest DTOs

To override the Content-type in your clients, use the HTTP Accept Header, append the .jsv suffix or ?format=jsv

HTTP + JSV

The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.

POST /v1/forms/submissions/{SubmissionUID}/request-info HTTP/1.1 
Host: api.dev.dynamics.trendsic.com 
Accept: text/jsv
Content-Type: text/jsv
Content-Length: length

{
	SubmissionUID: 00000000000000000000000000000000,
	Keys: 
	[
		String
	],
	Note: String,
	From: String
}
HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length

{
	Sent: 
	[
		{
			Channel: String,
			To: String,
			Outcome: String
		}
	],
	Record: 
	{
		SubmissionUID: 00000000000000000000000000000000,
		FormUID: 00000000000000000000000000000000,
		FormName: String,
		Noun: String,
		Number: String,
		ApplicantName: String,
		Stage: 
		{
			Id: String,
			Label: String,
			Tone: String,
			Kind: String
		},
		Tags: 
		[
			String
		],
		AssigneeAgentId: 0,
		AssigneeName: String,
		BranchName: String,
		SubmittedAt: 0001-01-01,
		VersionNo: 0,
		CurrentVersionNo: 0,
		Email: String,
		Phone: String,
		ContactName: String,
		Meta: String,
		Stages: 
		[
			{
				Id: String,
				Label: String,
				Tone: String,
				Kind: String
			}
		],
		Moves: 
		[
			{
				Id: String,
				Label: String,
				Tone: String,
				Kind: String
			}
		],
		People: 
		[
			{
				AgentId: 0,
				AgentName: String
			}
		],
		CanEdit: False,
		CanSensitive: False,
		Sections: 
		[
			{
				Title: String,
				Rows: 
				[
					{
						K: String,
						L: String,
						T: String,
						Kind: String,
						V: String,
						Sensitive: False,
						CanReveal: False,
						Locked: False,
						Files: 
						[
							{
								AttachmentId: 00000000000000000000000000000000,
								Name: String,
								Kind: String,
								Size: String,
								Sensitive: False,
								Locked: False
							}
						],
						NoFiles: False,
						Sig: 
						{
							Pending: False,
							Mode: String,
							SignerName: String,
							Role: String,
							RecordId: 0,
							ImageHash: String,
							DocumentDigest: String,
							Ip: String,
							Browser: String,
							ConsentStored: False,
							SignedText: String,
							HasImage: False
						},
						Asked: False,
						Changed: False,
						Prev: String
					}
				]
			}
		],
		Docs: 
		[
			{
				Name: String,
				Ok: False,
				Tag: String,
				Tone: String
			}
		],
		DocCount: String,
		Computed: 
		[
			{
				L: String,
				V: String
			}
		],
		Timeline: 
		[
			{
				Who: String,
				X: String,
				T: String,
				At: 0001-01-01,
				Dot: String
			}
		],
		Notes: 
		[
			{
				Who: String,
				X: String,
				T: String,
				At: 0001-01-01,
				Dot: String
			}
		],
		Audit: 
		[
			{
				Who: String,
				X: String,
				T: String,
				At: 0001-01-01,
				Dot: String
			}
		],
		IsTest: False,
		VersionText: String,
		TenantName: String,
		SubmittedIso: String,
		OpenRequest: 
		{
			RequestUID: 00000000000000000000000000000000,
			Keys: 
			[
				String
			],
			Resign: 
			[
				String
			],
			Note: String,
			By: String,
			At: String
		},
		CanRequest: False,
		RequestTip: String,
		Decision: 
		{
			Outcome: String,
			Tone: String,
			Reason: String,
			Note: String,
			Text: String,
			HasCounter: False,
			Typed: False,
			Drawn: False,
			SigName: String,
			SigMeta: String
		},
		Earlier: 
		[
			{
				Outcome: String,
				Tone: String,
				Reason: String,
				Note: String,
				Text: String,
				Counter: String,
				Reopened: String
			}
		],
		CanDecide: False,
		DecideTip: String,
		MoveTip: String,
		DueAt: 0001-01-01,
		Overdue: False,
		AgeText: String,
		DueText: String,
		Signatures: 
		[
			{
				RecordId: 0,
				Key: String,
				Label: String,
				Role: String,
				SignerName: String,
				Mode: String,
				HasImage: False,
				ConsentStored: False,
				Replaced: False,
				Counter: False,
				Reopened: False,
				Meta: String
			}
		],
		Replaced: 
		[
			{
				RequestUID: 00000000000000000000000000000000,
				AskedBy: String,
				AskedAt: String,
				AnsweredAt: String,
				Covering: String,
				Rows: 
				[
					{
						K: String,
						L: String,
						Kind: String,
						V: String,
						Sensitive: False,
						CanReveal: False,
						Locked: False,
						Files: 
						[
							{
								AttachmentId: 00000000000000000000000000000000,
								Name: String,
								Kind: String,
								Size: String,
								Sensitive: False,
								Locked: False
							}
						]
					}
				]
			}
		]
	},
	ResponseStatus: 
	{
		ErrorCode: String,
		Message: String,
		StackTrace: String,
		Errors: 
		[
			{
				ErrorCode: String,
				FieldName: String,
				Message: String,
				Meta: 
				{
					String: String
				}
			}
		],
		Meta: 
		{
			String: String
		}
	}
}