/* Options:
Date: 2024-10-18 04:26:08
Version: 6.40
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://digiofficeapigateway.deltares.nl/api

//GlobalNamespace: 
//AddServiceStackTypes: True
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
IncludeTypes: GenerateDocumentBatch.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart,dart:typed_data
*/

import 'package:servicestack/servicestack.dart';
import 'dart:typed_data';

class UserReference implements IEntityReference, IConvertible
{
    int? ID;
    String? LoginName;
    String? UserPrincipalName;
    String? FullName;
    String? EmailAddress;
    String? GlobalID;

    UserReference({this.ID,this.LoginName,this.UserPrincipalName,this.FullName,this.EmailAddress,this.GlobalID});
    UserReference.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ID = json['ID'];
        LoginName = json['LoginName'];
        UserPrincipalName = json['UserPrincipalName'];
        FullName = json['FullName'];
        EmailAddress = json['EmailAddress'];
        GlobalID = json['GlobalID'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ID': ID,
        'LoginName': LoginName,
        'UserPrincipalName': UserPrincipalName,
        'FullName': FullName,
        'EmailAddress': EmailAddress,
        'GlobalID': GlobalID
    };

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

class DocumentgeneratorDocumentReference implements IEntityReference, IConvertible
{
    String? ID;
    String? Name;
    String? GlobalID;

    DocumentgeneratorDocumentReference({this.ID,this.Name,this.GlobalID});
    DocumentgeneratorDocumentReference.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'ID': ID,
        'Name': Name,
        'GlobalID': GlobalID
    };

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

class RegistrationProfileReference implements IEntityReference, IConvertible
{
    String? ID;
    String? GlobalID;

    RegistrationProfileReference({this.ID,this.GlobalID});
    RegistrationProfileReference.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'ID': ID,
        'GlobalID': GlobalID
    };

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

class DocumentReference implements IEntityReference, IConvertible
{
    String? ID;
    String? Code;
    String? VersionCode;
    String? RootDocID;
    String? InternalInvoiceCode;
    int? CompanyNumber;
    String? DocumentTypeID;
    int? InvoiceType;
    int? RegProfCatID;
    String? GlobalID;
    String? ExternalID;
    String? ExternNr;
    String? InternNummer;

    DocumentReference({this.ID,this.Code,this.VersionCode,this.RootDocID,this.InternalInvoiceCode,this.CompanyNumber,this.DocumentTypeID,this.InvoiceType,this.RegProfCatID,this.GlobalID,this.ExternalID,this.ExternNr,this.InternNummer});
    DocumentReference.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ID = json['ID'];
        Code = json['Code'];
        VersionCode = json['VersionCode'];
        RootDocID = json['RootDocID'];
        InternalInvoiceCode = json['InternalInvoiceCode'];
        CompanyNumber = json['CompanyNumber'];
        DocumentTypeID = json['DocumentTypeID'];
        InvoiceType = json['InvoiceType'];
        RegProfCatID = json['RegProfCatID'];
        GlobalID = json['GlobalID'];
        ExternalID = json['ExternalID'];
        ExternNr = json['ExternNr'];
        InternNummer = json['InternNummer'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ID': ID,
        'Code': Code,
        'VersionCode': VersionCode,
        'RootDocID': RootDocID,
        'InternalInvoiceCode': InternalInvoiceCode,
        'CompanyNumber': CompanyNumber,
        'DocumentTypeID': DocumentTypeID,
        'InvoiceType': InvoiceType,
        'RegProfCatID': RegProfCatID,
        'GlobalID': GlobalID,
        'ExternalID': ExternalID,
        'ExternNr': ExternNr,
        'InternNummer': InternNummer
    };

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

class MessageQueueReference implements IEntityReference, IConvertible
{
    int? ID;
    String? GlobalID;

    MessageQueueReference({this.ID,this.GlobalID});
    MessageQueueReference.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'ID': ID,
        'GlobalID': GlobalID
    };

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

class ConfigurationSource implements IConvertible
{
    /**
    * Document genereren op basis van een DocGenDocument.
    */
    DocumentgeneratorDocumentReference? DocumentgeneratorDocument;
    /**
    * Document genereren op basis van een RegistratieProfiel.
    */
    RegistrationProfileReference? RegistrationProfile;
    /**
    * Use existing document registration.
    */
    DocumentReference? RegisteredDocument;
    /**
    * Use draft document registration.
    */
    MessageQueueReference? DraftDocumentRegistration;
    String? DocumentgeneratorType;
    /**
    * DocumentgeneratorType voor bijvoorbeeld Word of Email.
    */
    String? DocumentgeneratorTypeName;
    String? TemplateExtension;
    String? OutputExtension;

