/* Options:
Date: 2026-02-04 10:32:47
Version: 6.110
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://etc-api.vsmlab.vn

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

import 'package:servicestack/servicestack.dart';

enum CategoryTypes
{
    Department,
    PartyGroup,
    DocGroup,
    DocType,
    IssuingAgency,
    Status,
    Subjects,
    Workflow,
    WorkStatus,
    StepStatus,
    SignStatus,
}

class CreateCategoryModel implements IConvertible
{
    String? name;
    String? description;
    CategoryTypes? type;
    bool? isParty;
    // @ignore()
    List<int>? childList;

    CreateCategoryModel({this.name,this.description,this.type,this.isParty,this.childList});
    CreateCategoryModel.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        description = json['description'];
        type = JsonConverters.fromJson(json['type'],'CategoryTypes',context!);
        isParty = json['isParty'];
        childList = JsonConverters.fromJson(json['childList'],'List<int>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'description': description,
        'type': JsonConverters.toJson(type,'CategoryTypes',context!),
        'isParty': isParty,
        'childList': JsonConverters.toJson(childList,'List<int>',context!)
    };

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

class BasicUploadedFile implements IConvertible
{
    String? fileName;
    String? filekey;
    String? fileUrl;
    String? checksum;
    String? eTag;
    int? fileSize;

    BasicUploadedFile({this.fileName,this.filekey,this.fileUrl,this.checksum,this.eTag,this.fileSize});
    BasicUploadedFile.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        fileName = json['fileName'];
        filekey = json['filekey'];
        fileUrl = json['fileUrl'];
        checksum = json['checksum'];
        eTag = json['eTag'];
        fileSize = json['fileSize'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'fileName': fileName,
        'filekey': filekey,
        'fileUrl': fileUrl,
        'checksum': checksum,
        'eTag': eTag,
        'fileSize': fileSize
    };

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

class UploadedFiles extends BasicUploadedFile implements IConvertible
{
    int? id;
    String? uploadedFile;
    int? subDocumentId;
    int? stepId;
    int? code;

    UploadedFiles({this.id,this.uploadedFile,this.subDocumentId,this.stepId,this.code});
    UploadedFiles.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        id = json['id'];
        uploadedFile = json['uploadedFile'];
        subDocumentId = json['subDocumentId'];
        stepId = json['stepId'];
        code = json['code'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'id': id,
        'uploadedFile': uploadedFile,
        'subDocumentId': subDocumentId,
        'stepId': stepId,
        'code': code
    });

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

class SimpleDocumentRelation implements IConvertible
{
    int? id;
    String? title;
    String? documentCode;
    DateTime? publicationDate;
    bool? isSequentialSigning;
    String? statusText;
    int? documentTypeId;

    SimpleDocumentRelation({this.id,this.title,this.documentCode,this.publicationDate,this.isSequentialSigning,this.statusText,this.documentTypeId});
    SimpleDocumentRelation.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        title = json['title'];
        documentCode = json['documentCode'];
        publicationDate = JsonConverters.fromJson(json['publicationDate'],'DateTime',context!);
        isSequentialSigning = json['isSequentialSigning'];
        statusText = json['statusText'];
        documentTypeId = json['documentTypeId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'title': title,
        'documentCode': documentCode,
        'publicationDate': JsonConverters.toJson(publicationDate,'DateTime',context!),
        'isSequentialSigning': isSequentialSigning,
        'statusText': statusText,
        'documentTypeId': documentTypeId
    };

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

class BasicDocument implements IConvertible
{
    // @required()
    String? title;

    // @StringLength(4000)
    String? description;

    // @StringLength(500)
    String? owner;

    int? documentPolicyId;
    int? updateDocumentId;
    DateTime? effectBeginDate;
    DateTime? effectEndDate;
    int? issuingAgencyId;
    int? documentTypeId;
    int? documentGroupId;
    int? subjectId;
    // @StringLength(500)
    String? signBy;

    DateTime? signDate;
    int? statusId;
    bool? isInternal;
    String? documentNumber;
    String? documentCode;
    bool? isUrgent;
    int? scopeType;
    bool? isActive;

    BasicDocument({this.title,this.description,this.owner,this.documentPolicyId,this.updateDocumentId,this.effectBeginDate,this.effectEndDate,this.issuingAgencyId,this.documentTypeId,this.documentGroupId,this.subjectId,this.signBy,this.signDate,this.statusId,this.isInternal,this.documentNumber,this.documentCode,this.isUrgent,this.scopeType,this.isActive});
    BasicDocument.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        title = json['title'];
        description = json['description'];
        owner = json['owner'];
        documentPolicyId = json['documentPolicyId'];
        updateDocumentId = json['updateDocumentId'];
        effectBeginDate = JsonConverters.fromJson(json['effectBeginDate'],'DateTime',context!);
        effectEndDate = JsonConverters.fromJson(json['effectEndDate'],'DateTime',context!);
        issuingAgencyId = json['issuingAgencyId'];
        documentTypeId = json['documentTypeId'];
        documentGroupId = json['documentGroupId'];
        subjectId = json['subjectId'];
        signBy = json['signBy'];
        signDate = JsonConverters.fromJson(json['signDate'],'DateTime',context!);
        statusId = json['statusId'];
        isInternal = json['isInternal'];
        documentNumber = json['documentNumber'];
        documentCode = json['documentCode'];
        isUrgent = json['isUrgent'];
        scopeType = json['scopeType'];
        isActive = json['isActive'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'title': title,
        'description': description,
        'owner': owner,
        'documentPolicyId': documentPolicyId,
        'updateDocumentId': updateDocumentId,
        'effectBeginDate': JsonConverters.toJson(effectBeginDate,'DateTime',context!),
        'effectEndDate': JsonConverters.toJson(effectEndDate,'DateTime',context!),
        'issuingAgencyId': issuingAgencyId,
        'documentTypeId': documentTypeId,
        'documentGroupId': documentGroupId,
        'subjectId': subjectId,
        'signBy': signBy,
        'signDate': JsonConverters.toJson(signDate,'DateTime',context!),
        'statusId': statusId,
        'isInternal': isInternal,
        'documentNumber': documentNumber,
        'documentCode': documentCode,
        'isUrgent': isUrgent,
        'scopeType': scopeType,
        'isActive': isActive
    };

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

class BasicSignerConfig implements IConvertible
{
    int? subDocumentId;
    int? departmentId;
    int? signerType;
    int? signerRefId;
    // @ignore()
    String? signerRefText;

    int? actionType;
    int? orderIndex;

    BasicSignerConfig({this.subDocumentId,this.departmentId,this.signerType,this.signerRefId,this.signerRefText,this.actionType,this.orderIndex});
    BasicSignerConfig.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        subDocumentId = json['subDocumentId'];
        departmentId = json['departmentId'];
        signerType = json['signerType'];
        signerRefId = json['signerRefId'];
        signerRefText = json['signerRefText'];
        actionType = json['actionType'];
        orderIndex = json['orderIndex'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'subDocumentId': subDocumentId,
        'departmentId': departmentId,
        'signerType': signerType,
        'signerRefId': signerRefId,
        'signerRefText': signerRefText,
        'actionType': actionType,
        'orderIndex': orderIndex
    };

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

class SignerConfig extends BasicSignerConfig implements IConvertible
{
    int? id;
    int? documentId;
    int? stepId;

    SignerConfig({this.id,this.documentId,this.stepId});
    SignerConfig.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        id = json['id'];
        documentId = json['documentId'];
        stepId = json['stepId'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'id': id,
        'documentId': documentId,
        'stepId': stepId
    });

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

class WorkFlowProfile implements IConvertible
{
    int? id;
    String? name;
    String? fullName;
    String? email;
    int? departmentId;
    String? avatar;
    String? telephone;
    DateTime? birthday;
    int? confirmStatus;
    String? confirmStatusText;
    DateTime? signAt;
    int? signedFileId;
    int? originalFileId;
    String? signedFileName;
    bool? isSigned;
    String? signStatusText;

    WorkFlowProfile({this.id,this.name,this.fullName,this.email,this.departmentId,this.avatar,this.telephone,this.birthday,this.confirmStatus,this.confirmStatusText,this.signAt,this.signedFileId,this.originalFileId,this.signedFileName,this.isSigned,this.signStatusText});
    WorkFlowProfile.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        fullName = json['fullName'];
        email = json['email'];
        departmentId = json['departmentId'];
        avatar = json['avatar'];
        telephone = json['telephone'];
        birthday = JsonConverters.fromJson(json['birthday'],'DateTime',context!);
        confirmStatus = json['confirmStatus'];
        confirmStatusText = json['confirmStatusText'];
        signAt = JsonConverters.fromJson(json['signAt'],'DateTime',context!);
        signedFileId = json['signedFileId'];
        originalFileId = json['originalFileId'];
        signedFileName = json['signedFileName'];
        isSigned = json['isSigned'];
        signStatusText = json['signStatusText'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'fullName': fullName,
        'email': email,
        'departmentId': departmentId,
        'avatar': avatar,
        'telephone': telephone,
        'birthday': JsonConverters.toJson(birthday,'DateTime',context!),
        'confirmStatus': confirmStatus,
        'confirmStatusText': confirmStatusText,
        'signAt': JsonConverters.toJson(signAt,'DateTime',context!),
        'signedFileId': signedFileId,
        'originalFileId': originalFileId,
        'signedFileName': signedFileName,
        'isSigned': isSigned,
        'signStatusText': signStatusText
    };

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

class Roles implements IConvertible
{
    int? id;
    // @StringLength(50)
    String? name;

    DateTime? createdAt;
    DateTime? deletedAt;
    DateTime? updatedAt;
    int? updatedBy;
    int? deletedBy;
    int? createdBy;
    // @ignore()
    List<String>? permission;

    Roles({this.id,this.name,this.createdAt,this.deletedAt,this.updatedAt,this.updatedBy,this.deletedBy,this.createdBy,this.permission});
    Roles.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        createdAt = JsonConverters.fromJson(json['createdAt'],'DateTime',context!);
        deletedAt = JsonConverters.fromJson(json['deletedAt'],'DateTime',context!);
        updatedAt = JsonConverters.fromJson(json['updatedAt'],'DateTime',context!);
        updatedBy = json['updatedBy'];
        deletedBy = json['deletedBy'];
        createdBy = json['createdBy'];
        permission = JsonConverters.fromJson(json['permission'],'List<String>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'createdAt': JsonConverters.toJson(createdAt,'DateTime',context!),
        'deletedAt': JsonConverters.toJson(deletedAt,'DateTime',context!),
        'updatedAt': JsonConverters.toJson(updatedAt,'DateTime',context!),
        'updatedBy': updatedBy,
        'deletedBy': deletedBy,
        'createdBy': createdBy,
        'permission': JsonConverters.toJson(permission,'List<String>',context!)
    };

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

class SignerConfigDetail extends SignerConfig implements IConvertible
{
    WorkFlowProfile? profile;
    Roles? role;

    SignerConfigDetail({this.profile,this.role});
    SignerConfigDetail.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        profile = JsonConverters.fromJson(json['profile'],'WorkFlowProfile',context!);
        role = JsonConverters.fromJson(json['role'],'Roles',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'profile': JsonConverters.toJson(profile,'WorkFlowProfile',context!),
        'role': JsonConverters.toJson(role,'Roles',context!)
    });

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

class StepAttached implements IConvertible
{
    int? id;
    String? documentCode;
    String? title;
    bool? isSequentialSigning;
    UploadedFiles? pendingSignFile;
    UploadedFiles? originalFile;
    List<SignerConfigDetail>? signerConfigs;

    StepAttached({this.id,this.documentCode,this.title,this.isSequentialSigning,this.pendingSignFile,this.originalFile,this.signerConfigs});
    StepAttached.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        documentCode = json['documentCode'];
        title = json['title'];
        isSequentialSigning = json['isSequentialSigning'];
        pendingSignFile = JsonConverters.fromJson(json['pendingSignFile'],'UploadedFiles',context!);
        originalFile = JsonConverters.fromJson(json['originalFile'],'UploadedFiles',context!);
        signerConfigs = JsonConverters.fromJson(json['signerConfigs'],'List<SignerConfigDetail>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'documentCode': documentCode,
        'title': title,
        'isSequentialSigning': isSequentialSigning,
        'pendingSignFile': JsonConverters.toJson(pendingSignFile,'UploadedFiles',context!),
        'originalFile': JsonConverters.toJson(originalFile,'UploadedFiles',context!),
        'signerConfigs': JsonConverters.toJson(signerConfigs,'List<SignerConfigDetail>',context!)
    };

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

class WorkflowStep implements IConvertible
{
    int? id;
    // @References(typeof(Document))
    int? workflowId;

    int? stepOrder;
    int? statusId;
    // @required()
    // @StringLength(255)
    String? stepName;

    // @required()
    bool? isRequired;

    int? slaLegalValue;
    bool? slaLegalIsByDay;
    int? slaInternalValue;
    bool? slaInternalIsByDay;
    bool? requireAttachment;
    bool? isUsingForm;
    // @required()
    String? description;

    int? createdBy;
    // @ignore()
    List<int>? departmentIds;

    // @ignore()
    List<int>? mainAssigneeIds;

    // @ignore()
    List<int>? coDepartmentIds;

    // @ignore()
    List<int>? supportingAssigneeIds;

    // @ignore()
    List<int>? stepBasisDocumentIds;

    // @ignore()
    List<StepAttached>? attachedDocuments;

    WorkflowStep({this.id,this.workflowId,this.stepOrder,this.statusId,this.stepName,this.isRequired,this.slaLegalValue,this.slaLegalIsByDay,this.slaInternalValue,this.slaInternalIsByDay,this.requireAttachment,this.isUsingForm,this.description,this.createdBy,this.departmentIds,this.mainAssigneeIds,this.coDepartmentIds,this.supportingAssigneeIds,this.stepBasisDocumentIds,this.attachedDocuments});
    WorkflowStep.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        workflowId = json['workflowId'];
        stepOrder = json['stepOrder'];
        statusId = json['statusId'];
        stepName = json['stepName'];
        isRequired = json['isRequired'];
        slaLegalValue = json['slaLegalValue'];
        slaLegalIsByDay = json['slaLegalIsByDay'];
        slaInternalValue = json['slaInternalValue'];
        slaInternalIsByDay = json['slaInternalIsByDay'];
        requireAttachment = json['requireAttachment'];
        isUsingForm = json['isUsingForm'];
        description = json['description'];
        createdBy = json['createdBy'];
        departmentIds = JsonConverters.fromJson(json['departmentIds'],'List<int>',context!);
        mainAssigneeIds = JsonConverters.fromJson(json['mainAssigneeIds'],'List<int>',context!);
        coDepartmentIds = JsonConverters.fromJson(json['coDepartmentIds'],'List<int>',context!);
        supportingAssigneeIds = JsonConverters.fromJson(json['supportingAssigneeIds'],'List<int>',context!);
        stepBasisDocumentIds = JsonConverters.fromJson(json['stepBasisDocumentIds'],'List<int>',context!);
        attachedDocuments = JsonConverters.fromJson(json['attachedDocuments'],'List<StepAttached>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'workflowId': workflowId,
        'stepOrder': stepOrder,
        'statusId': statusId,
        'stepName': stepName,
        'isRequired': isRequired,
        'slaLegalValue': slaLegalValue,
        'slaLegalIsByDay': slaLegalIsByDay,
        'slaInternalValue': slaInternalValue,
        'slaInternalIsByDay': slaInternalIsByDay,
        'requireAttachment': requireAttachment,
        'isUsingForm': isUsingForm,
        'description': description,
        'createdBy': createdBy,
        'departmentIds': JsonConverters.toJson(departmentIds,'List<int>',context!),
        'mainAssigneeIds': JsonConverters.toJson(mainAssigneeIds,'List<int>',context!),
        'coDepartmentIds': JsonConverters.toJson(coDepartmentIds,'List<int>',context!),
        'supportingAssigneeIds': JsonConverters.toJson(supportingAssigneeIds,'List<int>',context!),
        'stepBasisDocumentIds': JsonConverters.toJson(stepBasisDocumentIds,'List<int>',context!),
        'attachedDocuments': JsonConverters.toJson(attachedDocuments,'List<StepAttached>',context!)
    };

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

abstract class IResponseRequest
{
    int? code;
    String? message;
}

class Category extends CreateCategoryModel implements IConvertible
{
    int? id;
    int? level;
    String? key;
    int? sortOrder;
    DateTime? lastUpdate;
    // @ignore()
    List<Category>? children;

    Category({this.id,this.level,this.key,this.sortOrder,this.lastUpdate,this.children});
    Category.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        id = json['id'];
        level = json['level'];
        key = json['key'];
        sortOrder = json['sortOrder'];
        lastUpdate = JsonConverters.fromJson(json['lastUpdate'],'DateTime',context!);
        children = JsonConverters.fromJson(json['children'],'List<Category>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'id': id,
        'level': level,
        'key': key,
        'sortOrder': sortOrder,
        'lastUpdate': JsonConverters.toJson(lastUpdate,'DateTime',context!),
        'children': JsonConverters.toJson(children,'List<Category>',context!)
    });

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

class WorkflowStepDetail extends WorkflowStep implements IConvertible
{
    List<Category>? departments;
    List<Category>? coDepartments;
    List<SimpleDocumentRelation>? basisDocuments;
    List<SimpleDocumentRelation>? referenceDocuments;
    List<WorkFlowProfile>? mainAssignees;
    List<WorkFlowProfile>? supportingAssignees;
    String? statusKey;
    String? statusText;
    // @ignore()
    bool? canRead;

    // @ignore()
    bool? canWrite;

    // @ignore()
    bool? canUpload;

    String? reasonReturn;
    DateTime? returnDate;

    WorkflowStepDetail({this.departments,this.coDepartments,this.basisDocuments,this.referenceDocuments,this.mainAssignees,this.supportingAssignees,this.statusKey,this.statusText,this.canRead,this.canWrite,this.canUpload,this.reasonReturn,this.returnDate});
    WorkflowStepDetail.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        departments = JsonConverters.fromJson(json['departments'],'List<Category>',context!);
        coDepartments = JsonConverters.fromJson(json['coDepartments'],'List<Category>',context!);
        basisDocuments = JsonConverters.fromJson(json['basisDocuments'],'List<SimpleDocumentRelation>',context!);
        referenceDocuments = JsonConverters.fromJson(json['referenceDocuments'],'List<SimpleDocumentRelation>',context!);
        mainAssignees = JsonConverters.fromJson(json['mainAssignees'],'List<WorkFlowProfile>',context!);
        supportingAssignees = JsonConverters.fromJson(json['supportingAssignees'],'List<WorkFlowProfile>',context!);
        statusKey = json['statusKey'];
        statusText = json['statusText'];
        canRead = json['canRead'];
        canWrite = json['canWrite'];
        canUpload = json['canUpload'];
        reasonReturn = json['reasonReturn'];
        returnDate = JsonConverters.fromJson(json['returnDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'departments': JsonConverters.toJson(departments,'List<Category>',context!),
        'coDepartments': JsonConverters.toJson(coDepartments,'List<Category>',context!),
        'basisDocuments': JsonConverters.toJson(basisDocuments,'List<SimpleDocumentRelation>',context!),
        'referenceDocuments': JsonConverters.toJson(referenceDocuments,'List<SimpleDocumentRelation>',context!),
        'mainAssignees': JsonConverters.toJson(mainAssignees,'List<WorkFlowProfile>',context!),
        'supportingAssignees': JsonConverters.toJson(supportingAssignees,'List<WorkFlowProfile>',context!),
        'statusKey': statusKey,
        'statusText': statusText,
        'canRead': canRead,
        'canWrite': canWrite,
        'canUpload': canUpload,
        'reasonReturn': reasonReturn,
        'returnDate': JsonConverters.toJson(returnDate,'DateTime',context!)
    });

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

class Document extends BasicDocument implements IConvertible
{
    int? id;
    // @StringLength(500)
    String? reasonReturn;

    int? accountId;
    DateTime? deletedAt;
    // @StringLength(500)
    String? deletedBy;

    // @StringLength(500)
    String? updatedBy;

    DateTime? createdAt;
    // @StringLength(500)
    String? createdBy;

    bool? isParty;
    bool? isRevisionRequested;
    DateTime? lastUpdatedAt;
    bool? isPrivate;
    int? departmentId;
    DateTime? publicationDate;
    int? processStatusId;
    String? fullTextSearchContent;

    Document({this.id,this.reasonReturn,this.accountId,this.deletedAt,this.deletedBy,this.updatedBy,this.createdAt,this.createdBy,this.isParty,this.isRevisionRequested,this.lastUpdatedAt,this.isPrivate,this.departmentId,this.publicationDate,this.processStatusId,this.fullTextSearchContent});
    Document.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        id = json['id'];
        reasonReturn = json['reasonReturn'];
        accountId = json['accountId'];
        deletedAt = JsonConverters.fromJson(json['deletedAt'],'DateTime',context!);
        deletedBy = json['deletedBy'];
        updatedBy = json['updatedBy'];
        createdAt = JsonConverters.fromJson(json['createdAt'],'DateTime',context!);
        createdBy = json['createdBy'];
        isParty = json['isParty'];
        isRevisionRequested = json['isRevisionRequested'];
        lastUpdatedAt = JsonConverters.fromJson(json['lastUpdatedAt'],'DateTime',context!);
        isPrivate = json['isPrivate'];
        departmentId = json['departmentId'];
        publicationDate = JsonConverters.fromJson(json['publicationDate'],'DateTime',context!);
        processStatusId = json['processStatusId'];
        fullTextSearchContent = json['fullTextSearchContent'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'id': id,
        'reasonReturn': reasonReturn,
        'accountId': accountId,
        'deletedAt': JsonConverters.toJson(deletedAt,'DateTime',context!),
        'deletedBy': deletedBy,
        'updatedBy': updatedBy,
        'createdAt': JsonConverters.toJson(createdAt,'DateTime',context!),
        'createdBy': createdBy,
        'isParty': isParty,
        'isRevisionRequested': isRevisionRequested,
        'lastUpdatedAt': JsonConverters.toJson(lastUpdatedAt,'DateTime',context!),
        'isPrivate': isPrivate,
        'departmentId': departmentId,
        'publicationDate': JsonConverters.toJson(publicationDate,'DateTime',context!),
        'processStatusId': processStatusId,
        'fullTextSearchContent': fullTextSearchContent
    });

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

class GetWorkflowStepResponse implements IResponseRequest, IConvertible
{
    int? code;
    String? message;
    List<WorkflowStepDetail>? data;

    GetWorkflowStepResponse({this.code,this.message,this.data});
    GetWorkflowStepResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        code = json['code'];
        message = json['message'];
        data = JsonConverters.fromJson(json['data'],'List<WorkflowStepDetail>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'code': code,
        'message': message,
        'data': JsonConverters.toJson(data,'List<WorkflowStepDetail>',context!)
    };

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

// @Route("/WorkflowStep/by-workflow", "Get")
class GetWorkflowStepRequest implements IReturn<GetWorkflowStepResponse>, IConvertible, IGet
{
    int? workflowId;

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

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

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

    createResponse() => GetWorkflowStepResponse();
    getResponseTypeName() => "GetWorkflowStepResponse";
    getTypeName() => "GetWorkflowStepRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'etc_api.vsmlab.vn', types: <String, TypeInfo> {
    'CategoryTypes': TypeInfo(TypeOf.Enum, enumValues:CategoryTypes.values),
    'CreateCategoryModel': TypeInfo(TypeOf.Class, create:() => CreateCategoryModel()),
    'BasicUploadedFile': TypeInfo(TypeOf.Class, create:() => BasicUploadedFile()),
    'UploadedFiles': TypeInfo(TypeOf.Class, create:() => UploadedFiles()),
    'SimpleDocumentRelation': TypeInfo(TypeOf.Class, create:() => SimpleDocumentRelation()),
    'BasicDocument': TypeInfo(TypeOf.Class, create:() => BasicDocument()),
    'BasicSignerConfig': TypeInfo(TypeOf.Class, create:() => BasicSignerConfig()),
    'SignerConfig': TypeInfo(TypeOf.Class, create:() => SignerConfig()),
    'WorkFlowProfile': TypeInfo(TypeOf.Class, create:() => WorkFlowProfile()),
    'Roles': TypeInfo(TypeOf.Class, create:() => Roles()),
    'SignerConfigDetail': TypeInfo(TypeOf.Class, create:() => SignerConfigDetail()),
    'StepAttached': TypeInfo(TypeOf.Class, create:() => StepAttached()),
    'List<SignerConfigDetail>': TypeInfo(TypeOf.Class, create:() => <SignerConfigDetail>[]),
    'WorkflowStep': TypeInfo(TypeOf.Class, create:() => WorkflowStep()),
    'List<StepAttached>': TypeInfo(TypeOf.Class, create:() => <StepAttached>[]),
    'IResponseRequest': TypeInfo(TypeOf.Interface),
    'Category': TypeInfo(TypeOf.Class, create:() => Category()),
    'List<Category>': TypeInfo(TypeOf.Class, create:() => <Category>[]),
    'WorkflowStepDetail': TypeInfo(TypeOf.Class, create:() => WorkflowStepDetail()),
    'List<SimpleDocumentRelation>': TypeInfo(TypeOf.Class, create:() => <SimpleDocumentRelation>[]),
    'List<WorkFlowProfile>': TypeInfo(TypeOf.Class, create:() => <WorkFlowProfile>[]),
    'Document': TypeInfo(TypeOf.Class, create:() => Document()),
    'GetWorkflowStepResponse': TypeInfo(TypeOf.Class, create:() => GetWorkflowStepResponse()),
    'List<WorkflowStepDetail>': TypeInfo(TypeOf.Class, create:() => <WorkflowStepDetail>[]),
    'GetWorkflowStepRequest': TypeInfo(TypeOf.Class, create:() => GetWorkflowStepRequest()),
});