/* Options:
Date: 2026-01-27 18:39:17
Version: 8.40
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://buildmax.org

//GlobalNamespace: 
//MakePropertiesOptional: False
//AddServiceStackTypes: True
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
IncludeTypes: GetQuestion.*
//ExcludeTypes: 
//DefaultImports: 
*/


export enum Brand
{
    Desktop = 'Desktop',
    Hp = 'Hp',
    Kyocera = 'Kyocera',
    NeaScan = 'NeaScan',
    Samsung = 'Samsung',
    FujiXerox = 'FujiXerox',
    Ta = 'Ta',
    Utax = 'Utax',
    Epson = 'Epson',
    ScanFront400 = 'ScanFront400',
    Sharp = 'Sharp',
    Ricoh = 'Ricoh',
    FujiFilm = 'FujiFilm',
}

export class DtoBase
{
    public Brand: Brand;

    public constructor(init?: Partial<DtoBase>) { (Object as any).assign(this, init); }
}

export class RequestBase extends DtoBase
{

    public constructor(init?: Partial<RequestBase>) { super(init); (Object as any).assign(this, init); }
}

export class QuestionRequestDto extends RequestBase
{
    public TemplateGuid: string;
    public QuestionGuid: string;
    public Parent: string;
    public FolderBrowser: string;

    public constructor(init?: Partial<QuestionRequestDto>) { super(init); (Object as any).assign(this, init); }
}

export class ResponseBase extends DtoBase
{
    public SelectedUiLanguage: string;
    public svSession: string;
    public Title: string;
    public PageTip: string;
    public NewBrowser: boolean;
    public ScanFront400TA: boolean;
    public ScanFront400UTAX: boolean;

    public constructor(init?: Partial<ResponseBase>) { super(init); (Object as any).assign(this, init); }
}

export interface IClientQuestion extends ITemplateQuestion
{
    QuestionGuid: string;
    ValueDisplayed: string;
    ValueReturned: string;
    Answered: boolean;
    RegexMatches: boolean;
    RegexHint: string;
}

export interface IUser extends IIdTemplatesItem
{
    Groups: ReadOnlyCollection<IUserGroup>;
    EmailAddress: string;
    HasPassword: boolean;
    HomeFolder: string;
    Password: string;
    SbcUser?: boolean;
}

export interface IUserGroup extends IIdTemplatesItem, IGroup
{
    Users: ReadOnlyCollection<IUser>;
}

export interface IMetadataParserEx extends IMetadataParser
{
}

export interface ITemplateModificationInfo
{
    Guid: string;
    TemplateModificationDateTime: string;
    IconModificationDateTime: string;
}

export enum TemplateType
{
    Workflow = 'Workflow',
    FreeForm = 'FreeForm',
}

export enum TemplateScheduleType
{
    Interval = 'Interval',
    Fixed = 'Fixed',
}

export interface ITemplateSchedule extends IInterface
{
    Time?: string;
    EndTime?: string;
    NoEndTime?: boolean;
    Type?: TemplateScheduleType;
}

export interface ICredentials extends IInterface
{
    Username: string;
    Password: string;
}

export interface IRejection
{
    RejectAfter?: number;
    RejectionPath: string;
    ShareCredentials: ICredentials;
}

export interface IBadDocumentRejection extends IStatus
{
    RejectionPath: string;
    ShareCredentials: ICredentials;
}

export enum PdfLoadResolution
{
    Default = 'Default',
    Dpi100 = 'Dpi100',
    Dpi150 = 'Dpi150',
    Dpi200 = 'Dpi200',
    Dpi300 = 'Dpi300',
    Dpi400 = 'Dpi400',
    Dpi500 = 'Dpi500',
    Dpi600 = 'Dpi600',
}

export interface IGeneral extends IInterface
{
    Name: string;
    Description: string;
    Icon: string;
    Schedule: ITemplateSchedule;
    Rejection: IRejection;
    BadDocumentRejection: IBadDocumentRejection;
    PdfLoadResolution?: PdfLoadResolution;
}

export interface ICaptureSource extends IStatus
{
}

export interface ICapture extends IInterface
{
    CaptureSources: ReadOnlyCollection<ICaptureSource>;
}

export interface IStringMetadata extends IMetadata
{
    IsSecure?: boolean;
    SampleValue: string;
    Value: string;
}

export interface IXmlMetadataImportTagMapping extends IInterface
{
    XPathExpression: string;
    Metadata: IStringMetadata;
}

export interface IXmlMetadataImportNamespaceMapping extends IInterface
{
    Prefix: string;
    Name: string;
}

export interface IXmlMetadataImport extends IStatus
{
    SampleDocumentName: string;
    TagMappings: ReadOnlyCollection<IXmlMetadataImportTagMapping>;
    NamespaceMappings: ReadOnlyCollection<IXmlMetadataImportNamespaceMapping>;
}

export enum NotificationType
{
    FailureOnly = 'FailureOnly',
    SuccessOnly = 'SuccessOnly',
    Always = 'Always',
}