    ConfigurationSource({this.DocumentgeneratorDocument,this.RegistrationProfile,this.RegisteredDocument,this.DraftDocumentRegistration,this.DocumentgeneratorType,this.DocumentgeneratorTypeName,this.TemplateExtension,this.OutputExtension});
    ConfigurationSource.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        DocumentgeneratorDocument = JsonConverters.fromJson(json['DocumentgeneratorDocument'],'DocumentgeneratorDocumentReference',context!);
        RegistrationProfile = JsonConverters.fromJson(json['RegistrationProfile'],'RegistrationProfileReference',context!);
        RegisteredDocument = JsonConverters.fromJson(json['RegisteredDocument'],'DocumentReference',context!);
        DraftDocumentRegistration = JsonConverters.fromJson(json['DraftDocumentRegistration'],'MessageQueueReference',context!);
        DocumentgeneratorType = JsonConverters.fromJson(json['DocumentgeneratorType'],'String',context!);
        DocumentgeneratorTypeName = json['DocumentgeneratorTypeName'];
        TemplateExtension = json['TemplateExtension'];
        OutputExtension = json['OutputExtension'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'DocumentgeneratorDocument': JsonConverters.toJson(DocumentgeneratorDocument,'DocumentgeneratorDocumentReference',context!),
        'RegistrationProfile': JsonConverters.toJson(RegistrationProfile,'RegistrationProfileReference',context!),
        'RegisteredDocument': JsonConverters.toJson(RegisteredDocument,'DocumentReference',context!),
        'DraftDocumentRegistration': JsonConverters.toJson(DraftDocumentRegistration,'MessageQueueReference',context!),
        'DocumentgeneratorType': JsonConverters.toJson(DocumentgeneratorType,'String',context!),
        'DocumentgeneratorTypeName': DocumentgeneratorTypeName,
        'TemplateExtension': TemplateExtension,
        'OutputExtension': OutputExtension
    };

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

enum VersioningType
{
    New,
    Change,
    Primary,
    Secondary,
}

class CompanyReference implements IEntityReference, IConvertible
{
    int? ID;
    int? Number;
    String? GlobalID;
    String? ExternalID;

    CompanyReference({this.ID,this.Number,this.GlobalID,this.ExternalID});
    CompanyReference.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ID = json['ID'];
        Number = json['Number'];
        GlobalID = json['GlobalID'];
        ExternalID = json['ExternalID'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ID': ID,
        'Number': Number,
        'GlobalID': GlobalID,
        'ExternalID': ExternalID
    };

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

class RelationReference implements IEntityReference, IConvertible
{
    int? ID;
    int? CreditorNumber;
    int? DebtorNumber;
    String? GlobalLocationNumber;
    String? GlobalID;
    String? ExternalID;

    RelationReference({this.ID,this.CreditorNumber,this.DebtorNumber,this.GlobalLocationNumber,this.GlobalID,this.ExternalID});
    RelationReference.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ID = json['ID'];
        CreditorNumber = json['CreditorNumber'];
        DebtorNumber = json['DebtorNumber'];
        GlobalLocationNumber = json['GlobalLocationNumber'];
        GlobalID = json['GlobalID'];
        ExternalID = json['ExternalID'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ID': ID,
        'CreditorNumber': CreditorNumber,
        'DebtorNumber': DebtorNumber,
        'GlobalLocationNumber': GlobalLocationNumber,
        'GlobalID': GlobalID,
        'ExternalID': ExternalID
    };

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

class PersonReference implements IEntityReference, IConvertible
{
    int? ID;
    int? Number;
    String? GlobalID;
    String? ExternalID;

    PersonReference({this.ID,this.Number,this.GlobalID,this.ExternalID});
    PersonReference.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ID = json['ID'];
        Number = json['Number'];
        GlobalID = json['GlobalID'];
        ExternalID = json['ExternalID'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ID': ID,
        'Number': Number,
        'GlobalID': GlobalID,
        'ExternalID': ExternalID
    };

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

class ProjectReference implements IEntityReference, IConvertible
{
    int? ID;
    String? Code;
    String? TypeExternalID;
    int? CompanyNumber;
    String? GlobalID;
    String? ExternalID;

