/* Options:
Date: 2024-10-18 04:31:06
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: GenerateDocument.*
//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;
}

abstract class IGenerateDocument extends IDocument
{
    UserReference? User;
    bool? SendMail;
    bool? ShouldUpdateDocumentFile;
}

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

abstract class IGenerateDocumentResponse
{
    String? DocumentID;
}

abstract class IEntityReference
{
    String? GlobalID;
}

class GenerateDocumentResponse implements IGenerateDocumentResponse, IConvertible
{
    /**
    * Contains the registration ID of the generated (corporate identity) document
    */
    // @ApiMember(Description="Contains the registration ID of the generated (corporate identity) document", IsRequired=true)
    String? DocumentID;

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

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

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

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

/**
* Generate custom Document (Don't use from inside VSTO's)
*/
// @Api(Description="Generate custom Document (Don't use from inside VSTO's)")
class GenerateDocument implements IReturn<GenerateDocumentResponse>, IGenerateDocument, IConvertible
{
    /**
    * DigiOffice user
    */
    // @ApiMember(Description="DigiOffice user")
    UserReference? User;

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

    /**
    * 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;

    /**
    * Should update the document file.
    */
    // @ApiMember(Description="Should update the document file.")
    bool? ShouldUpdateDocumentFile;

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

    fromMap(Map<String, dynamic> json) {
        User = JsonConverters.fromJson(json['User'],'UserReference',context!);
        SendMail = json['SendMail'];
        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'];
        ShouldUpdateDocumentFile = json['ShouldUpdateDocumentFile'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'User': JsonConverters.toJson(User,'UserReference',context!),
        'SendMail': SendMail,
        '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,
        'ShouldUpdateDocumentFile': ShouldUpdateDocumentFile
    };

    createResponse() => GenerateDocumentResponse();
    getResponseTypeName() => "GenerateDocumentResponse";
    getTypeName() => "GenerateDocument";
    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()),
    'IGenerateDocument': TypeInfo(TypeOf.Interface),
    'IDocument': TypeInfo(TypeOf.Interface),
    'IGenerateDocumentResponse': TypeInfo(TypeOf.Interface),
    'IEntityReference': TypeInfo(TypeOf.Interface),
    'GenerateDocumentResponse': TypeInfo(TypeOf.Class, create:() => GenerateDocumentResponse()),
    'GenerateDocument': TypeInfo(TypeOf.Class, create:() => GenerateDocument()),
});