export interface INotification extends IStatus
{
    Description: string;
    To: string;
    Subject: string;
    Body: string;
    Cc: string;
    Bcc: string;
    NotificationType?: NotificationType;
}

export interface INotifications extends IStatus
{
    Notifications: ReadOnlyCollection<INotification>;
}

export interface IValidationError
{
    Property: string;
    ErrorMessage: string;
}

export interface IValidationErrors
{
    Errors: ReadOnlyCollection<IValidationError>;
}

export interface IValidator
{
    ValidationErrors: IValidationErrors;
    IsValid: boolean;
}

export interface ITemplate extends IStatus
{
    TemplateVersion: string;
    ScannerVisionVersion: string;
    Guid: string;
    BeginScript: string;
    EndScript: string;
    TemplateType: TemplateType;
    General: IGeneral;
    Capture: ICapture;
    XmlMetadataImport: IXmlMetadataImport;
    Notifications: INotifications;
    Validator: IValidator;
}

export interface IClientTemplate
{
    Description: string;
    Icon: string;
    ModificationInfo: ITemplateModificationInfo;
    Name: string;
    Questions: IClientQuestion[];
    Template: ITemplate;
    TemplateGuid: string;
}

export class ScanResponseBase extends ResponseBase
{
    public Template: IClientTemplate;
    public GlobalQuestions: IClientQuestion[];
    public CanEnableScanButton: boolean;

    public constructor(init?: Partial<ScanResponseBase>) { super(init); (Object as any).assign(this, init); }
}

export enum TemplateQuestionType
{
    Edit = 'Edit',
    List = 'List',
    EditList = 'EditList',
    Browse = 'Browse',
    Password = 'Password',
    Date = 'Date',
    Time = 'Time',
    Boolean = 'Boolean',
    Integer = 'Integer',
    Double = 'Double',
    BrowseList = 'BrowseList',
}

export interface ITemplatePicklist extends IStatus
{
    Guid: string;
}

export interface ITemplateQuestion extends IStatus
{
    TagName: string;
    Question: string;
    Tooltip: string;
    DefaultValue: string;
    HideDefaultValue?: boolean;
    Regex: string;
    Sample: string;
    QuestionType?: TemplateQuestionType;
    MinimumSize?: number;
    MaximumSize?: number;
    IsRequired?: boolean;
    Picklist: ITemplatePicklist;
}

export interface IStatus extends IInterface
{
    Status?: boolean;
}

export interface IInterface
{
}

export interface IIdTemplatesItem extends IStatus
{
    Id: string;
    Name: string;
    Description: string;
    Templates: ReadOnlyCollection<string>;
}

export interface IMetadataParser
{
}

export interface IGroup extends IInterface
{
    UseGroupSettings?: boolean;
}

export enum DataType
{
    String = 'String',
    Boolean = 'Boolean',
    Integer = 'Integer',
    Double = 'Double',
    DateTime = 'DateTime',
}

export interface IMetadata extends IDataTypeInterface
{
    TagName: string;
    Description: string;
}

export interface IDataTypeInterface extends IInterface
{
    DataType?: DataType;
}

export class GetQuestionResponse extends ScanResponseBase
{
    public Question: IClientQuestion;
    public RegexMatches: boolean;
    public RegexHint: string;
    public SelectedFolder: string;
    public LoggedInUser: IUser;
    public MetadataParser: IMetadataParserEx;
    public ParsedRoot: string;
    public FolderBrowser: string;
    public Parent: string;
    public SearchTerm: string;
    public PageNumber?: number;

    public constructor(init?: Partial<GetQuestionResponse>) { super(init); (Object as any).assign(this, init); }
}

// @Route("/{Brand}/question/{TemplateGuid}/{QuestionGuid}", "GET")
// @Route("/{Brand}/question/{TemplateGuid}/{QuestionGuid}/page/{PageNumber}", "GET")
// @Route("/{Brand}/question/{TemplateGuid}/{QuestionGuid}/{ParsedRoot*}/folder/revisited/{FolderBrowser*}", "GET")
// @Route("/{Brand}/question/{TemplateGuid}/{QuestionGuid}/{ParsedRoot*}/folder/revisited/{FolderBrowser*}/page/{PageNumber}", "GET")
// @Route("/{Brand}/question/{TemplateGuid}/{QuestionGuid}/{ParsedRoot*}/folder/revisited/{FolderBrowser*}/search/{SearchTerm}", "GET")
// @Route("/{Brand}/question/{TemplateGuid}/{QuestionGuid}/{ParsedRoot*}/folder/revisited/{FolderBrowser*}/search/{SearchTerm}/page/{PageNumber}", "GET")
export class GetQuestion extends QuestionRequestDto implements IReturn<GetQuestionResponse>
{
    public ParsedRoot: string;
    public SearchTerm: string;
    public PageNumber: number;

    public constructor(init?: Partial<GetQuestion>) { super(init); (Object as any).assign(this, init); }
    public getTypeName() { return 'GetQuestion'; }
    public getMethod() { return 'GET'; }
    public createResponse() { return new GetQuestionResponse(); }
}