    ProjectReference({this.ID,this.Code,this.TypeExternalID,this.CompanyNumber,this.GlobalID,this.ExternalID});
    ProjectReference.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ID = json['ID'];
        Code = json['Code'];
        TypeExternalID = json['TypeExternalID'];
        CompanyNumber = json['CompanyNumber'];
        GlobalID = json['GlobalID'];
        ExternalID = json['ExternalID'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ID': ID,
        'Code': Code,
        'TypeExternalID': TypeExternalID,
        'CompanyNumber': CompanyNumber,
        'GlobalID': GlobalID,
        'ExternalID': ExternalID
    };

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

class SubProject implements IConvertible
{
    ProjectReference? Project;

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

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

    Map<String, dynamic> toJson() => {
        'Project': JsonConverters.toJson(Project,'ProjectReference',context!)
    };

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

class ContactPersonReference implements IEntityReference, IConvertible
{
    int? ID;
    String? GlobalID;
    String? ExternalID;
    int? RelationID;
    int? PersonID;

    ContactPersonReference({this.ID,this.GlobalID,this.ExternalID,this.RelationID,this.PersonID});
    ContactPersonReference.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ID = json['ID'];
        GlobalID = json['GlobalID'];
        ExternalID = json['ExternalID'];
        RelationID = json['RelationID'];
        PersonID = json['PersonID'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ID': ID,
        'GlobalID': GlobalID,
        'ExternalID': ExternalID,
        'RelationID': RelationID,
        'PersonID': PersonID
    };

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

enum SignerType
{
    MainSigner,
    AdditionalSigner,
    ConfirmationDeclarant,
    AdditionalConfirmationDeclarant,
}

class Signer implements IConvertible
{
    UserReference? User;
    PersonReference? Person;
    RelationReference? Relation;
    ContactPersonReference? ContactPerson;
    DocumentReference? RegisteredDocument;
    SignerType? Type;
    String? ClosingSentence;
    String? Name;
    String? Subsidiary;
    String? Function;
    String? Department;
    String? PhoneNumber;
    String? FaxNumber;
    String? MobileNumber;
    String? Email;
    String? CustomText;
    List<String>? Signature;
    bool? SignatureVisible;
    bool? Visible;

    Signer({this.User,this.Person,this.Relation,this.ContactPerson,this.RegisteredDocument,this.Type,this.ClosingSentence,this.Name,this.Subsidiary,this.Function,this.Department,this.PhoneNumber,this.FaxNumber,this.MobileNumber,this.Email,this.CustomText,this.Signature,this.SignatureVisible,this.Visible});
    Signer.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        User = JsonConverters.fromJson(json['User'],'UserReference',context!);
        Person = JsonConverters.fromJson(json['Person'],'PersonReference',context!);
        Relation = JsonConverters.fromJson(json['Relation'],'RelationReference',context!);
        ContactPerson = JsonConverters.fromJson(json['ContactPerson'],'ContactPersonReference',context!);
        RegisteredDocument = JsonConverters.fromJson(json['RegisteredDocument'],'DocumentReference',context!);
        Type = JsonConverters.fromJson(json['Type'],'SignerType',context!);
        ClosingSentence = json['ClosingSentence'];
        Name = json['Name'];
        Subsidiary = json['Subsidiary'];
        Function = json['Function'];
        Department = json['Department'];
        PhoneNumber = json['PhoneNumber'];
        FaxNumber = json['FaxNumber'];
        MobileNumber = json['MobileNumber'];
        Email = json['Email'];
        CustomText = json['CustomText'];
        Signature = JsonConverters.fromJson(json['Signature'],'List<String>',context!);
        SignatureVisible = json['SignatureVisible'];
        Visible = json['Visible'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'User': JsonConverters.toJson(User,'UserReference',context!),
        'Person': JsonConverters.toJson(Person,'PersonReference',context!),
        'Relation': JsonConverters.toJson(Relation,'RelationReference',context!),
        'ContactPerson': JsonConverters.toJson(ContactPerson,'ContactPersonReference',context!),
        'RegisteredDocument': JsonConverters.toJson(RegisteredDocument,'DocumentReference',context!),
        'Type': JsonConverters.toJson(Type,'SignerType',context!),
        'ClosingSentence': ClosingSentence,
        'Name': Name,
        'Subsidiary': Subsidiary,
        'Function': Function,
        'Department': Department,
        'PhoneNumber': PhoneNumber,
        'FaxNumber': FaxNumber,
        'MobileNumber': MobileNumber,
        'Email': Email,
        'CustomText': CustomText,
        'Signature': JsonConverters.toJson(Signature,'List<String>',context!),
        'SignatureVisible': SignatureVisible,
        'Visible': Visible
    };

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

class Field implements IConvertible
{
    String? Name;
    String? OldValue;
    String? Value;
    String? Title;

    Field({this.Name,this.OldValue,this.Value,this.Title});
    Field.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Name = json['Name'];
        OldValue = json['OldValue'];
        Value = json['Value'];
        Title = json['Title'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Name': Name,
        'OldValue': OldValue,
        'Value': Value,
        'Title': Title
    };

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

class AttachmentData implements IConvertible
{
    String? ContentType;
    /**
    * Data base64-encoded zonder padding.
    */
    String? Data;

    AttachmentData({this.ContentType,this.Data});
    AttachmentData.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'ContentType': ContentType,
        'Data': Data
    };

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

class Attachment implements IConvertible
{
    String? Name;
    AttachmentData? AttachmentData;

    Attachment({this.Name,this.AttachmentData});
    Attachment.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Name': Name,
        'AttachmentData': JsonConverters.toJson(AttachmentData,'AttachmentData',context!)
    };

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

class RegistrationMetaData implements IConvertible
{
    /**
    * Hoe moet het versiebeheer worden toegepast?
    */
    // @ApiMember(Description="Hoe moet het versiebeheer worden toegepast?")
    VersioningType? Versioning;

    /**
    * Previous document will be used for registration of a new version.
    */
    // @ApiMember(Description="Previous document will be used for registration of a new version.")
    DocumentReference? PreviousDocument;

    /**
    * Company
    */
    // @ApiMember(Description="Company")
    CompanyReference? Company;

    /**
    * Relation
    */
    // @ApiMember(Description="Relation")
    RelationReference? Relation;

    /**
    * Person
    */
    // @ApiMember(Description="Person")
    PersonReference? Person;

    /**
    * Project
    */
    // @ApiMember(Description="Project")
    ProjectReference? Project;

    /**
    * Sub projects
    */
    // @ApiMember(AllowMultiple=true, Description="Sub projects")
    List<SubProject>? SubProjects;

    /**
    * Signers
    */
    // @ApiMember(AllowMultiple=true, Description="Signers")
    List<Signer>? Signers;

    /**
    * Bevat velden die gebruikt worden als additionele metadata voor het document, naast de vaste koppelingen zoals gebruiker, project en relatie.
    */
    // @ApiMember(AllowMultiple=true, Description="Bevat velden die gebruikt worden als additionele metadata voor het document, naast de vaste koppelingen zoals gebruiker, project en relatie.")
    List<Field>? Fields;

    /**
    * Attachments die aan de documentregistratie gekoppeld moet worden.
    */
    // @ApiMember(AllowMultiple=true, Description="Attachments die aan de documentregistratie gekoppeld moet worden.")
    List<Attachment>? Attachments;

    RegistrationMetaData({this.Versioning,this.PreviousDocument,this.Company,this.Relation,this.Person,this.Project,this.SubProjects,this.Signers,this.Fields,this.Attachments});
    RegistrationMetaData.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Versioning = JsonConverters.fromJson(json['Versioning'],'VersioningType',context!);
        PreviousDocument = JsonConverters.fromJson(json['PreviousDocument'],'DocumentReference',context!);
        Company = JsonConverters.fromJson(json['Company'],'CompanyReference',context!);
        Relation = JsonConverters.fromJson(json['Relation'],'RelationReference',context!);
        Person = JsonConverters.fromJson(json['Person'],'PersonReference',context!);
        Project = JsonConverters.fromJson(json['Project'],'ProjectReference',context!);
        SubProjects = JsonConverters.fromJson(json['SubProjects'],'List<SubProject>',context!);
        Signers = JsonConverters.fromJson(json['Signers'],'List<Signer>',context!);
        Fields = JsonConverters.fromJson(json['Fields'],'List<Field>',context!);
        Attachments = JsonConverters.fromJson(json['Attachments'],'List<Attachment>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Versioning': JsonConverters.toJson(Versioning,'VersioningType',context!),
        'PreviousDocument': JsonConverters.toJson(PreviousDocument,'DocumentReference',context!),
        'Company': JsonConverters.toJson(Company,'CompanyReference',context!),
        'Relation': JsonConverters.toJson(Relation,'RelationReference',context!),
        'Person': JsonConverters.toJson(Person,'PersonReference',context!),
        'Project': JsonConverters.toJson(Project,'ProjectReference',context!),
        'SubProjects': JsonConverters.toJson(SubProjects,'List<SubProject>',context!),
        'Signers': JsonConverters.toJson(Signers,'List<Signer>',context!),
        'Fields': JsonConverters.toJson(Fields,'List<Field>',context!),
        'Attachments': JsonConverters.toJson(Attachments,'List<Attachment>',context!)
    };

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

class CommonEntityBaseReference implements IEntityReference, IConvertible
{
    String? ID;
    String? ExternalID;
    String? GlobalID;

    CommonEntityBaseReference({this.ID,this.ExternalID,this.GlobalID});
    CommonEntityBaseReference.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ID = json['ID'];
        ExternalID = json['ExternalID'];
        GlobalID = json['GlobalID'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ID': ID,
        'ExternalID': ExternalID,
        'GlobalID': GlobalID
    };

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

enum Direction
{
    Left2Right,
    UpLeft2DownRight,
    Up2Down,
    UpRight2DownLeft,
    Right2Left,
    DownRight2UpLeft,
    Down2Up,
    DownLeft2UpRight,
}

class Watermark implements IConvertible
{
    String? Text;
    String? FontFamilyText;
    FontFamily? FontFamily;
    Direction? Direction;
    String? StrokeColorText;
    Color? StrokeColor;
    String? FillColorText;
    Color? FillColor;

    Watermark({this.Text,this.FontFamilyText,this.FontFamily,this.Direction,this.StrokeColorText,this.StrokeColor,this.FillColorText,this.FillColor});
    Watermark.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Text = json['Text'];
        FontFamilyText = json['FontFamilyText'];
        FontFamily = JsonConverters.fromJson(json['FontFamily'],'FontFamily',context!);
        Direction = JsonConverters.fromJson(json['Direction'],'Direction',context!);
        StrokeColorText = json['StrokeColorText'];
        StrokeColor = JsonConverters.fromJson(json['StrokeColor'],'Color',context!);
        FillColorText = json['FillColorText'];
        FillColor = JsonConverters.fromJson(json['FillColor'],'Color',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Text': Text,
        'FontFamilyText': FontFamilyText,
        'FontFamily': JsonConverters.toJson(FontFamily,'FontFamily',context!),
        'Direction': JsonConverters.toJson(Direction,'Direction',context!),
        'StrokeColorText': StrokeColorText,
        'StrokeColor': JsonConverters.toJson(StrokeColor,'Color',context!),
        'FillColorText': FillColorText,
        'FillColor': JsonConverters.toJson(FillColor,'Color',context!)
    };

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

class BatchDocument implements IDocument, IConvertible
{
    /**
    * ConfigurationSource: DocumentgeneratorDocument of RegistratieProfiel.
    */
    // @ApiMember(Description="ConfigurationSource: DocumentgeneratorDocument of RegistratieProfiel.", IsRequired=true)
    ConfigurationSource? ConfigurationSource;

    /**
    * Set references to bind with Registration profile
    */
    // @ApiMember(Description="Set references to bind with Registration profile", IsRequired=true)
    RegistrationMetaData? RegistrationMetaData;

    /**
    * Entity instance used as data source parent, if not exists default is Document registration instance.
    */
    // @ApiMember(Description="Entity instance used as data source parent, if not exists default is Document registration instance.")
    CommonEntityBaseReference? DataSourceEntity;

    /**
    * Hier kan de (dynamische) data voor het document geplaatst worden, de data kan middels tekstblokken en placeholders worden geplaatst.Het formaat binnen CustomData staat vrij maar vereist een 'root' element.
    */
    // @ApiMember(Description="Hier kan de (dynamische) data voor het document geplaatst worden, de data kan middels tekstblokken en placeholders worden geplaatst.Het formaat binnen CustomData staat vrij maar vereist een 'root' element.")
    String? CustomData;

    /**
    * Insert a watermark into the document.
    */
    // @ApiMember(Description="Insert a watermark into the document.")
    Watermark? Watermark;

    /**
    * Type van het gegenereerde document, bijvoorbeeld: Doc, Docx, Pdf.
    */
    // @ApiMember(Description="Type van het gegenereerde document, bijvoorbeeld: Doc, Docx, Pdf.")
    String? OutputType;

    BatchDocument({this.ConfigurationSource,this.RegistrationMetaData,this.DataSourceEntity,this.CustomData,this.Watermark,this.OutputType});
    BatchDocument.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ConfigurationSource = JsonConverters.fromJson(json['ConfigurationSource'],'ConfigurationSource',context!);
        RegistrationMetaData = JsonConverters.fromJson(json['RegistrationMetaData'],'RegistrationMetaData',context!);
        DataSourceEntity = JsonConverters.fromJson(json['DataSourceEntity'],'CommonEntityBaseReference',context!);
        CustomData = json['CustomData'];
        Watermark = JsonConverters.fromJson(json['Watermark'],'Watermark',context!);
        OutputType = json['OutputType'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ConfigurationSource': JsonConverters.toJson(ConfigurationSource,'ConfigurationSource',context!),
        'RegistrationMetaData': JsonConverters.toJson(RegistrationMetaData,'RegistrationMetaData',context!),
        'DataSourceEntity': JsonConverters.toJson(DataSourceEntity,'CommonEntityBaseReference',context!),
        'CustomData': CustomData,
        'Watermark': JsonConverters.toJson(Watermark,'Watermark',context!),
        'OutputType': OutputType
    };

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

abstract class IGenerateDocumentBatch
{
    UserReference? User;
    String? Description;
    List<BatchDocument>? Documents;
    bool? DontRegister;
    bool? SendMail;
}

abstract class IDocument
{
    ConfigurationSource? ConfigurationSource;
    CommonEntityBaseReference? DataSourceEntity;
    RegistrationMetaData? RegistrationMetaData;
    String? CustomData;
    Watermark? Watermark;
    String? OutputType;
}

abstract class IGenerateDocumentBatchResponse
{
    String? BatchID;
    int? Processed;
    String? TrackAndTraceUrl;
}

abstract class IEntityReference
{
    String? GlobalID;
}

class GenerateDocumentBatchResponse implements IGenerateDocumentBatchResponse, IConvertible
{
    /**
    * ID of the batch
    */
    // @ApiMember(Description="ID of the batch", IsRequired=true)
    String? BatchID;

    /**
    * Document processed count
    */
    // @ApiMember(Description="Document processed count", IsRequired=true)
    int? Processed;

    /**
    * Track and Trace url
    */
    // @ApiMember(Description="Track and Trace url", IsRequired=true)
    String? TrackAndTraceUrl;

    GenerateDocumentBatchResponse({this.BatchID,this.Processed,this.TrackAndTraceUrl});
    GenerateDocumentBatchResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        BatchID = json['BatchID'];
        Processed = json['Processed'];
        TrackAndTraceUrl = json['TrackAndTraceUrl'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'BatchID': BatchID,
        'Processed': Processed,
        'TrackAndTraceUrl': TrackAndTraceUrl
    };

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

/**
* Queue multiple (corporate identity) document(s) to generate later via the DigiOffice background agent.
*/
// @Api(Description="Queue multiple (corporate identity) document(s) to generate later via the DigiOffice background agent.")
class GenerateDocumentBatch implements IReturn<GenerateDocumentBatchResponse>, IGenerateDocumentBatch, IConvertible
{
    /**
    * Owner of the badge (DigiOffice user)
    */
    // @ApiMember(Description="Owner of the badge (DigiOffice user)")
    UserReference? User;

    /**
    * Description of the badge
    */
    // @ApiMember(Description="Description of the badge", IsRequired=true)
    String? Description;

    /**
    * Corporate identity document(s) to be generate
    */
    // @ApiMember(AllowMultiple=true, Description="Corporate identity document(s) to be generate", IsRequired=true)
    List<BatchDocument>? Documents;

    /**
    * Generated document is not registered in DigiOffice DMS.
    */
    // @ApiMember(Description="Generated document is not registered in DigiOffice DMS.")
    bool? DontRegister;

    /**
    * Send the generated e-mail via the e-mail queue.
    */
    // @ApiMember(Description="Send the generated e-mail via the e-mail queue.")
    bool? SendMail;

    GenerateDocumentBatch({this.User,this.Description,this.Documents,this.DontRegister,this.SendMail});
    GenerateDocumentBatch.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        User = JsonConverters.fromJson(json['User'],'UserReference',context!);
        Description = json['Description'];
        Documents = JsonConverters.fromJson(json['Documents'],'List<BatchDocument>',context!);
        DontRegister = json['DontRegister'];
        SendMail = json['SendMail'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'User': JsonConverters.toJson(User,'UserReference',context!),
        'Description': Description,
        'Documents': JsonConverters.toJson(Documents,'List<BatchDocument>',context!),
        'DontRegister': DontRegister,
        'SendMail': SendMail
    };

    createResponse() => GenerateDocumentBatchResponse();
    getResponseTypeName() => "GenerateDocumentBatchResponse";
    getTypeName() => "GenerateDocumentBatch";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'digiofficeapigateway.deltares.nl', types: <String, TypeInfo> {
    'UserReference': TypeInfo(TypeOf.Class, create:() => UserReference()),
    'DocumentgeneratorDocumentReference': TypeInfo(TypeOf.Class, create:() => DocumentgeneratorDocumentReference()),
    'RegistrationProfileReference': TypeInfo(TypeOf.Class, create:() => RegistrationProfileReference()),
    'DocumentReference': TypeInfo(TypeOf.Class, create:() => DocumentReference()),
    'MessageQueueReference': TypeInfo(TypeOf.Class, create:() => MessageQueueReference()),
    'ConfigurationSource': TypeInfo(TypeOf.Class, create:() => ConfigurationSource()),
    'VersioningType': TypeInfo(TypeOf.Enum, enumValues:VersioningType.values),
    'CompanyReference': TypeInfo(TypeOf.Class, create:() => CompanyReference()),
    'RelationReference': TypeInfo(TypeOf.Class, create:() => RelationReference()),
    'PersonReference': TypeInfo(TypeOf.Class, create:() => PersonReference()),
    'ProjectReference': TypeInfo(TypeOf.Class, create:() => ProjectReference()),
    'SubProject': TypeInfo(TypeOf.Class, create:() => SubProject()),
    'ContactPersonReference': TypeInfo(TypeOf.Class, create:() => ContactPersonReference()),
    'SignerType': TypeInfo(TypeOf.Enum, enumValues:SignerType.values),
    'Signer': TypeInfo(TypeOf.Class, create:() => Signer()),
    'Field': TypeInfo(TypeOf.Class, create:() => Field()),
    'AttachmentData': TypeInfo(TypeOf.Class, create:() => AttachmentData()),
    'Attachment': TypeInfo(TypeOf.Class, create:() => Attachment()),
    'RegistrationMetaData': TypeInfo(TypeOf.Class, create:() => RegistrationMetaData()),
    'List<SubProject>': TypeInfo(TypeOf.Class, create:() => <SubProject>[]),
    'List<Signer>': TypeInfo(TypeOf.Class, create:() => <Signer>[]),
    'List<Field>': TypeInfo(TypeOf.Class, create:() => <Field>[]),
    'List<Attachment>': TypeInfo(TypeOf.Class, create:() => <Attachment>[]),
    'CommonEntityBaseReference': TypeInfo(TypeOf.Class, create:() => CommonEntityBaseReference()),
    'Direction': TypeInfo(TypeOf.Enum, enumValues:Direction.values),
    'Watermark': TypeInfo(TypeOf.Class, create:() => Watermark()),
    'FontFamily': TypeInfo(TypeOf.Class, create:() => FontFamily()),
    'Color': TypeInfo(TypeOf.Class, create:() => Color()),
    'BatchDocument': TypeInfo(TypeOf.Class, create:() => BatchDocument()),
    'IGenerateDocumentBatch': TypeInfo(TypeOf.Interface),
    'IDocument': TypeInfo(TypeOf.Interface),
    'IGenerateDocumentBatchResponse': TypeInfo(TypeOf.Interface),
    'IEntityReference': TypeInfo(TypeOf.Interface),
    'GenerateDocumentBatchResponse': TypeInfo(TypeOf.Class, create:() => GenerateDocumentBatchResponse()),
    'GenerateDocumentBatch': TypeInfo(TypeOf.Class, create:() => GenerateDocumentBatch()),
    'List<BatchDocument>': TypeInfo(TypeOf.Class, create:() => <BatchDocument>[]),
});