declare module EVA.Admin {

  export namespace Errors {
    export const enum Workspaces {
      /**
       * You are not authorized to view this workspace.
       */
      UnauthorizedToViewWorkspace = 'Workspaces:UnauthorizedToViewWorkspace',
      /**
       * Workspace is owned by other user.
       */
      WorkspaceOwnedByOtherUser = 'Workspaces:WorkspaceOwnedByOtherUser',
      /**
       * The workspace is private.
       */
      WorkspaceIsPrivate = 'Workspaces:WorkspaceIsPrivate',
      /**
       * The workspace is shared.
       */
      WorkspaceIsShared = 'Workspaces:WorkspaceIsShared',
      /**
       * Cannot set a workspace without key to be the active one.
       */
      CannotSetWorkspaceWithoutKeyToActive = 'Workspaces:CannotSetWorkspaceWithoutKeyToActive',
      /**
       * Cannot remove a shared workspace as it still has Active members.
       */
      CannotRemoveSharedWorkspace = 'Workspaces:CannotRemoveSharedWorkspace',
      /**
       * Cannot remove an active workspace as it's still active
       */
      CannotRemoveActiveWorkspace = 'Workspaces:CannotRemoveActiveWorkspace',
      /**
       * Workspaces can't have duplicate names
       */
      DuplicateNames = 'Workspaces:DuplicateNames',
      /**
       * RoleIds: {0:string} are not connected to the provided workspace.
       */
      RoleDoesNotHaveSharedWorkspace = 'Workspaces:RoleDoesNotHaveSharedWorkspace'
    }

  }


  /**
   * List all shared workspaces based on the given filter
   */
  export interface ListSharedWorkspaces {
    InitialPageConfig?: EVA.Core.PageTokenConfig<ListSharedWorkspacesFilter>;
    PageToken?: string;
  }

  export interface ListSharedWorkspacesFilter {
    Key?: string;
    /**
     * Entity type: Role
     */
    RoleID?: number;
    Name: string;
  }

  export interface ListSharedWorkspacesResponse {
    Results?: ListSharedWorkspacesResponse.Workspace[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListSharedWorkspacesResponse {
    export interface Workspace {
      /**
       * Entity type: Workspace
       */
      ID: number;
      Key: string;
      Name: string;
      Settings: string;
      IsAllowedToEdit: boolean;
      RolesWithDefault: Workspace.RoleWithDefault[];
    }

    export namespace Workspace {
      export interface RoleWithDefault {
        /**
         * Entity type: Role
         */
        ID: number;
        IsDefault: boolean;
        Name: string;
      }

    }

  }

  /**
   * Get a shared workspace by ID
   */
  export interface GetSharedWorkspaceByID {
    /**
     * Entity type: Workspace
     */
    ID: number;
  }

  export interface GetSharedWorkspaceByIDResponse {
    /**
     * Entity type: Workspace
     */
    ID: number;
    /**
     * Entity type: User
     */
    OwnerID: number;
    Key: string;
    Name: string;
    Settings: string;
    RolesWithDefault: GetSharedWorkspaceByIDResponse.RoleWithDefault[];
    IsAllowedToEdit: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetSharedWorkspaceByIDResponse {
    export interface RoleWithDefault {
      /**
       * Entity type: Role
       */
      ID: number;
      IsDefault: boolean;
      Name: string;
    }

  }

  /**
   * Creates a new shared workspace.
   */
  export interface CreateSharedWorkspace {
    /**
     * Identifier of workspace target
     */
    Key: string;
    /**
     * Max. length 128 characters
     */
    Name: string;
    Settings: string;
    /**
     * Entity type: Role
     */
    RoleIDs?: number[];
  }

  export interface CreateWorkspaceResponse {
    /**
     * Entity type: Workspace
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update a shared workspace by ID
   */
  export interface UpdateSharedWorkspace {
    /**
     * Entity type: Workspace
     */
    ID: number;
    /**
     * Max. length 128 characters
     */
    Name: string;
    Settings: string;
  }

  /**
   * Add roles to a shared workspace
   */
  export interface AddRolesToSharedWorkspace {
    /**
     * Entity type: Workspace
     */
    ID: number;
    /**
     * Entity type: Role
     */
    RoleIDs: number[];
  }

  /**
   * Remove (all) roles from a workspace
   */
  export interface RemoveRolesFromSharedWorkspace {
    /**
     * Entity type: Workspace
     */
    ID?: number;
    RemoveAllRoles?: boolean;
    /**
     * Entity type: Role
     */
    RoleIDs?: number[];
  }

  /**
   * Delete a shared workspace by it's ID
   */
  export interface DeleteSharedWorkspace {
    /**
     * Entity type: Workspace
     */
    ID: number;
    UnlinkActiveWorkspace?: boolean;
  }

  /**
   * Transfer shared wordspace ownership with ID and optional user Update
   */
  export interface TransferSharedWorkspaceOwnership {
    /**
     * Entity type: Workspace
     */
    ID: number;
    /**
     * Entity type: User
     */
    OwnerID?: number;
  }

  /**
   * Set default shared workspace for roles
   */
  export interface SetDefaultSharedWorkspaceForRoles {
    /**
     * Entity type: Workspace
     */
    ID: number;
    /**
     * Entity type: Role
     */
    RoleIDs: number[];
    IsDefault?: boolean;
  }

  /**
   * Get all workspaces for the current user
   */
  export interface GetWorkspaces {
    /**
     * Identifier of workspace target
     */
    Key?: string;
  }

  export interface GetWorkspacesResponse {
    Result: GetWorkspacesResponse.Workspace[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetWorkspacesResponse {
    export interface Workspace {
      /**
       * Entity type: Workspace
       */
      ID: number;
      Key: string;
      Name: string;
      Settings: string;
      IsShared: boolean;
      RolesWithDefault: Workspace.RoleWithDefault[];
      IsActive: boolean;
    }

    export namespace Workspace {
      export interface RoleWithDefault {
        /**
         * Entity type: Role
         */
        ID: number;
        IsDefault: boolean;
        Name: string;
      }

    }

  }

  /**
   * Get a workspace by ID
   */
  export interface GetWorkspaceByID {
    /**
     * Entity type: Workspace
     */
    ID: number;
  }

  export interface GetWorkspaceByIDResponse {
    /**
     * Entity type: Workspace
     */
    ID: number;
    Key?: string;
    Name: string;
    Settings: string;
    IsShared: boolean;
    IsActive: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Creates a new workspace for the current user.
   */
  export interface CreateWorkspace {
    /**
     * Identifier of workspace target
     */
    Key?: string;
    /**
     * Max. length 128 characters
     */
    Name: string;
    Settings: string;
  }

  /**
   * Update a workspace by ID
   */
  export interface UpdateWorkspace {
    /**
     * Entity type: Workspace
     */
    ID: number;
    /**
     * Max. length 128 characters
     */
    Name: string;
    Settings: string;
  }

  /**
   * Set active workspace for the current user
   */
  export interface SetActiveWorkspace {
    /**
     * Entity type: Workspace
     */
    ID: number;
  }

  /**
   * Delete a Workspace by it's ID
   */
  export interface DeleteWorkspace {
    /**
     * Entity type: Workspace
     */
    ID: number;
  }

  /**
   * Gives a list of all admin modules visible by the current user.
   */
  export interface AdminGetAllModules {
  }

  export interface AdminGetAllModulesResponse {
    Modules: AdminGetAllModulesResponse.ModuleDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace AdminGetAllModulesResponse {
    export interface ModuleDto {
      /**
       * Entity type: Module
       */
      ID: number;
      Name: string;
      Code: string;
      IsActive: boolean;
      Data?: any;
    }

  }

  /**
   * Gives a list of all roles that are allowed to see this module
   */
  export interface AdminGetModuleAllowedRoles {
    /**
     * Entity type: Module
     */
    ModuleID: number;
  }

  export interface AdminGetModuleAllowedRolesResponse {
    Roles: AdminGetModuleAllowedRolesResponse.Role[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace AdminGetModuleAllowedRolesResponse {
    export interface Role {
      /**
       * Entity type: Role
       */
      ID: number;
      Name: string;
      Code: string;
    }

  }

  /**
   * Gives a list of all modules that the given role isallowed to see
   */
  export interface AdminGetRoleAllowedModules {
    /**
     * Entity type: Role
     */
    RoleID: number;
  }

  export interface AdminGetRoleAllowedModulesResponse {
    Modules: AdminGetRoleAllowedModulesResponse.AllowedModule[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace AdminGetRoleAllowedModulesResponse {
    export interface AllowedModule {
      /**
       * Entity type: Module
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Set which roles are allowed to see the specified module. Will replace existing values.
   */
  export interface AdminUpdateModuleAllowedRoles {
    /**
     * Entity type: Module
     */
    ModuleID: number;
    Roles?: AdminUpdateModuleAllowedRoles.AllowedRole[];
  }

  export namespace AdminUpdateModuleAllowedRoles {
    export interface AllowedRole {
      /**
       * Entity type: Role
       */
      RoleID: number;
    }

  }

  /**
   * Set which modules are allowed to see by the specified role. Will replace existing values.
   */
  export interface AdminUpdateRoleAllowedModules {
    /**
     * Entity type: Role
     */
    RoleID: number;
    Modules?: AdminUpdateRoleAllowedModules.AllowedModule[];
  }

  export namespace AdminUpdateRoleAllowedModules {
    export interface AllowedModule {
      /**
       * Entity type: Module
       */
      ModuleID: number;
    }

  }

  /**
   * Get a Module by ID
   */
  export interface AdminGetModuleByID {
    /**
     * Entity type: Module
     */
    ID: number;
  }

  export interface AdminGetModuleByIDResponse {
    /**
     * Entity type: Module
     */
    ID: number;
    Name: string;
    Code: string;
    IsActive: boolean;
    Data?: any;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new Module
   */
  export interface AdminCreateModule {
    Name: string;
    Code: string;
    IsActive?: boolean;
    Data?: any;
  }

  export interface AdminCreateModuleResponse {
    /**
     * Entity type: Module
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing Module
   */
  export interface AdminUpdateModule {
    /**
     * Entity type: Module
     */
    ID: number;
    Name: string;
    Code: string;
    IsActive?: boolean;
    Data?: any;
  }

  /**
   * Delete a Module
   */
  export interface AdminDeleteModule {
    /**
     * Entity type: Module
     */
    ID: number;
  }

  /**
   * List the Modules
   */
  export interface AdminListModules {
    PageConfig?: EVA.Core.PageConfig<ListModulesFilter>;
  }

  export interface ListModulesFilter {
    Name: string;
    Code: string;
    IsActive?: boolean;
  }

  export interface AdminListModulesResponse {
    Result?: EVA.Core.PagedResult<AdminListModulesResponse.ModuleDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace AdminListModulesResponse {
    export interface ModuleDto {
      /**
       * Entity type: Module
       */
      ID: number;
      Name: string;
      Code: string;
      IsActive: boolean;
      Data?: any;
    }

  }

}declare module EVA.Auditing {

  export namespace Errors {
    export const enum Protel {
      /**
       * Protel order creation failed.
       */
      OrderCreationFailed = 'Protel:OrderCreationFailed',
      /**
       * Protel payment creation failed.
       */
      PaymentCreationFailed = 'Protel:PaymentCreationFailed',
      /**
       * Protel refund failed, not eligible for Voiding or no Reference provided.
       */
      RefundNotAvailable = 'Protel:RefundNotAvailable',
      /**
       * Protel refund failed, can only be done in the original store.
       */
      RefundNotAvailableInOtherStore = 'Protel:RefundNotAvailableInOtherStore',
      /**
       * Protel refund failed, serialnumber of the form is required.
       */
      RefundRequiresSerialNumber = 'Protel:RefundRequiresSerialNumber'
    }

    export const enum ValidationError {
      /**
       * ShopID exceeds maximum length of 4 characters, it was: {0:string}.
       */
      ShopNumberExceedsMaximumLength = 'ValidationError:ShopNumberExceedsMaximumLength',
      /**
       * TenantCode exceeds maximum length of 5 characters, it was: {0:string}.
       */
      TenantCodeExceedsMaximumLength = 'ValidationError:TenantCodeExceedsMaximumLength',
      /**
       * Register (counter) number exceeds maximum length of 3 characters, it was: {0:string}.
       */
      RegisterNumberExceedsMaximumLength = 'ValidationError:RegisterNumberExceedsMaximumLength',
      /**
       * The Infrasec RegisterID / FiscalSystemID of the station cannot be null or whitespace.
       */
      InfrasecRegisterIDNullOrWhitespace = 'ValidationError:InfrasecRegisterIDNullOrWhitespace',
      /**
       * The Infrasec Organization Number (taken from the Company RegistrationNumber) must be exactly 10 characters, but it was {0:string}.
       */
      CompanyRegistrationNumberNotWithinRange = 'ValidationError:CompanyRegistrationNumberNotWithinRange',
      /**
       * {0:string}
       */
      ExceptionInNTHRelatedFlow = 'ValidationError:ExceptionInNTHRelatedFlow',
      /**
       * EXCEPTION_IN_RT_RELATED_FLOW 
       * An exception occured in a flow involving the RT Server!
       * The RT Server might not be the culprit, see the full error message for more details: 
       * {0:string}
       */
      ExceptionInRTServerRelatedFlow = 'ValidationError:ExceptionInRTServerRelatedFlow',
      /**
       * EXCEPTION_IN_RT_RELATED_FLOW 
       * The station (till) fiscal system ID must be exactly 8 characters, but it was: {0:string}
       */
      StationFiscalSystemIdOutOfRangeError = 'ValidationError:StationFiscalSystemIdOutOfRangeError',
      /**
       * EXCEPTION_IN_RT_RELATED_FLOW 
       * RT Server did not return a valid content: 
       * {0:string}
       */
      RtServerInvalidResponseContent = 'ValidationError:RtServerInvalidResponseContent',
      /**
       * EXCEPTION_IN_RT_RELATED_FLOW 
       * More than one station (till) with this {0:string} FiscalSystemID found in EVA! The FiscalSystemID of the newly created station will be set to null and the station cannot be used further for operations.
       */
      StationWithThisFiscalSystemIdAlreadyCreatedInEva = 'ValidationError:StationWithThisFiscalSystemIdAlreadyCreatedInEva'
    }

    export const enum InfrasecErrors {
      /**
       * The station with ID '{0:number}' is not a point of sale
       */
      StationNotPointOfSale = 'InfrasecErrors:StationNotPointOfSale',
      /**
       * The FiscalID/RegisterID for station with ID '{0:number}' is null or whitespace.
       */
      StationFiscalIDNotSet = 'InfrasecErrors:StationFiscalIDNotSet',
      /**
       * The FiscalID/RegisterID for station with ID '{0:number}' cannot be modified (Infrasec does not support changing the Register Number of a station.
       */
      StationFiscalIDCanNeverBeChanged = 'InfrasecErrors:StationFiscalIDCanNeverBeChanged',
      /**
       * The Register (Station) with this ID: {0:string} was already enrolled. The same combination of properties [Counter Number, StoreID (ShopNumber), Chain Code (TenantCode), POS Authority Code, Authority Code] was supplied before to build this RegisterID. Note that the 'Chain' (ChainName) does not matter, only the combination of the properties above
       */
      RegisterWithThisIDAlreadyEnrolled = 'InfrasecErrors:RegisterWithThisIDAlreadyEnrolled',
      /**
       * {0:string}
       */
      EnrollmentFailed = 'InfrasecErrors:EnrollmentFailed',
      /**
       * {0:string}
       */
      ReceiptError = 'InfrasecErrors:ReceiptError',
      /**
       * Auth Error Code 189. RequestID: {0:string}. Check the Organization Number (Organization RegistrationNumber) and the RegisterID from the request, the station from where the order was paid must belong to thesame OU.
       */
      ReceiptAuthError = 'InfrasecErrors:ReceiptAuthError',
      /**
       * The Infrasec API is offline, should proceed with Offline Cash invoice fallback flow{0:string}
       */
      InfrasecCCUApiOffline = 'InfrasecErrors:InfrasecCCUApiOffline'
    }

    export const enum FiskalySignEsErrors {
      /**
       * Fiskaly is unresponsive
       */
      FiskalyUnresponsive = 'FiskalySignEsErrors:FiskalyUnresponsive',
      /**
       * Station FiscalSystemID cannot be empty. The FiscalSystemID must be set to the value of the SignES associated ClientID
       */
      MissingFiscalSystemID = 'FiskalySignEsErrors:MissingFiscalSystemID',
      /**
       * Station must exist. The FiscalSystemID of the station must be set to the value of the SignES associated ClientID
       */
      MissingStation = 'FiskalySignEsErrors:MissingStation',
      /**
       * Setting EVA.Framework.Configuration.Setting`1[System.String] cannot be empty. The setting must be a UUIDv4 set to the value of the SignES associated ClientID
       */
      MissingWebShopClientID = 'FiskalySignEsErrors:MissingWebShopClientID',
      /**
       * The original invoice ID cannot be empty. The ReferenceInvoiceID should contain the associated Fiskaly SignES Invoice ID as a UUIDv4 format.
       */
      MissingReferenceInvoiceID = 'FiskalySignEsErrors:MissingReferenceInvoiceID'
    }

    export const enum FinancialPeriodAudit {
      /**
       * The 'From' {0:string} is greater than the 'To' {1:string} date
       */
      FromGreaterThanTo = 'FinancialPeriodAudit:FromGreaterThanTo',
      /**
       * The maximum period is {0:number} days
       */
      PeriodExceeded = 'FinancialPeriodAudit:PeriodExceeded',
      /**
       * Got a 'From' date but missing the 'To' date
       */
      MissingToDate = 'FinancialPeriodAudit:MissingToDate',
      /**
       * 'From' is in the future
       */
      DateIsInTheFuture = 'FinancialPeriodAudit:DateIsInTheFuture'
    }

    export const enum GenerateFinancialPeriodAuditExportService {
      /**
       * The specified audit file type is not handled.
       */
      AuditTypeCannotBeProcessed = 'GenerateFinancialPeriodAuditExportService:AuditTypeCannotBeProcessed'
    }

    export namespace Auditing {
      export const enum ReturnReport {
        /**
         * The report is empty.
         */
        InvalidReport = 'Auditing:ReturnReport:InvalidReport'
      }

      export namespace Romania {
        export const enum FiscalPrinter {
          /**
           * Invalid value for cashier code '{0:string}'
           */
          InvalidCashierCode = 'Auditing:Romania:FiscalPrinter:InvalidCashierCode',
          /**
           * The device '{0:number}' must have the OrganizationUnitID set
           */
          MissingDeviceOrganizationUnit = 'Auditing:Romania:FiscalPrinter:MissingDeviceOrganizationUnit',
          /**
           * Cannot find organization unit with ID {0:number}
           */
          MissingOrganizationUnit = 'Auditing:Romania:FiscalPrinter:MissingOrganizationUnit',
          /**
           * Cannot find country ID for organization unit with ID {0:number}
           */
          MissingCountryID = 'Auditing:Romania:FiscalPrinter:MissingCountryID',
          /**
           * Sale receipts require a fiscal receipt number
           */
          MissingFiscalReceipt = 'Auditing:Romania:FiscalPrinter:MissingFiscalReceipt',
          /**
           * Missing tax information, line '{0:string}'
           */
          MissingTaxInfo = 'Auditing:Romania:FiscalPrinter:MissingTaxInfo',
          /**
           * Incorrect VAT rate on the product, please check the configuration of the tax rates. Invalid value for category '{0:string}'
           */
          InvalidTaxCategory = 'Auditing:Romania:FiscalPrinter:InvalidTaxCategory',
          /**
           * Command '{0:string}', execution failure, error: {1:string}
           */
          FiscalPrinterExecutionError = 'Auditing:Romania:FiscalPrinter:FiscalPrinterExecutionError',
          /**
           * Did not expect to print an invoice {0:number} with a fiscal receipt number set {1:string}
           */
          FiscalReceiptNumberIndicatesReprint = 'Auditing:Romania:FiscalPrinter:FiscalReceiptNumberIndicatesReprint'
        }

      }

      export namespace Italy {
        export const enum SDI {
          /**
           * Invoice {0:number} does not have a customer
           */
          MissingCustomer = 'Auditing:Italy:SDI:MissingCustomer',
          /**
           * Invoice {0:number} does not have a billing address
           */
          MissingBillingAddress = 'Auditing:Italy:SDI:MissingBillingAddress',
          /**
           * OrganizationUnit {0:number} for Invoice {1:number} does not have a Company attached to it
           */
          MissingParentCompany = 'Auditing:Italy:SDI:MissingParentCompany',
          /**
           * Missing 'codice fiscale' to export invoice {0:number} to the SDI
           */
          MissingFiscalID = 'Auditing:Italy:SDI:MissingFiscalID',
          /**
           * OrganizationUnit {0:number} has not SDI url configured
           */
          MissingSDIServiceUrl = 'Auditing:Italy:SDI:MissingSDIServiceUrl',
          /**
           * OrganizationUnit {0:number} is missing the SDI transmitter country code
           */
          MissingSDITransmitterCountryCode = 'Auditing:Italy:SDI:MissingSDITransmitterCountryCode',
          /**
           * OrganizationUnit {0:number} is missing the SDI transmitter VAT number
           */
          MissingSDITransmitterVatNumber = 'Auditing:Italy:SDI:MissingSDITransmitterVatNumber'
        }

      }

      export namespace Hungary {
        export const enum PageroOnline {
          /**
           * {0:string}
           */
          TransientError = 'Auditing:Hungary:PageroOnline:TransientError'
        }

      }

    }

    export const enum ReprocessFinancialPeriodAuditService {
      /**
       * The specified audit cannot be reprocessed.
       */
      AuditCannotBeReprocessed = 'ReprocessFinancialPeriodAuditService:AuditCannotBeReprocessed'
    }

    export const enum SAFTPaymentCreationValidator {
      /**
       * The payment surpasses the maximum amount of {amount:number} {currency:string} in cash.
       */
      PaymentForbidden = 'SAFTPaymentCreationValidator:PaymentForbidden'
    }

    export const enum SAFT {
      /**
       * InvalidClientConfiguration
       */
      Series = 'SAFT:Series',
      /**
       * Failed to list series (one or more settings are invalid)
       */
      InvalidConfiguration = 'SAFT:InvalidConfiguration'
    }

    export const enum RomaniaPaymentCreationValidator {
      /**
       * You cannot create a sale containing gift cards and normal products.
       */
      MixedOrder = 'RomaniaPaymentCreationValidator:MixedOrder',
      /**
       * No thermal printer configured on the station.
       */
      NoThermalPrinter = 'RomaniaPaymentCreationValidator:NoThermalPrinter',
      /**
       * No fiscal thermal printer configured on the station.
       */
      NoFiscalThermalPrinter = 'RomaniaPaymentCreationValidator:NoFiscalThermalPrinter',
      /**
       * Thermal printer not reachable.
       */
      ThermalPrinterNotReachable = 'RomaniaPaymentCreationValidator:ThermalPrinterNotReachable',
      /**
       * Printer memory is full.
       */
      ThermalPrinterMemory = 'RomaniaPaymentCreationValidator:ThermalPrinterMemory',
      /**
       * Unable to complete the transaction. The financial period is open for longer than 24 hours. Please close the financial period and re-open the period in order to continue.
       */
      ThermalPrinterNeedToPrintZReport = 'RomaniaPaymentCreationValidator:ThermalPrinterNeedToPrintZReport',
      /**
       * Unable to complete the transaction. Printer in error state: {0:string}
       */
      ThermalPrinterError = 'RomaniaPaymentCreationValidator:ThermalPrinterError'
    }

    export const enum InvoiceValidationError {
      /**
       * {0:string}
       */
      KSeFRejectedTheInvoice = 'InvoiceValidationError:KSeFRejectedTheInvoice',
      /**
       * {0:string}
       */
      KSeFRejectedInvoice = 'InvoiceValidationError:KSeFRejectedInvoice',
      /**
       * Validation of the EVA created KSeF Invoice XML against the XSD Schema failed! At least one validation error was encountered:
       * {0:string}
       */
      InvoiceXsdValidationError = 'InvoiceValidationError:InvoiceXsdValidationError'
    }

    export const enum PolandFiscalPosPrinter {
      /**
       * Station required on the fiscal printer device
       */
      StationNotSetOnDevice = 'PolandFiscalPosPrinter:StationNotSetOnDevice',
      /**
       * Fiscal system ID required on the station
       */
      NoFiscalSystemID = 'PolandFiscalPosPrinter:NoFiscalSystemID'
    }

    export const enum PolandPaymentCreationValidator {
      /**
       * You cannot create a sale containing gift cards and normal products.
       */
      MixedOrder = 'PolandPaymentCreationValidator:MixedOrder',
      /**
       * No thermal printer configured on the station.
       */
      NoThermalPrinter = 'PolandPaymentCreationValidator:NoThermalPrinter',
      /**
       * No fiscal thermal printer configured on the station.
       */
      NoFiscalThermalPrinter = 'PolandPaymentCreationValidator:NoFiscalThermalPrinter',
      /**
       * Thermal printer not reachable.
       */
      ThermalPrinterNotReachable = 'PolandPaymentCreationValidator:ThermalPrinterNotReachable',
      /**
       * Thermal Printer is in autonomous mode, please exit this mode or restart your printer to continue.
       */
      ThermalPrinterAutonomous = 'PolandPaymentCreationValidator:ThermalPrinterAutonomous',
      /**
       * Check printer paper.
       */
      ThermalPrinterPaper = 'PolandPaymentCreationValidator:ThermalPrinterPaper',
      /**
       * Printer memory is full.
       */
      ThermalPrinterMemory = 'PolandPaymentCreationValidator:ThermalPrinterMemory'
    }

    export const enum PageroOnlineResponse {
      /**
       * Pagero online did not return a successful response: {0:string}
       */
      ResponseError = 'PageroOnlineResponse:ResponseError'
    }

    export const enum NF525PaymentCreationValidator {
      /**
       * The payment surpasses the maximum amount of {amount:number} {currency:string} in cash.
       */
      PaymentForbidden = 'NF525PaymentCreationValidator:PaymentForbidden',
      /**
       * The maximum duration of {0:number} day(s) in the offline financial period has been exceeded. Please close and reopen the period.
       */
      OfflinePeriodDurationExceeded = 'NF525PaymentCreationValidator:OfflinePeriodDurationExceeded'
    }

    export const enum SDiCoopInvoiceMiddlewareErrors {
      /**
       * The request message was empty
       */
      EmptyRequestMessage = 'SDiCoopInvoiceMiddlewareErrors:EmptyRequestMessage',
      /**
       * The request message did not contain a body.
       */
      EmptyRequestMessageBody = 'SDiCoopInvoiceMiddlewareErrors:EmptyRequestMessageBody',
      /**
       * The message body type '{0:string}' is unknown.
       */
      UnknownRequestMessageBodyType = 'SDiCoopInvoiceMiddlewareErrors:UnknownRequestMessageBodyType',
      /**
       * The SDI ID '{0:string}' is unknown.
       */
      UnknownInvoiceIdentificationNumber = 'SDiCoopInvoiceMiddlewareErrors:UnknownInvoiceIdentificationNumber'
    }

    export const enum RtServerResponse {
      /**
       * EXCEPTION_IN_RT_RELATED_FLOW 
       * RT Server did not return a successful response: 
       * {0:string}
       */
      ResponseError = 'RtServerResponse:ResponseError',
      /**
       * EXCEPTION_IN_RT_RELATED_FLOW 
       * Received 'Server Closure To Do' response from RT Server. This should indicate that there is at least one station which is open. All stations have to be closed if you want to remove a station from the RT Server. 
       * {0:string}
       */
      ServerClosureToDo = 'RtServerResponse:ServerClosureToDo'
    }

    export const enum ReceiptError {
      /**
       * EXCEPTION_IN_RT_RELATED_FLOW 
       * No matching RT Server Vat Rate found for this Product. Check the Tax Rates from the Organization Unit that the product belongs to. Details: {0:string}
       */
      RtServerVatRateMismatch = 'ReceiptError:RtServerVatRateMismatch'
    }

    export const enum ItalyIntegrationErrors {
      /**
       * EXCEPTION_IN_RT_RELATED_FLOW 
       * The station (till) fiscal system ID must be exactly 8 characters, but it was null. Station details: {0:string}
       */
      FiscalSystemIDCannotBeNull = 'ItalyIntegrationErrors:FiscalSystemIDCannotBeNull'
    }

    export const enum LotteryNumber {
      /**
       * EXCEPTION_IN_RT_RELATED_FLOW 
       * Expected lottery number to be exactly 8 characters, but was: {0:string}
       */
      InvalidLotteryNumberProvided = 'LotteryNumber:InvalidLotteryNumberProvided'
    }

    export const enum LotteryErrors {
      /**
       * EXCEPTION_IN_RT_RELATED_FLOW 
       * Expected lottery number to be exactly 8 characters, but was: {0:string}
       */
      InvalidLotteryNumberProvided = 'LotteryErrors:InvalidLotteryNumberProvided',
      /**
       * EXCEPTION_IN_RT_RELATED_FLOW
       * {0:string}
       */
      InvalidInstantLotteryComputedVerificationCode = 'LotteryErrors:InvalidInstantLotteryComputedVerificationCode',
      /**
       * EXCEPTION_IN_RT_RELATED_FLOW
       * {0:string}
       */
      RtServerNotInActiveState = 'LotteryErrors:RtServerNotInActiveState'
    }

    export const enum GermanPaymentCreationValidator {
      /**
       * The station {0:number} is not a fiscal station.
       */
      NotAFicalStation = 'GermanPaymentCreationValidator:NotAFicalStation',
      /**
       * The station {0:number} is not a fiscal station.
       */
      NotSyncedToTheExternalSystem = 'GermanPaymentCreationValidator:NotSyncedToTheExternalSystem'
    }

    export const enum GermanyIntegrationErrors {
      /**
       * The station fiscal system ID cannot be null. Station details: {0:string}
       */
      FiscalSystemIDCannotBeNull = 'GermanyIntegrationErrors:FiscalSystemIDCannotBeNull',
      /**
       * The station fiscal system ID cannot be changed. Station details: {0:string}
       */
      FiscalSystemIDOfAStationCannotBeChanged = 'GermanyIntegrationErrors:FiscalSystemIDOfAStationCannotBeChanged'
    }

    export const enum FiskalyKassenSichVErrors {
      /**
       * Fiskaly is unresponsive
       */
      FiskalyUnresponsive = 'FiskalyKassenSichVErrors:FiskalyUnresponsive',
      /**
       * Invalid Fiskaly Request
       */
      InvalidRequest = 'FiskalyKassenSichVErrors:InvalidRequest',
      /**
       * {0:string}
       */
      InvalidAcquisitionDate = 'FiskalyKassenSichVErrors:InvalidAcquisitionDate',
      /**
       * Establishment not synced with Fiskaly
       */
      EstablishmentIDNotSet = 'FiskalyKassenSichVErrors:EstablishmentIDNotSet',
      /**
       * Submission was not created on Fiskaly
       */
      SubmissionIDNotSet = 'FiskalyKassenSichVErrors:SubmissionIDNotSet',
      /**
       * Submission transmission failed. {0}
       */
      SubmissionTransmissionFailed = 'FiskalyKassenSichVErrors:SubmissionTransmissionFailed',
      /**
       * Submission creation failed. {0}
       */
      SubmissionCreationFailed = 'FiskalyKassenSichVErrors:SubmissionCreationFailed',
      /**
       * Submission api organization unit decommission failed. {0}
       */
      OrganizationUnitDecommissionFailed = 'FiskalyKassenSichVErrors:OrganizationUnitDecommissionFailed'
    }

    export const enum GenericPaymentCreationValidator {
      /**
       * The payment surpasses the maximum amount of {amount:number} {curency:string} in cash.
       */
      PaymentForbidden = 'GenericPaymentCreationValidator:PaymentForbidden'
    }

    export const enum FiscalPrinting {
      /**
       * Printing {typeOfReport:string} failed on station {stationID:number}
       */
      FailureToPrintPeriodicReport = 'FiscalPrinting:FailureToPrintPeriodicReport'
    }

    export const enum AuditingPaymentCreationValidator {
      /**
       * Additional fiscal configuration is required
       */
      FiscalConfigurationRequired = 'AuditingPaymentCreationValidator:FiscalConfigurationRequired'
    }

    export const enum AustriaFiskalyErrors {
      /**
       * Fiskaly is unresponsive
       */
      FiskalyUnresponsive = 'AustriaFiskalyErrors:FiskalyUnresponsive'
    }

    export const enum AustriaPaymentCreationValidator {
      /**
       * The station {0:number} is not a fiscal station.
       */
      NotAFicalStation = 'AustriaPaymentCreationValidator:NotAFicalStation'
    }

  }


  export interface PrintControlDocument {
    /**
     * Entity type: Station
     */
    StationID?: number;
  }

  /**
   * Protel, lalalalal
   */
  export interface TestProtel {
    /**
     * Entity type: Order
     */
    OrderID: number;
    TaxNo?: string;
  }

  export interface TestProtelResponse {
    IsEligible: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Used to get the required fields for the company.
   */
  export interface GetAuditingFieldsForCompany {
    /**
     * Entity type: Company
     */
    CompanyID: number;
  }

  export interface GetAuditingFieldsForCompanyResponse {
    Fields: { [key: string]: GetAuditingFieldsForCompanyResponse.FieldModel };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAuditingFieldsForCompanyResponse {
    export interface FieldModel {
      Label: string;
      Value: string;
      Type: EVA.Core.AuditingFieldDataType;
      MinLength: number;
      MaxLength: number;
    }

  }

  /**
   * Used to set the required fields for the company.
   */
  export interface SetAuditingFieldsForCompany {
    /**
     * Entity type: Company
     */
    CompanyID: number;
    AuditingFields: { [key: string]: string };
  }

  export interface CorrectInvoiceInformation {
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
    FiscalID?: string;
    RemoveFiscalID?: boolean;
    VatNumber?: string;
    RemoveVatNumber?: boolean;
    RemoveCompany?: boolean;
    CompanyName?: string;
    FirstName?: string;
    LastName?: string;
    RecipientCode?: string;
    RecipientEmail?: string;
    PublicProjectCode?: string;
    TenderIdentificationCode?: string;
    BillingAddressAddress1?: string;
    BillingAddressNumber?: string;
    BillingAddressZipCode?: string;
    BillingAddressCity?: string;
    BillingAddressRegion?: string;
    BillingAddressCountryID?: string;
  }

  /**
   * Creates financial period audits based on the given organization unit set.
   */
  export interface CreateFinancialPeriodAuditForOrganizationUnitSet {
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Start of the date range to create an audit for
     */
    From: string;
    /**
     * End of the date range to create an audit for
     */
    To: string;
  }

  export interface CreateFinancialPeriodAuditForOrganizationUnitSetResponse {
    /**
     * Entity type: FinancialPeriodAudit
     */
    IDs: number[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Creates a new audit collection of all currently open `Financial Period`s for the given `OrganizationUnitID`. The `OrganizationUnitID` act as root
   * selector and will cascade for all 'child' organizations as well.
   * 
   * Supply a `To` parameter to only collect `Financial Period`s from before that moment for audit.
   * Supply the `Type` to specify which or what kind of output you want to have. If none is passed the first available one is used. See the
   * `GetFinancialPeriodAuditOutputTypes` service to fetch all of the available types.
   */
  export interface CreateFinancialPeriodAudit {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Start of the date range to create an audit for
     */
    From?: string;
    /**
     * End of the date range to create an audit for
     */
    To?: string;
    /**
     * Use `GetFinancialPeriodAuditOutputTypes` to fetch the available types
     */
    Type?: string;
    IsPreview?: boolean;
  }

  export interface CreateFinancialPeriodAuditResponse {
    /**
     * Entity type: FinancialPeriodAudit
     */
    IDs: number[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Generates and prints the periodic monthly report that can be printed on-demand at the given station over the given period.
   * 
   * - `StationID` is where the periodic report should be printed
   * - `Year` is the year of the period
   * - `Month` is the month of the period (1=january, 12=december)
   */
  export interface CreateMonthlyPeriodicReport {
    /**
     * Entity type: Station
     */
    StationID: number;
    Year: number;
    Month: number;
  }

  /**
   * Helper service to decommission a station
   */
  export interface DecommissionStation {
    /**
     * Entity type: Station
     */
    StationID: number;
  }

  /**
   * Generates the audit file for the given audit and optionally its type, if there's one or more to choose from. Get these via the `GetFinancialPeriodAuditOutputTypes`
   */
  export interface GenerateFinancialPeriodAuditExport {
    /**
     * Financial period audit to generate the document for
     * Entity type: FinancialPeriodAudit
     */
    FinancialPeriodAuditID?: number;
    /**
     * Type of audit document to generate
     */
    Type?: string;
  }

  /**
   * Used to get the auditing summary.
   */
  export interface GetAuditingSummary {
  }

  export interface GetAuditingSummaryResponse {
    Summary: { [key: string]: string };
    Documents: { [key: string]: string };
    ControlDocuments: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Service for retrieving a list of blobs by the given `FinancialPeriodAudit` ID
   */
  export interface GetFinancialPeriodAuditBlobs {
    /**
     * Entity type: FinancialPeriodAudit
     */
    ID: number;
  }

  export interface GetFinancialPeriodAuditBlobsResponse {
    Items: GetFinancialPeriodAuditBlobsResponse.BlobItem[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetFinancialPeriodAuditBlobsResponse {
    export interface BlobItem {
      BlobID: string;
      BlobUrl: string;
      Type?: string;
    }

  }

  /**
   * Returns all of the available outputs that are available for the financial period audits for the given organization unit
   */
  export interface GetFinancialPeriodAuditOutputTypes {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetFinancialPeriodAuditOutputTypesResponse {
    Types: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Used to get the required fields for the organization unit.
   */
  export interface GetAuditingFieldsForOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetAuditingFieldsForOrganizationUnitResponse {
    Fields: { [key: string]: GetAuditingFieldsForOrganizationUnitResponse.FieldModel };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAuditingFieldsForOrganizationUnitResponse {
    export interface FieldModel {
      Label: string;
      Value: string;
      Type: EVA.Core.AuditingFieldDataType;
      MinLength: number;
      MaxLength: number;
    }

  }

  /**
   * Used to set the required fields for the organization unit.
   */
  export interface SetAuditingFieldsForOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    AuditingFields: { [key: string]: string };
  }

  /**
   * Generate and print a terminal report. This is a report for a terminal, p/a a X- or Z-report. It is required to supply the StationID where to print the report.
   */
  export interface PrintTerminalReport {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    DocumentID?: string;
    /**
     * Entity type: Station
     */
    StationID?: number;
  }

  export interface PrintTerminalReportResponse {
    CopyReceiptsPrinted: number;
    TotalCopyReceiptsAmount: number;
    ReceiptsPrinted: number;
    CashDrawerOpenings: number;
    ReturnCount: number;
    ReturnAmount: number;
    DiscountCount: number;
    DiscountAmount: number;
    Change: number;
    OpeningAmount: number;
    ClosingAmount: number;
    CashDepositsTotalAmount: number;
    Payments: PrintTerminalReportResponse.Payment[];
    CreditTaxes: PrintTerminalReportResponse.Tax[];
    DebitTaxes: PrintTerminalReportResponse.Tax[];
    Taxes: PrintTerminalReportResponse.Tax[];
    ProductGroups: PrintTerminalReportResponse.ProductGroup[];
    TotalPayments: number;
    TotalTaxes: number;
    TotalAmount: number;
    PaymentsPerUser: PrintTerminalReportResponse.PaymentPerUser[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace PrintTerminalReportResponse {
    export interface Payment {
      Description: string;
      Amount: number;
    }

    export interface PaymentPerUser {
      /**
       * Entity type: User
       */
      UserID: number;
      EmployeeNumber: string;
      Description: string;
      Amount: number;
    }

    export interface Tax {
      Code: string;
      Rate: number;
      Amount: number;
    }

    export interface ProductGroup {
      Code: string;
      Amount: number;
      Count: number;
    }

  }

  /**
   * Generates a monthly report on returned orders.
   */
  export interface ProduceReturnReport {
    /**
     * Min: 1
     */
    Year: number;
    Month: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  /**
   * Retry processing of a FinancialPeriodAudit, in case it is stuck or had an issue processing earlier.
   */
  export interface ReprocessFinancialPeriodAudit {
    /**
     * Entity type: FinancialPeriodAudit
     */
    ID: number;
  }

  /**
   * Validates the given Fiscal ID by the current organization unit auditing provider or by providing a country in the request
   */
  export interface ValidateFiscalID {
    FiscalID: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
  }

  export interface ValidateFiscalIDResponse {
    Success: EVA.Core.AuditingFiscalIDValidationResult;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListSeries {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    Identifier?: string;
    Type?: string;
    From?: string;
    To?: string;
  }

  export interface ListSeriesResponse {
    Result: ListSeriesResponse.Model[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListSeriesResponse {
    export interface Model {
      Identifier: string;
      SerialType: string;
      Classification: string;
      DocumentType: string;
      StartSequence: number;
      StartDate: string;
      ProcessingMediumCode: string;
      CertificateNumber: string;
      ValidationCode: string;
      RegistrationDate: string;
      State: string;
      StatusChangeReasonCode: string;
      LastChangeDate: string;
      TaxRegistrationNumber: string;
    }

  }

  export interface CancelSeries {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    Identifier?: string;
    Classification?: string;
    DocumentType?: string;
    ValidationCode?: string;
  }

  export interface CancelSeriesResponse {
    Success: boolean;
    Code: string;
    Message: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Utility service to easily set all of the settings required for enabling ATCUD in Portugal (SAFT)
   */
  export interface SetSeriesSettings {
    /**
     * Organization unit to which the settings should be applied
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Certificate that was handed out by the AT after completing the CSR steps (.cer file)
     */
    SigningCertificate?: string;
    /**
     * Certificate that was generated by combining the private key with the key received from AT
     */
    ClientCertificate?: string;
    /**
     * Recommended, password to the client certificate
     */
    ClientCertificatePassword?: string;
    /**
     * Username of the web service user created in the AT portal with at least WSE rights
     */
    Username?: string;
    /**
     * Password of the web service user
     */
    Password?: string;
    /**
     * Endpoint to connect to when registering series. Use https://servicos.portaldasfinancas.gov.pt:722/SeriesWSService for TEST and https://servicos.portaldasfinancas.gov.pt:422/SeriesWSService for PRODUCTION
     */
    Endpoint?: string;
  }

}declare module EVA.Authentication.OpenID {

  /**
   * Get all available openid provider configurations
   */
  export interface GetAvailableOpenIDConfigurations {
  }

  export interface GetAvailableOpenIDConfigurationsResponse {
    Providers: AvailableOpenIDConfiguration[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface AvailableOpenIDConfiguration {
    /**
     * Entity type: Provider
     */
    ID: number;
    Name?: string;
    Primary: boolean;
    BaseUrl: string;
    ClientID: string;
    UserType: EVA.Core.UserTypes;
  }

  /**
   * Get all info for a Azure OpenID Provider
   */
  export interface GetOpenIDProviderByID {
    /**
     * Entity type: Provider
     */
    ID: number;
  }

  export interface GetOpenIDProviderByIDResponse {
    /**
     * Entity type: Provider
     */
    ID?: number;
    BackendID?: string;
    Name?: string;
    Enabled?: boolean;
    Primary?: boolean;
    BaseUrl?: string;
    ClientID?: string;
    FirstNameClaim?: string;
    LastNameClaim?: string;
    EmailAddressClaim?: string;
    NicknameClaim?: string;
    UsernameClaim?: string;
    LanguageClaim?: string;
    CountryClaim?: string;
    UserType?: EVA.Core.UserTypes;
    CreateUsers?: boolean;
    DisallowOtherMethods?: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new OpenID Provider Registration
   */
  export interface CreateOpenIDProvider {
    BackendID?: string;
    Name?: string;
    Enabled?: boolean;
    BaseUrl?: string;
    ClientID?: string;
    FirstNameClaim?: string;
    LastNameClaim?: string;
    /**
     * To identify the user an EmailAddress or Nickname is required, so at least one of EmailAddressClaim/NicknameClaim/UsernameClaim should be set.
     */
    EmailAddressClaim?: string;
    /**
     * To identify the user an EmailAddress or Nickname is required, so at least one of EmailAddressClaim/NicknameClaim/UsernameClaim should be set.
     */
    NicknameClaim?: string;
    /**
     * To identify the user an EmailAddress or Nickname is required, so at least one of EmailAddressClaim/NicknameClaim/UsernameClaim should be set.
     */
    UsernameClaim?: string;
    LanguageClaim?: string;
    CountryClaim?: string;
    UserType?: EVA.Core.UserTypes;
    CreateUsers?: boolean;
    DisallowOtherMethods?: boolean;
  }

  export interface CreateOpenIDProviderResponse {
    /**
     * Entity type: Provider
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing OpenID Provider Registration
   */
  export interface UpdateOpenIDProvider {
    /**
     * Entity type: Provider
     */
    ID: number;
    BackendID?: string;
    Name?: string;
    Enabled?: boolean;
    BaseUrl?: string;
    ClientID?: string;
    FirstNameClaim?: string;
    LastNameClaim?: string;
    /**
     * To identify the user an EmailAddress or Nickname is required, so at least one of EmailAddressClaim/NicknameClaim/UsernameClaim should be set.
     */
    EmailAddressClaim?: string;
    /**
     * To identify the user an EmailAddress or Nickname is required, so at least one of EmailAddressClaim/NicknameClaim/UsernameClaim should be set.
     */
    NicknameClaim?: string;
    /**
     * To identify the user an EmailAddress or Nickname is required, so at least one of EmailAddressClaim/NicknameClaim/UsernameClaim should be set.
     */
    UsernameClaim?: string;
    LanguageClaim?: string;
    CountryClaim?: string;
    UserType?: EVA.Core.UserTypes;
    CreateUsers?: boolean;
    DisallowOtherMethods?: boolean;
  }

  /**
   * Delete an existing OpenID Provider Registration
   */
  export interface DeleteOpenIDProvider {
    /**
     * Entity type: Provider
     */
    ID: number;
  }

  /**
   * List OpenID Provider Registrations
   */
  export interface ListOpenIDProviders {
    PageConfig?: EVA.Core.PageConfig<ListOpenIDProvidersFilter>;
  }

  export interface ListOpenIDProvidersFilter {
    Name?: string;
    Enabled?: boolean;
    Primary?: boolean;
    BaseUrl?: string;
    ClientID?: string;
  }

  export interface ListOpenIDProvidersResponse {
    Result?: EVA.Core.PagedResult<OpenIDProviderDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface OpenIDProviderDto {
    /**
     * Entity type: Provider
     */
    ID?: number;
    BackendID?: string;
    Name?: string;
    Enabled?: boolean;
    Primary?: boolean;
    BaseUrl?: string;
    ClientID?: string;
    FirstNameClaim?: string;
    LastNameClaim?: string;
    /**
     * To identify the user an EmailAddress or Nickname is required, so at least one of EmailAddressClaim/NicknameClaim/UsernameClaim should be set.
     */
    EmailAddressClaim?: string;
    /**
     * To identify the user an EmailAddress or Nickname is required, so at least one of EmailAddressClaim/NicknameClaim/UsernameClaim should be set.
     */
    NicknameClaim?: string;
    /**
     * To identify the user an EmailAddress or Nickname is required, so at least one of EmailAddressClaim/NicknameClaim/UsernameClaim should be set.
     */
    UsernameClaim?: string;
    LanguageClaim?: string;
    CountryClaim?: string;
    UserType?: EVA.Core.UserTypes;
    CreateUsers?: boolean;
    DisallowOtherMethods?: boolean;
  }

  /**
   * Set the provider that will be the default available when logging in, non-primary providers have to be requested.
   */
  export interface SetPrimaryOpenIDProvider {
    /**
     * Entity type: Provider
     */
    ID: number;
  }

}declare module EVA.AvaTax {

  /**
   * Validate the Avatax configuration for the current OrganizationUnit.
   * 
   * Returns a list of messages that contains information about the configuration.
   */
  export interface AvataxValidateConfiguration {
  }

  export interface AvataxValidateConfigurationResponse {
    IsValid: boolean;
    Messages: AvataxValidateConfigurationResponse.ValidationMessage[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace AvataxValidateConfigurationResponse {
    export interface ValidationMessage {
      Error: boolean;
      Message: string;
    }

  }

}declare module EVA.BI {

  /**
   * Returns data that can be displayed as graphs in the frontend. This data is provided by an external system. When no external system is configured, mockdata will be returned.
   */
  export interface GetCustomerCharts {
    /**
     * Entity type: User
     */
    UserID: number;
  }

  export interface GetChartsResponse {
    Elements: ChartElement[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ChartElement {
    Type: ChartElementTypes;
    Title: string;
    Description: string;
    DataSet: any;
  }

  export const enum ChartElementTypes {
    Text = 1,
    Bar = 2,
    Pie = 3,
    Table = 4
  }

  export interface GetDailyStats {
  }

  export interface GetDailyStatsResponse {
    Orders: number;
    Exported: number;
    Shipped: number;
    Products: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GetOrderCounts {
    StartDate?: string;
    EndDate?: string;
  }

  export interface GetOrderCountsResponse {
    Days: GetOrderCountsResponse.DayWithCount[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetOrderCountsResponse {
    export interface DayWithCount {
      Day: string;
      Count: number;
    }

  }

  export interface GetPopularProducts {
    StartDate?: string;
    EndDate?: string;
    Amount?: number;
  }

  export interface GetPopularProductsResponse {
    Products: GetPopularProductsResponse.ProductWithCount[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetPopularProductsResponse {
    export interface ProductWithCount {
      /**
       * Entity type: Product
       */
      ID: number;
      Name: string;
      Count: number;
    }

  }

}declare module EVA.Blobs {

  export namespace Errors {
    export const enum ZipBlobs {
      /**
       * Duplicate path '{0:string}' is not allowed
       */
      DuplicatePaths = 'ZipBlobs:DuplicatePaths'
    }

  }


  /**
   * Creates a new, empty blob. If you wish to store data in there directly, use the `StoreBlob` service instead.
   * 
   * Empty blobs are placeholders; eventually, you'll want to push data in there. This service allows you to create that placeholder, and it is expected you then use the
   * multipart or raw binary `POST` call to `/blob/{Guid}` to push your data.
   * 
   * The combination of `Category` and `OriginalName` must be unique, as the `GetBlobInfoService` allows retrieval based on these values. Internally, a fresh and unique `Guid` is
   * generated and returned from this request. The response also contains the full `Url` by which this blob can be accessed (which will contain aforementioned `Guid`). Use this
   * path to POST your data, too!
   * 
   * - [x] The `MimeType` is required, a few suggestions would be `application/pdf`, `text/csv` or `application/json` - but you probably already know this.
   * - [x] The `ExpireDate` is the date at which the given blob should expire. Leave this empty to *suggest* to keep it forever. We will bag it and get rid of it when the time is right. :hocho:
   * 
   * When retrieving the blob, it will be returned to you using the `MimeType` as `ContentType` header and a proper `Expires` header.
   */
  export interface CreateBlob {
    Category?: string;
    OriginalName?: string;
    MimeType?: string;
    ExpireDate?: string;
    LocationType?: string;
    Uri?: string;
  }

  export interface CreateBlobResponse {
    /**
     * The ID of the newly created blob.
     * Entity type: Blob
     */
    Guid: string;
    /**
     * The URL where the newly created blob can be accessed.
     */
    Url: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Deletes specified blob, either by `BlobID` or `BlobUrl`.
   */
  export interface DeleteBlob {
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrl?: string;
  }

  /**
   * Get information about a blob, either by `Guid` or by `Category` and `OriginalName`.
   */
  export interface GetBlobInfo {
    Guid?: string;
    Category?: string;
    OriginalName?: string;
  }

  export interface GetBlobInfoResponse {
    Guid: string;
    MimeType: string;
    OriginalName: string;
    Category: string;
    ExpireDate?: string;
    LastModificationTimeUtc: string;
    /**
     * In bytes
     */
    Size: number;
    /**
     * @deprecated All services returning a `BlobID` should already return a `BlobUrl` - please use that instead.
     */
    Url?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GetProductImagePlaceholder {
  }

  export interface GetPlaceholderResponse {
    Guid: string;
    Url: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List blobs intended for EVA user documentation.
   * 
   * - When not specifying `PageConfig.Filter.Category`, we will default to `Documentation`
   * - When `PageConfig.Filter.Category` does not start with `Documentation`, we will prefix it with `Documentation`
   */
  export interface ListBlobsForDocumentation {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListBlobsForDocumentationFilter>;
  }

  export interface ListBlobsForDocumentationResponse {
    Result?: EVA.Core.PagedResult<ListBlobsForDocumentationResponse.DocumentationBlob>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListBlobsForDocumentationResponse {
    export interface DocumentationBlob {
      ID: string;
      OriginalName: string;
      MimeType: string;
      Category: string;
      ExpireDate?: string;
      LocationType: string;
      Url: string;
    }

  }

  /**
   * List blobs intended for stencils.
   */
  export interface ListBlobsForStencil {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListBlobsForStencilFilter>;
  }

  export interface ListBlobsForStencilResponse {
    Result?: EVA.Core.PagedResult<ListBlobsForStencilResponse.StencilBlob>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListBlobsForStencilResponse {
    export interface StencilBlob {
      ID: string;
      OriginalName: string;
      MimeType: string;
      Category: string;
      ExpireDate?: string;
      LocationType: string;
      Url: string;
    }

  }

  export interface SetProductImagePlaceholder {
    MimeType: string;
    Data: string;
  }

  export interface SetPlaceholderResponse {
    Guid: string;
    Url: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Creates a new blob and stores `Data` to it.
   * 
   * The combination of `Category` and `OriginalName` must be unique, as the `GetBlobInfoService` allows retrieval based on these values. Internally, a fresh and unique `Guid` is
   * generated and returned from this request. The response also contains the full `Url` by which this blob can be accessed (which will contain aforementioned `Guid`).
   * 
   * - [x] The `MimeType` is required, a few suggestions would be `application/pdf`, `text/csv` or `application/json` - but you probably already know this.
   * - [x] The `ExpireDate` is the date at which the given blob should expire. Leave this empty to *suggest* to keep it forever. We will bag it and get rid of it when the time is right. :hocho:
   * 
   * When retrieving the blob, it will be returned to you using the `MimeType` as `ContentType` header and a proper `Expires` header.
   * 
   * *NOTE*: leaving `OriginalName` empty means EVA treats this file as a temporary one and it'll be removed after a set period. Which can be manipulated through the setting `Blobs:DefaultLifeTime`
   * which is the default expire time for these kinds of blobs in minutes.
   */
  export interface StoreBlob {
    Category?: string;
    OriginalName?: string;
    MimeType: string;
    Data: string;
    ExpireDate?: string;
  }

  export interface StoreBlobResponse {
    Guid: string;
    Url: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Returns a list of blobs as a zip file.
   */
  export interface ZipBlobs {
    /**
     * Name of the generated zip file, will default to 'download.zip' if not specified.
     */
    ZipName?: string;
    /**
     * List of blobs to be included in the zip file.
     */
    Blobs: ZipBlobs.BlobToZip[];
  }

  export namespace ZipBlobs {
    export interface BlobToZip {
      /**
       * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
       * Entity type: Blob
       */
      BlobID?: string;
      /**
       * Can be used for both standard- and secured blobs - must match environment assets URL.
       */
      BlobUrl?: string;
      /**
       * Path of the file in the resulting zip, including filename - when not set, files are set to root using their original blob name or else a random UUID.
       */
      Path?: string;
    }

  }

  export interface ZipBlobsResponse {
    ResourceInfo: EVA.Core.ResourceInfo;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

}declare module EVA.Carrier.Paazl {

  export namespace Errors {
    export const enum Paazl {
      /**
       * Specified `Carrier` is not configured as Shipping Method
       */
      ShippingMethodNotConfigured = 'Paazl:ShippingMethodNotConfigured',
      /**
       * Missing `ZipCode` that is required to retrieve shipping options
       */
      MissingZipCode = 'Paazl:MissingZipCode',
      /**
       * Missing `CountryID` that is required to retrieve shipping options
       */
      MissingCountryID = 'Paazl:MissingCountryID',
      /**
       * Invalid shipping option
       */
      InvalidShippingOption = 'Paazl:InvalidShippingOption',
      /**
       * Please select one address
       */
      SelectAddress = 'Paazl:SelectAddress',
      /**
       * Invalid shipping option address
       */
      InvalidAddress = 'Paazl:InvalidAddress',
      /**
       * Please select one delivery date
       */
      SelectDeliveryDate = 'Paazl:SelectDeliveryDate',
      /**
       * Invalid shipping delivery date
       */
      InvalidDeliveryDate = 'Paazl:InvalidDeliveryDate'
    }

  }


  /**
   * Returns a list of the available shipping options configured in Paazl, taking an `OrderID`. The related order needs to have a Shipping Address
   * set. The parameter `ExtendedDeliveryDateDetails` toggles the `Period` value contents of the `DeliveryDateDetails` property in the response.
   * 
   * This data should be presented to the user, so that a choice can be made between the available options. When the option represents a
   * "pick-up point", the user should additionally be able to select the desired address for delivery, of which the available options are also
   * included in above return data.
   * 
   * Optionally, supply a `ZipCode` and `CountryID` to deviate from specified orders' Shipping Address (eg. to support dynamic pickup points). Note
   * that you'll have to supply the same inputs to `PaazlUpdateShippingOptionsForOrder` if you want to use this feature!
   * 
   * :watch:	Any `Day` mentioned is a date without time, and so it's timezone is irrelevant. Any `From` and `Till` time is in local time to the
   * receipient or pick-up point, and needs to be presented to the user and saved with the `PaazlUpdateShippingOptionsForOrder` without any timezone
   * conversion.
   */
  export interface PaazlGetShippingOptionsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * @default false
     */
    ExtendedDeliveryDateDetails?: boolean;
    ZipCode?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    ShowUnavailable?: boolean;
  }

  export interface PaazlGetShippingOptionsForOrderResponse {
    Result: PaazlShippingOption[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface PaazlShippingOption {
    Type: string;
    Carrier: string;
    Description: string;
    Price?: number;
    DisplayPrice?: number;
    PartOfDay: string;
    DayOfWeek: string;
    IsAvailable: boolean;
    DeliveryDateDetails: PaazlDeliveryDateDetail[];
    Addresses: PaazlShippingAddress[];
    ShippingMethod?: EVA.Core.ShippingMethodDto;
  }

  export interface PaazlDeliveryDateDetail {
    Day: string;
    Period: PaazlPeriod;
  }

  export interface PaazlPeriod {
    From: string;
    Till: string;
  }

  export interface PaazlShippingAddress {
    Name: string;
    Type: string;
    Code: string;
    StreetAndHouseNumber: string;
    ZipCode: string;
    City: string;
    CountryID: string;
    Latitude: number;
    Longitude: number;
    Distance?: number;
    Price?: number;
    DisplayPrice?: number;
    AdditionalInfo: string;
    OpeningHours: PaazlOpeningHours[];
  }

  export interface PaazlOpeningHours {
    DayOfWeek: number;
    AlwaysOpen: boolean;
    Period: PaazlPeriod;
  }

  /**
   * The user choice should be passed to the `PaazlUpdateShippingOptionsForOrder` service, using the same `OrderID` as before, and the selected
   * `PaazlShippingOption` as previously returned by the first service. When not using a pickup point service, leave the `Address` array empty when
   * returning it. When using a pickup point service, return the array with a single element.
   * 
   * If you called `PaazlGetShippingOptionsForOrder` with a `ZipCode`/`CountryID` override, be sure to specify the same values here!
   * 
   * This service is a wrapper around various other services;
   * 
   * * `SetShippingMethod` service to set the entire order to specified shipping method (property `Type` will be mapped to an EVA shipping method)
   * * `UpdateOrderAddresses` service to set the pickup point address as `ShippingAddress` (in case of a pickup point selection)
   * * `SetDeliveryOrderData` service to store the additional delivery data for the order
   * * And it will recalculate the shipping costs, based on this new selection
   */
  export interface PaazlUpdateShippingOptionsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    ShippingOption: PaazlShippingOption;
    ZipCode?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
  }

}declare module EVA.Carrier.PostNL {

  export namespace Errors {
    export const enum PostNL {
      /**
       * There were no valid coordinates provided.
       */
      NoValidCoordinates = 'PostNL:NoValidCoordinates',
      /**
       * There is not ShippingAddress set on the given Order.
       */
      MissingShippingAddress = 'PostNL:MissingShippingAddress'
    }

  }


  /**
   * Creates a shipment barcode & label from PostNL, setting barcode as tracking number and attach label as order document, while also printing it to your current or optionally specified station.
   */
  export interface PostNLCreateShippingLabelForShipment {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
    /**
     * Entity type: Station
     */
    StationID?: number;
  }

  /**
   * List the available PostNL PickupPoints for the given order, in the requested area.
   */
  export interface PostNLGetAvailablePickUpLocationsForArea {
    /**
     * Entity type: Order
     */
    OrderID: number;
    NorthWest: PostNLGetAvailablePickUpLocationsForArea.Coordinate;
    SouthEast: PostNLGetAvailablePickUpLocationsForArea.Coordinate;
  }

  export namespace PostNLGetAvailablePickUpLocationsForArea {
    export interface Coordinate {
      Latitude: number;
      Longitude: number;
    }

  }

  export interface PostNLGetAvailablePickUpLocationsForAreaResponse {
    Locations: Location[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface Location {
    LocationCode: string;
    Name: string;
    Distance?: number;
    Latitude?: number;
    Longitude?: number;
    Address: LocationAddress;
    DeliveryOptions: string[];
    OpeningHours: LocationOpeningHours;
    PartnerName: string;
    PhoneNumber: string;
    RetailNetworkID: string;
    Saleschannel: string;
    TerminalType: string;
  }

  export interface LocationAddress {
    Countrycode: string;
    Zipcode: string;
    HouseNr: string;
    Street: string;
    City: string;
    Remark: string;
  }

  export interface LocationOpeningHours {
    Monday: string[];
    Tuesday: string[];
    Wednesday: string[];
    Thursday: string[];
    Friday: string[];
    Saturday: string[];
    Sunday: string[];
  }

  /**
   * List the available PostNL PickupPoints for the given order. The locations will be based on the ShippingAddress of the Order.
   */
  export interface PostNLGetAvailablePickUpLocationsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface PostNLGetAvailablePickUpLocationsForOrderResponse {
    Locations: Location[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the available PostNL timeframe options for the given order.
   * 
   * * The `StartDate` and `EndDate` parameters are required and inclusive, the time portions will be ignored.
   * * Will cross-reference PostNL timeframes with EVA stock availability and return only valid options for both
   * * When `SkipAvailabilityChecks` is true, the ExpectedAvailabilityDate on the lines is ignored
   * 
   * Only lines set to PostNL will be used for the EVA stock availability check; unless no lines apply, in which case all lines are considered.
   */
  export interface PostNLGetAvailableTimeframesForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    StartDate: string;
    EndDate: string;
    SkipAvailabilityChecks: boolean;
  }

  export interface PostNLGetAvailableTimeframesForOrderResponse {
    Frames: AvailableTimeframeDate[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface AvailableTimeframeDate {
    Date: string;
    Timeframes: AvailableTimeframe[];
  }

  export interface AvailableTimeframe {
    Option: TimeframeOptions;
    StartDateTime: string;
    EndDateTime: string;
    Costs: number;
  }

  export const enum TimeframeOptions {
    /**
     * Daytime delivery
     */
    Daytime = 1,
    /**
     * Evening delivery
     */
    Evening = 2,
    /**
     * Morning delivery before 10:00
     */
    Morning = 4,
    /**
     * Morning delivery before 12:00
     */
    Noon = 8,
    /**
     * Sunday delivery
     */
    Sunday = 16,
    /**
     * Sameday delivery (must be used in combination with Evening)
     */
    Sameday = 32,
    /**
     * Afternoon delivery before 17:00
     */
    Afternoon = 64,
    All = 127
  }

  /**
   * Return the selected PostNL shipping options for the given Order.
   */
  export interface PostNLGetShippingOptionsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface PostNLGetShippingOptionsForOrderResponse {
    Date?: string;
    TimeframeOptions?: TimeframeOptions;
    PickUpLocationID: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Set the requested PostNL shipping options for the given Order.
   */
  export interface PostNLUpdateShippingOptionsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Date?: string;
    TimeframeOptions?: TimeframeOptions;
    PickUpLocationID?: string;
  }

}declare module EVA.Cookbook {

  export interface CreateAccountingRecipe {
    Recipe?: string;
    IsActive?: boolean;
    Name?: string;
  }

  export interface CreateAccountingRecipeResponse {
    /**
     * Entity type: AccountingRecipe
     */
    ID: number;
    HasErrors: boolean;
    Errors: ParseRecipeError[];
    CompletionSuggestions: CompletionSuggestion[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ParseRecipeError {
    Type: ParsingErrorType;
    Message: string;
    SourceLine: string;
    SourceLineNumber: number;
    SourceColumn: number;
  }

  export const enum ParsingErrorType {
    InvalidSyntax = 0,
    UnknownVariable = 1,
    InvalidComparison = 2,
    InvalidOperator = 3,
    MissingCredit = 4,
    MissingDebit = 5,
    AmountMustBeNumerical = 6,
    InvalidBookOnOrganizationUnit = 7,
    InvalidEventType = 8,
    DuplicateVariable = 9,
    InvalidVariable = 10
  }

  export interface CompletionSuggestion {
    Label: string;
    Code: string;
    Type: CompletionSuggestionType;
    Documentation: string;
  }

  export const enum CompletionSuggestionType {
    Variable = 0,
    Keyword = 1,
    Enum = 2,
    Account = 3
  }

  export interface UpdateAccountingRecipe {
    /**
     * Entity type: AccountingRecipe
     */
    ID: number;
    Recipe?: string;
    IsActive?: boolean;
    Name?: string;
  }

  export interface UpdateAccountingRecipeResponse {
    HasErrors: boolean;
    Errors: ParseRecipeError[];
    CompletionSuggestions: CompletionSuggestion[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface DeleteAccountingRecipe {
    /**
     * Entity type: AccountingRecipe
     */
    ID: number;
  }

  export interface ListAccountingRecipes {
    IsActive?: boolean;
    Type?: EVA.Core.FinancialEventTypes;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListAccountingRecipesResponse {
    Result?: EVA.Core.PagedResult<AccountingRecipeDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface AccountingRecipeDto {
    /**
     * Entity type: AccountingRecipe
     */
    ID: number;
    Recipe: string;
    Name: string;
    EventType: EVA.Core.FinancialEventTypes;
    IsActive: boolean;
  }

  export interface GetAccountingRecipe {
    /**
     * Entity type: AccountingRecipe
     */
    ID: number;
  }

  export interface GetAccountingRecipeResponse {
    Recipe: AccountingRecipeDto;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ParseAccountingRecipe {
    Recipe: string;
    CursorPosition?: number;
  }

  export interface ParseRecipeResponse {
    HasErrors: boolean;
    Errors: ParseRecipeError[];
    CompletionSuggestions: CompletionSuggestion[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface PreviewAccountingRecipe {
    Recipes?: AccountingRecipeToPreview[];
    /**
     * Entity type: FinancialEvent
     */
    FinancialEventIDs?: number[];
    /**
     * Entity type: Order
     */
    OrderID?: number;
    Type?: EVA.Core.FinancialEventTypes;
    RecipeType: AccountingRecipeToPreviewType;
  }

  export interface AccountingRecipeToPreview {
    /**
     * Entity type: AccountingRecipe
     */
    ID?: number;
    Recipe: string;
  }

  export const enum AccountingRecipeToPreviewType {
    V1 = 0,
    V2 = 1
  }

  export interface PreviewAccountingRecipeResponse {
    Warnings: string[];
    BookingPreviewSummaries: AccountBookingPreview[];
    BookingPreviewDetails: AccountBookingDetails[];
    HasErrors: boolean;
    Errors: ParseRecipeError[];
    CompletionSuggestions: CompletionSuggestion[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface AccountBookingPreview {
    Date: string;
    /**
     * Entity type: OrganizationUnit
     */
    BookedOnOrganizationUnitID: number;
    BookedOnOrganizationUnitName: string;
    /**
     * Entity type: Account
     */
    BookedOnAccountID: number;
    BookedOnAccountNumber: string;
    BookedOnAccountName: string;
    Amount: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    Offset1: string;
    Offset2: string;
    Offset3: string;
    Offset4: string;
    Offset5: string;
    Offset6: string;
    Offset7: string;
    Offset8: string;
    Offset9: string;
  }

  export interface AccountBookingDetails {
    Amount: number;
    /**
     * Entity type: OrganizationUnit
     */
    BookedOnOrganizationUnitID: number;
    BookedOnOrganizationUnitName: string;
    /**
     * Entity type: Account
     */
    BookedOnAccountID: number;
    BookedOnAccountNumber: string;
    BookedOnAccountName: string;
    /**
     * Entity type: AccountingRecipe
     */
    AccountingRecipeID: number;
    Date: string;
    Description: string;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    Offset1: string;
    Offset2: string;
    Offset3: string;
    Offset4: string;
    Offset5: string;
    Offset6: string;
    Offset7: string;
    Offset8: string;
    Offset9: string;
  }

  export interface GetAccountingRecipeHistory {
    /**
     * Entity type: AccountingRecipe
     */
    ID: number;
  }

  export interface GetAccountingRecipeHistoryResponse {
    Entries: GetAccountingRecipeHistoryResponse.AccountingRecipeEntry[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAccountingRecipeHistoryResponse {
    export interface AccountingRecipeEntry {
      /**
       * Entity type: AccountingRecipe
       */
      ID: number;
      Recipe: string;
      Name: string;
      Revision: number;
      EventType: EVA.Core.FinancialEventTypes;
      IsActive: boolean;
      ModifiedByEmail?: string;
      /**
       * Entity type: User
       */
      ModifiedByUserID?: number;
      ModifiedAt?: string;
      ExistedFrom: string;
      ExistedTill: string;
    }

  }

  /**
   * Compares V1 and V2 scripts for a given set of events. This is a temporary service to aid in the migration of V1 scripts to V2.
   */
  export interface CookbookMigrationComparison {
    /**
     * The list of V1 scripts to use in the comparison. If not supplied, will use all active V1 scripts.
     * Entity type: AccountingRecipe
     */
    ScriptsV1?: number[];
    /**
     * The list of V2 scripts to use in the comparison. If not supplied, will use all active V2 scripts.
     * Entity type: Script
     */
    ScriptsV2?: number[];
    /**
     * List of event IDs to use in the comparison.
     * Entity type: FinancialEvent
     */
    EventIDs?: number[];
    /**
     * The start date to use in the comparison.
     */
    StartDate?: string;
    /**
     * The end date to use in the comparison.
     */
    EndDate?: string;
    /**
     * The financial period ID to use in the comparison.
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    /**
     * The maximum amounts of events to compare - defaults to 25.000, max at 100.000.
     * @default 25000
     * Range: 1-100000
     */
    Limit?: number;
  }

  export interface CookbookMigrationComparisonResponse {
    /**
     * The list of events that are missing in the new processing.
     */
    MissingEvents: GeneralLedgerRecord[];
    /**
     * The list of events that are unexpected in the new processing.
     */
    UnexpectedEvents: GeneralLedgerRecord[];
    /**
     * The list of events that are matching in both processings.
     */
    MatchingEvents: GeneralLedgerRecord[];
    /**
     * The list of events that are returned by the old processing.
     */
    OldEvents: GeneralLedgerRecord[];
    /**
     * The list of events that are returned by the new processing.
     */
    NewEvents: GeneralLedgerRecord[];
    /**
     * The list of warnings for the old processing.
     */
    WarningsOld: Warning[];
    /**
     * The list of warnings for the new processing.
     */
    WarningsNew: Warning[];
    /**
     * Indicates whether the event limit was reached.
     */
    ReachedEventsLimit: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GeneralLedgerRecord {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: Account
     */
    AccountID: number;
    Amount: number;
    Remark: string;
    IsProcessed: boolean;
    /**
     * Entity type: StockMutation
     */
    StockMutationID?: number;
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
    Reference: string;
    Offset1: string;
    Offset2: string;
    Offset3: string;
    Offset4: string;
    Offset5: string;
    Offset6: string;
    Offset7: string;
    Offset8: string;
    Offset9: string;
    TaxCodeID?: number;
    TaxAmount?: number;
    TaxRate?: number;
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    CurrencyID: string;
    Source: string;
    /**
     * Entity type: FinancialEvent
     */
    FinancialEventID?: number;
    GeneratedTime?: string;
    Description: string;
    TaxBookingCode: string;
  }

  export interface Warning {
    Type: string;
    Message: string;
  }

}declare module EVA.Core.LiveGuard {

  export namespace Errors {
    export const enum LiveGuard {
      /**
       * You're not allowed to generate this liveguard api key.
       */
      NotAllowedToGenerateApiKey = 'LiveGuard:NotAllowedToGenerateApiKey',
      /**
       * You're not allowed to generate this liveguard secret.
       */
      NotAllowedToGenerateSecret = 'LiveGuard:NotAllowedToGenerateSecret',
      /**
       * This is a stub order for offline evapay payments, no mutations allowed.
       */
      UnableToMutateEVAPayStub = 'LiveGuard:UnableToMutateEVAPayStub'
    }

    export const enum LiveGuardCertificate {
      /**
       * The configuration is invalid.
       */
      InvalidConfiguration = 'LiveGuardCertificate:InvalidConfiguration',
      /**
       * No valid Watchtower for this request.
       */
      NoValidWatchtower = 'LiveGuardCertificate:NoValidWatchtower',
      /**
       * CSR could not be parsed.
       */
      CsrInvalid = 'LiveGuardCertificate:CsrInvalid',
      /**
       * Failed to generate the certificate.
       */
      CertificateGenerationFailed = 'LiveGuardCertificate:CertificateGenerationFailed',
      /**
       * Hostname for this Watchtower does not match the hostname in the CSR.
       */
      HostnameMismatch = 'LiveGuardCertificate:HostnameMismatch'
    }

    export const enum LiveGuardVPN {
      /**
       * The configuration is invalid.
       */
      InvalidConfiguration = 'LiveGuardVPN:InvalidConfiguration',
      /**
       * No valid Watchtower for this request.
       */
      NoValidWatchtower = 'LiveGuardVPN:NoValidWatchtower',
      /**
       * Failed to check for existing config.
       */
      ExistsCheckFailed = 'LiveGuardVPN:ExistsCheckFailed',
      /**
       * Failed to create new config.
       */
      CreateFailed = 'LiveGuardVPN:CreateFailed'
    }

    export const enum LiveGuardExecuteTask {
      /**
       * There is no current connection to the selected device.
       */
      NoConnection = 'LiveGuardExecuteTask:NoConnection'
    }

    export const enum LiveGuardLockStatus {
      /**
       * This watchtower is not connected.
       */
      NotConnected = 'LiveGuardLockStatus:NotConnected',
      /**
       * Failed to lock the device.
       */
      LockFailed = 'LiveGuardLockStatus:LockFailed',
      /**
       * Failed to unlock the device.
       */
      UnlockFailed = 'LiveGuardLockStatus:UnlockFailed'
    }

    export const enum WatchtowerExecuteCommand {
      /**
       * There is no current connection to the selected device.
       */
      NoConnection = 'WatchtowerExecuteCommand:NoConnection'
    }

    export const enum WatchtowerIO {
      /**
       * Failed to connect to the device.
       */
      ConnectionFailed = 'WatchtowerIO:ConnectionFailed'
    }

    export const enum MenderClient {
      /**
       * No registration request found for this device. (Please reboot the device and try again)
       */
      NoRegistrationRequest = 'MenderClient:NoRegistrationRequest'
    }

    export const enum LocalModeManager {
      /**
       * You can only force local mode on shops.
       */
      CanForceLocalModeOnlyOnShop = 'LocalModeManager:CanForceLocalModeOnlyOnShop'
    }

    export const enum FleetManagerErrors {
      /**
       * Device with HardwareID {hardwareID:string} already exists with ID {deviceID:number}.
       */
      DeviceAlreadyExists = 'FleetManagerErrors:DeviceAlreadyExists',
      /**
       * OrganizationUnit {organizationUnitID:number} already has a watchtower with ID {deviceID:number}.
       */
      DuplicateOrganizationUnit = 'FleetManagerErrors:DuplicateOrganizationUnit'
    }

    export const enum FleetManager {
      /**
       * Could not determine a matching FleetManager.
       */
      UnableToDetermineFleetManager = 'FleetManager:UnableToDetermineFleetManager',
      /**
       * The FleetManager {0:string} is not available.
       */
      FleetManagerNotAvailable = 'FleetManager:FleetManagerNotAvailable',
      /**
       * Device with HardwareID {hardwareID:string} was not found in FleetManager {fleetManager:string}.
       */
      DeviceNotInFleetManager = 'FleetManager:DeviceNotInFleetManager',
      /**
       * Device is not valid for this FleetManager.
       */
      InvalidDevice = 'FleetManager:InvalidDevice',
      /**
       * Device was already boarded.
       */
      DeviceAlreadyBoarded = 'FleetManager:DeviceAlreadyBoarded',
      /**
       * Error while boarding the device: {0:string}
       */
      BoardingFailed = 'FleetManager:BoardingFailed'
    }

  }


  /**
   * Get user information to sync to LiveGuard
   */
  export interface GetUserForLiveGuard {
    /**
     * Entity type: User
     */
    UserID?: number;
    EmailAddress?: string;
    NickName?: string;
  }

  export interface GetUserForLiveGuardResponse {
    EmailAddress?: string;
    Nickname?: string;
    FirstName?: string;
    LastName?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    Type?: EVA.Core.UserTypes;
    BackendSystemID?: string;
    BackendID?: string;
    TimeZone?: string;
    AuthenticationData?: GetUserForLiveGuardResponse.AuthenticationDataDto[];
    Roles?: GetUserForLiveGuardResponse.RoleDto[];
    /**
     * Entity type: User
     */
    CloudIDs?: number[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetUserForLiveGuardResponse {
    export interface RoleDto {
      Name: string;
      Code: string;
      UserType: EVA.Core.UserTypes;
      GlobalID: string;
      DeactivateUserAfterInactiveDays?: number;
      Functionalities: GetUserForLiveGuardResponse.FunctionalityDto[];
    }

    export interface FunctionalityDto {
      Functionality: string;
      FunctionalityScope: EVA.Core.FunctionalityScope;
      ElevationType: EVA.Core.ElevationType;
    }

    export interface AuthenticationDataDto {
      Type: string;
      Data: string;
      SearchKey: string;
    }

  }

  export interface LiveGuardGenerateApiKey {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface LiveGuardGenerateApiKeyResponse {
    ApiKey: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Generate a trust token that needs to be provided in the Login call to the cloud to verify local presence
   */
  export interface LiveGuardGenerateTrustToken {
  }

  export interface LiveGuardGenerateTrustTokenResponse {
    TrustToken: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Retreive current chain status for the connected watchtower
   */
  export interface LiveGuardGetAuditChains {
  }

  export interface LiveGuardGetAuditChainsResponse {
    Chains: ChainDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ChainDto {
    /**
     * Entity type: AuditChain
     */
    ID: number;
    Identifier: string;
    Discriminator: number;
    Type: EVA.Core.AuditChainTypes;
    Version: number;
    CurrentSequenceNumber: number;
    PreviousSequenceNumber?: number;
    CurrentSignature: string;
    PreviousSignature: string;
    RecentLedgers: LiveGuardPushOrder.ChainLedgerDto[];
  }

  /**
   * Service called by a liveguard instance to generate an authentication token for an authorized user on the liveguard
   * 
   * Can only be called by the liveguard user
   */
  export interface LiveGuardGetTokenForUser {
    Username: string;
    UseJwtTokens?: boolean;
  }

  export interface LiveGuardGetTokenForUserResponse {
    AuthenticationToken: string;
    RefreshToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Retreive current secret for TOTP token usage
   */
  export interface LiveGuardGetTOTPSecret {
  }

  export interface LiveGuardGetTOTPSecretResponse {
    Secret: EVA.Core.TOTPSecretWrapper;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Accepts an Order pushed from a LiveGuard instance
   */
  export interface LiveGuardPushOrder {
    LiveGuardOrderID?: string;
    DisplayID?: string;
    CreationTime?: string;
    Remark?: string;
    Customer?: LiveGuardPushOrder.CustomerDto;
    ShippingAddress?: EVA.Core.AddressDataDto;
    BillingAddress?: EVA.Core.AddressDataDto;
    PickupAddress?: EVA.Core.AddressDataDto;
    Lines?: LiveGuardPushOrder.OrderLineDto[];
    Payments?: LiveGuardPushOrder.PaymentDto[];
    IsPaid?: boolean;
    SoldBy?: string;
    Blobs?: LiveGuardPushOrder.OrderBlobDto[];
    Invoices?: LiveGuardPushOrder.InvoiceDto[];
    Chains?: ChainDto[];
    BlobID: string;
    IsShipped?: boolean;
    CustomerIdentifiers?: LiveGuardPushOrder.OrderCustomerIdentifiersDto;
    BoardingPass?: LiveGuardPushOrder.BoardingPassDto;
  }

  export namespace LiveGuardPushOrder {
    export interface OrderCustomerIdentifiersDto {
      UserID?: string;
      UserSubscriptionID?: string;
      UserBackendID?: string;
      UserCustomID?: string;
      EmailAddress?: string;
    }

    export interface OrderBlobDto {
      /**
       * Entity type: Invoice
       */
      InvoiceID?: number;
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      Name: string;
      Type: EVA.Core.OrderBlobTypes;
      BlobID: string;
    }

    export interface InvoiceLineTaxDetailDto {
      TaxRate: number;
      TaxAmount: number;
      TaxName: string;
      TaxType: string;
      TaxSubType: string;
      TaxSubTypeName: string;
    }

    export interface InvoiceLineDiscountDetailDto {
      CloudID?: number;
      BackendID: string;
      Description: string;
      Amount: number;
    }

    export interface InvoiceLineDto {
      InvoiceData: LiveGuardPushOrder.InvoiceDataDto[];
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      TaxRate: number;
      TaxCode?: string;
      TaxRateCategory?: EVA.Core.TaxRateCategory;
      UnitCost?: number;
      UnitPrice?: number;
      Quantity: number;
      TotalAmountInvoiced: number;
      TotalAmountInvoicedInTax: number;
      DiscountAmount: number;
      DiscountDetails: LiveGuardPushOrder.InvoiceLineDiscountDetailDto[];
      TaxDetails: LiveGuardPushOrder.InvoiceLineTaxDetailDto[];
      InvoicedBy: string;
      Type: EVA.Core.InvoiceLineTypes;
      TaxAmount?: number;
      Description?: string;
      UnitPriceInTax: number;
      NetTaxAmount: number;
      TotalTaxAmount: number;
    }

    export interface InvoiceDataDto {
      Type: string;
      Data: string;
      SearchKey: string;
    }

    export interface InvoiceBlobDto {
      BackendID: string;
      OriginalName: string;
      MimeType: string;
      Category: string;
      BlobID: string;
    }

    export interface InvoiceUserDataDto {
      EmailAddress: string;
      BackendRelationID: string;
      Initials: string;
      FirstName: string;
      LastName: string;
      Gender: string;
      BillingAddress: EVA.Core.AddressDataDto;
      ShippingAddress: EVA.Core.AddressDataDto;
      Company: EVA.Core.CompanyDto;
      FiscalID: string;
      BankAccount: string;
      PhoneNumber: string;
      LanguageID: string;
      CountryID: string;
      OrganizationUnitName: string;
      OrganizationUnitBackendID: string;
      OrganizationUnitBranchNumber: string;
      OrganizationUnitCompany: EVA.Core.CompanyDto;
      OrganizationUnitCompanyVatNumber: string;
      OrganizationUnitEstablishmentNumber?: string;
      OrganizationUnitCountryID?: string;
      OrganizationUnitAddress1?: string;
      OrganizationUnitAddress2?: string;
      OrganizationUnitHouseNumber?: string;
      OrganizationUnitDistrict?: string;
      OrganizationUnitSubDistrict?: string;
      OrganizationUnitCity?: string;
      OrganizationUnitZipCode?: string;
      OrganizationUnitState?: string;
      OrganizationUnitEmailAddress?: string;
      OrganizationUnitPhoneNumber?: string;
      OrganizationUnitWebsite?: string;
      OrganizationUnitBIC?: string;
    }

    export interface InvoiceDocumentLedgerDto {
      Type: EVA.Core.InvoiceDocumentLedgerTypes;
      /**
       * Entity type: AuditChain
       */
      ChainID?: number;
      SequenceNumber: number;
      PreviousSequenceNumber?: number;
      Signature: string;
      PreviousSignature: string;
      IsSuccess: boolean;
      FailureReason: string;
      ReportContentBlobID?: string;
      InvoiceDocumentLedgerData: EVA.Core.InvoiceDocumentLedgerData;
      Format: EVA.Core.InvoiceDocumentLedgerFormats;
      ReprintNumber?: number;
      /**
       * Entity type: Device
       */
      OriginalDeviceID?: number;
    }

    export interface InvoiceDto {
      /**
       * Entity type: Invoice
       */
      ID: number;
      InvoiceNumber: string;
      InvoiceDate?: string;
      Lines: LiveGuardPushOrder.InvoiceLineDto[];
      TotalAmount: number;
      Description: string;
      Status: EVA.Core.InvoiceStatuses;
      Blobs: LiveGuardPushOrder.InvoiceBlobDto[];
      Type: EVA.Core.InvoiceTypes;
      AuditingProvider: string;
      BackendTypeID?: number;
      CurrencyID: string;
      PrintCount: number;
      FiscalID: string;
      VatNumber: string;
      InvoiceData: LiveGuardPushOrder.InvoiceDataDto[];
      UserData: LiveGuardPushOrder.InvoiceUserDataDto;
      DocumentLedger: LiveGuardPushOrder.InvoiceDocumentLedgerDto[];
      /**
       * Entity type: AuditChain
       */
      ChainID?: number;
      Signature: string;
      PreviousSignature: string;
      SequenceNumber?: number;
      /**
       * Entity type: Station
       */
      StationID?: string;
      TaxReverseCharge: boolean;
      CalculationMethod: EVA.Core.InvoiceCalculationMethod;
      BackendSystemID: string;
      BackendID: string;
      ReferencedInvoice?: string;
      ExpirationDate?: string;
    }

    export interface CustomerDto {
      /**
       * Entity type: User
       */
      LiveGuardID: number;
      FirstName: string;
      LastName: string;
      EmailAddress: string;
      PhoneNumber: string;
      LanguageID: string;
      CountryID: string;
      Gender: string;
    }

    export interface OrderLineDto {
      /**
       * Entity type: OrderLine
       */
      ID: number;
      BackendID?: string;
      CustomID?: string;
      Amount: number;
      TaxRate: number;
      TaxRateCategory?: EVA.Core.TaxRateCategory;
      Quantity: number;
      Description: string;
      SerialNumber?: string;
      UnitPriceBeforeCorrection?: number;
      UnitPriceBeforeCorrectionInTax?: number;
      ReturnReason?: string;
      ReturnReasonType?: EVA.Core.ReturnReasonType;
      UnitPriceCorrectionReason: string;
      Discounts: LiveGuardPushOrder.OrderLineDiscount[];
      TaxDetails: LiveGuardPushOrder.OrderLineTaxDetail[];
      StockProductBackendID: string;
    }

    export interface OrderLineTaxDetail {
      TaxRate: number;
      TaxAmount: number;
      TaxName: string;
      TaxType: string;
      TaxSubType: string;
      TaxSubTypeName: string;
    }

    export interface OrderLineDiscount {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      BackendID: string;
      Description: string;
      Amount: number;
      CloudID?: number;
    }

    export interface PaymentDto {
      BackendID: string;
      Method: string;
      Type: string;
      Amount: number;
      Data: string;
      DataObjects: string;
      /**
       * Entity type: PaymentTransaction
       */
      ID: number;
      /**
       * Entity type: Device
       */
      OriginalDeviceID?: number;
    }

    export interface ChainLedgerDto {
      NewSequenceNumber: number;
      PreviousSequenceNumber?: number;
      NewSignature: string;
      PreviousSignature: string;
      CreationTime: string;
    }

    export interface BoardingPassDto {
      Format: string;
      NumberOfLegs: number;
      Name: string;
      Type: string;
      OperatingCarrierPNRCode: string;
      DepartingAirportCode: string;
      DestinationAirportCode: string;
      AirlineCompanyCode: string;
      FlightNumber: number;
      JulianDate: number;
      Cabin: string;
      Seat: string;
      CheckinSequence: number;
      Status: number;
      Data: string;
    }

  }

  export interface LiveGuardPushOrderResponse {
    /**
     * Entity type: Order
     */
    ID: number;
    AlreadyExists: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface LiveGuardSyncCatalogByBlob {
  }

  export interface LiveGuardSyncCatalogByBlobResponse {
    Products: string;
    Bundles: string;
    PriceList: string;
    PromotionPriceList: string;
    EcoTaxPriceList: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface LiveGuardSyncGeneralByBlob {
  }

  export interface LiveGuardSyncGeneralByBlobResponse {
    Url?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface LiveGuardSyncUsersByBlob {
  }

  export interface LiveGuardSyncUsersByBlobResponse {
    Url?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Trigger a full sync on a liveguard instance, this has major performance impact for a while
   */
  export interface LiveGuardTriggerSync {
  }

  /**
   * Validate the given token with the cloud, and if valid, trust the chain.
   */
  export interface LiveGuardValidateToken {
    LocalChainID?: string;
    CloudChainID?: string;
    AuthenticationToken?: string;
  }

  export interface LiveGuardValidateTokenResponse {
    ChainID?: string;
    /**
     * Entity type: User
     */
    UserID?: number;
    EmailAddress?: string;
    Nickname?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface EVAStatus {
  }

  export interface EVAStatusResponse {
    Ready: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Returns some basic information about the current state of the liveGuard
   */
  export interface LiveGuardGetInformation {
  }

  export interface LiveGuardGetInformationResponse {
    HardwareID?: string;
    Version: string;
    OrganizationUnitName: string;
    OrganizationUnitBackendID: string;
    ProductsCount: number;
    UsersCount: number;
    SettingsCount: number;
    PendingOrderExports: number;
    LastGeneralSync?: string;
    LastUserSync?: string;
    LastCatalogSync?: string;
    GeneralTaskState?: EVA.Core.TaskState;
    CatalogTaskState?: EVA.Core.TaskState;
    UserTaskState?: EVA.Core.TaskState;
    GeneralTaskLastRun?: string;
    CatalogTaskLastRun?: string;
    UserTaskLastRun?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Push metrics of the watchtower device to the cloud.
   */
  export interface LiveGuardPushMetrics {
    HardwareID?: string;
    State?: string;
    EVAVersion?: string;
    IOVersion?: string;
    OSVersion?: string;
    CPUUsage?: number;
    DiskUsage?: number;
    RAMUsage?: number;
    LastBootTime?: string;
    Temperature?: number;
    Latency?: number;
    AvgLatency?: number;
    DNSLatency?: number;
    Logs?: EVA.Core.WatchtowerLog[];
  }

  /**
   * This service overrides the operational flags for a liveguard instance.
   * 
   * This should never be used in production environments. This is used to mimick offline scenario's in liveguard deployments in the cloud.
   */
  export interface LiveGuardSetStatus {
    /**
     * Flag this environment as if it's running on a watchtower device. Will disable a lot of functionality.
     */
    RunningOnWatchtower?: boolean;
    /**
     * Flag this environment as if it has no working internet connection. Will disable a lot of functionality.
     */
    InternetAvailable?: boolean;
    /**
     * Flag this environment as if the cloud deployment of EVA is not availabled. Will disable a lot of functionality.
     */
    EVACloudAvailable?: boolean;
    /**
     * Disable the automatic task that checks for Internet/EVACloud. This should be set to true if these properties need to be managed by hand.
     */
    DisableCheckTask?: boolean;
  }

  /**
   * This service returns the operational flags for a liveguard instance.
   */
  export interface LiveGuardGetStatus {
  }

  export interface LiveGuardGetStatusResponse {
    RunningOnWatchtower: boolean;
    InternetAvailable: boolean;
    EVACloudAvailable: boolean;
    DisableCheckTask: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new SSL certificate for a Watchtower device.
   */
  export interface CreateWatchtowerCertificate {
    CertificateSigningRequest: string;
  }

  export interface CreateWatchtowerCertificateResponse {
    Certificate: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new watchtower device
   * 
   * To create a device for fallback IO, leave the HardwareID null
   * When a HardwareID is set, the device will be boarded and prepared for use.
   */
  export interface CreateWatchtowerDevice {
    Name: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    HardwareID?: string;
  }

  export interface CreateWatchtowerDeviceResponse {
    /**
     * Entity type: Device
     */
    ID?: number;
    ApiKey?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new VPN Configuration for a Watchtower device.
   */
  export interface CreateWatchtowerVPNConfiguration {
  }

  export interface CreateWatchtowerVPNConfigurationResponse {
    Config: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Execute a command on a device
   */
  export interface LiveGuardExecuteTask {
    /**
     * Entity type: Device
     */
    DeviceID: number;
    Catalog?: boolean;
    General?: boolean;
    Users?: boolean;
  }

  /**
   * Push the current configuration for the given device to mender
   */
  export interface PushWatchtowerConfigurationToDevice {
    /**
     * Entity type: Device
     */
    DeviceID: number;
  }

  /**
   * Update the lock status of a watchtower device.
   * 
   * This can only be done when the device is online
   */
  export interface ToggleLockStatusForWatchtowerDevice {
    /**
     * Entity type: Device
     */
    DeviceID: number;
    IsLocked: boolean;
  }

  /**
   * Execute a command on a device
   */
  export interface WatchtowerExecuteCommand {
    /**
     * Entity type: Device
     */
    DeviceID: number;
    Type: string;
    Address?: string;
    Port?: number;
  }

  export interface WatchtowerExecuteCommandResponse {
    Output?: string;
    Success?: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get details about the given device.
   */
  export interface WatchtowerGetDeviceDetails {
    /**
     * Entity type: Device
     */
    DeviceID: number;
  }

  export interface WatchtowerGetDeviceDetailsResponse {
    ID?: number;
    FleetManagerID?: string;
    HardwareID?: string;
    Virtual?: boolean;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OrganizationUnitName?: string;
    OrganizationUnitBackendID?: string;
    /**
     * Entity type: Country
     */
    OrganizationUnitCountryID?: string;
    OrganizationUnitStatus?: EVA.Core.OrganizationUnitStatus;
    FleetManagerLastCheckIn?: string;
    WatchtowerIOConnected?: boolean;
    WatchtowerIOLastSeen?: string;
    WatchtowerConnected?: boolean;
    WatchtowerLastSeen?: string;
    Online?: boolean;
    LastSeen?: string;
    Locked?: boolean;
    ForceLocalMode?: boolean;
    OSVersion?: string;
    OSVersionLastCheckinTime?: string;
    State?: string;
    StateLastCheckinTime?: string;
    EVAVersion?: string;
    EVAVersionLastCheckinTime?: string;
    IOVersion?: string;
    IOVersionLastCheckinTime?: string;
    LiveGuardStateLastCheckinTime?: string;
    GeneralTaskState?: EVA.Core.TaskState;
    GeneralTaskStateLastRunTime?: string;
    CatalogTaskState?: EVA.Core.TaskState;
    CatalogTaskStateLastRunTime?: string;
    UserTaskState?: EVA.Core.TaskState;
    UserTaskStateLastRunTime?: string;
    ProductsCount?: number;
    UsersCount?: number;
    SettingsCount?: number;
    PendingOrderExports?: number;
    NetworkInterfaces?: WatchtowerGetDeviceDetailsResponse.NetworkInterface[];
    FleetManagerStatus?: FleetManagerDeviceStatus;
    Logs?: EVA.Core.WatchtowerLog[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace WatchtowerGetDeviceDetailsResponse {
    export interface NetworkInterface {
      Name: string;
      MacAddress: string;
      IPV4?: string;
      IPV6?: string;
    }

  }

  export const enum FleetManagerDeviceStatus {
    Accepted = 1,
    Pending = 2,
    Rejected = 3,
    Preauthorized = 4,
    Noauth = 5
  }

  /**
   * List the configured watchtower devices with their status
   * 
   * Sorting is supported on the following properties:
   * - ID
   * - Name
   * - HardwareID
   * - OrganizationUnitID
   * - OrganizationUnitBackendID
   * - OrganizationUnitName
   * - OrganizationUnitCountryID
   * - OrganizationUnitStatus
   * - WatchtowerIOConnected
   * - WatchtowerIOLastSeen
   * - ForceLocalMode
   */
  export interface ListWatchtowerDevices {
    PageConfig?: EVA.Core.PageConfig<ListWatchtowerDevicesFilter>;
  }

  export interface ListWatchtowerDevicesFilter {
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OrganizationUnitStatus?: EVA.Core.OrganizationUnitStatus;
    IncludeChildOrganizationUnits?: boolean;
    /**
     * Entity type: Device
     */
    DeviceID?: number;
    FleetManagerID?: string;
    HardwareID?: string;
    IsWatchtowerIOConnected?: boolean;
    IsWatchtowerConnected?: boolean;
    IsWatchtowerOnline?: boolean;
    IsLocked?: boolean;
    ForceLocalMode?: boolean;
  }

  export interface ListWatchtowerDevicesResponse {
    Result?: EVA.Core.PagedResult<ListWatchtowerDevicesResponse.Watchtower>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListWatchtowerDevicesResponse {
    export interface Watchtower {
      /**
       * Entity type: Device
       */
      ID: number;
      Name: string;
      HardwareID: string;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      OrganizationUnitBackendID?: string;
      OrganizationUnitName: string;
      /**
       * Entity type: Country
       */
      OrganizationUnitCountryID: string;
      OrganizationUnitStatus: EVA.Core.OrganizationUnitStatus;
      WatchtowerIOConnected: boolean;
      WatchtowerIOLastSeen?: string;
      WatchtowerConnected: boolean;
      WatchtowerLastSeen?: string;
      Online: boolean;
      LastSeen?: string;
      Locked: boolean;
      ForceLocalMode: boolean;
    }

  }

  /**
   * Get an authentication token that's valid in the cloud for the current user
   */
  export interface LiveGuardGetCloudToken {
    UseJwtTokens?: boolean;
  }

  export interface LiveGuardGetCloudTokenResponse {
    AuthenticationToken: string;
    RefreshToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Returns id mapping for cloud vs liveguard entities
   */
  export interface LiveGuardGetMapping {
  }

  export interface LiveGuardGetMappingResponse {
    Mapping: { [key: string]: { [key: number]: number } };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get a trust token that needs to be provided in the Login call to the cloud to verify local presence
   */
  export interface LiveGuardGetTrustToken {
  }

  export interface LiveGuardGetTrustTokenResponse {
    TrustToken: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

}declare module EVA.Core.Management {

  export namespace Errors {
    export const enum UserOrigins {
      /**
       * This UserOrigin already exists
       */
      AlreadyExists = 'UserOrigins:AlreadyExists'
    }

    export const enum CreateEmployee {
      /**
       * This user already exists, use the UpdateUser service.
       */
      UserAlreadyExists = 'CreateEmployee:UserAlreadyExists',
      /**
       * There is already an existing customer.
       */
      ExistingCustomer = 'CreateEmployee:ExistingCustomer'
    }

    export const enum GenerateIdentificationCode {
      /**
       * Cannot generate identification codes for Single Sign-On users.
       */
      CannotGenerateIdentificationCodeForSingleSignOn = 'GenerateIdentificationCode:CannotGenerateIdentificationCodeForSingleSignOn'
    }

    export const enum TaxService {
      /**
       * StartDate ({0:string}) cannot be after EndDate: ({1:string})
       */
      StartDateShouldBeBeforeEndDate = 'TaxService:StartDateShouldBeBeforeEndDate',
      /**
       * StartDate cannot exist without EndDate and vice-versa
       */
      StartAndEndDateRequired = 'TaxService:StartAndEndDateRequired',
      /**
       * Validation of the Excel file failed: {0:string}
       */
      InvalidExcelFile = 'TaxService:InvalidExcelFile'
    }

    export const enum StockAllocations {
      /**
       * It's required to specify an OrganizationUnit to create this StockAllocationRule.
       */
      OrganizationUnitRequired = 'StockAllocations:OrganizationUnitRequired',
      /**
       * OrganizationUnit {0:number} is not directly supplied by OrganizationUnit {1:number}.
       */
      InvalidOrganizationUnit = 'StockAllocations:InvalidOrganizationUnit'
    }

    export const enum StockAllocationRules {
      /**
       * Validation of the Excel file failed: {0:string}
       */
      UploadStockAllocationRuleValidationError = 'StockAllocationRules:UploadStockAllocationRuleValidationError'
    }

    export const enum StockLabels {
      /**
       * StockLabel with name '{0:string}' already exists
       */
      AlreadyExists = 'StockLabels:AlreadyExists'
    }

    export const enum OrganizationUnitShippingMethod {
      /**
       * OrganizationUnitShippingMethod already exists
       */
      OrganizationUnitShippingMethodAlreadyExists = 'OrganizationUnitShippingMethod:OrganizationUnitShippingMethodAlreadyExists'
    }

    export const enum Roles {
      /**
       * The code `{0:string}` is preserved for system roles.
       */
      CodeIsPreservedForSystemRoles = 'Roles:CodeIsPreservedForSystemRoles',
      /**
       * Cannot modify or delete New Black system roles.
       */
      CannotModifyOrDeleteNewBlackRole = 'Roles:CannotModifyOrDeleteNewBlackRole'
    }

    export const enum RoleSets {
      /**
       * A role set with BackendID '{0:string}' already exists
       */
      RoleSetWithBackendIDAlreadyExists = 'RoleSets:RoleSetWithBackendIDAlreadyExists',
      /**
       * Role set '{0:string}' is still attached to organization units
       */
      RoleSetIsStillAttached = 'RoleSets:RoleSetIsStillAttached'
    }

    export const enum ProductBarcodes {
      /**
       * Barcode {barcode:string} already exists for ProductID {productID:number}
       */
      BarcodeAlreadyExists = 'ProductBarcodes:BarcodeAlreadyExists',
      /**
       * Product not found
       */
      ProductNotFound = 'ProductBarcodes:ProductNotFound',
      /**
       * UnitOfMeasure not found
       */
      UnitOfMeasureNotFound = 'ProductBarcodes:UnitOfMeasureNotFound'
    }

    export const enum ProductRequirements {
      /**
       * The supplied backendid already exists.
       */
      DuplicateBackendID = 'ProductRequirements:DuplicateBackendID'
    }

    export const enum ProductUnitOfMeasures {
      /**
       * Product not found
       */
      ProductNotFound = 'ProductUnitOfMeasures:ProductNotFound',
      /**
       * UnitOfMeasure not found
       */
      UnitOfMeasureNotFound = 'ProductUnitOfMeasures:UnitOfMeasureNotFound',
      /**
       * The Quantity should be greather than 0
       */
      InvalidQuantity = 'ProductUnitOfMeasures:InvalidQuantity'
    }

    export const enum UnitOfMeasures {
      /**
       * This UnitOfMeasure already exists
       */
      AlreadyExists = 'UnitOfMeasures:AlreadyExists'
    }

    export const enum Pricing {
      /**
       * A BackendID cannot be defined without a BackendSystemID and vice versa.
       */
      BackendIdentifiersRequired = 'Pricing:BackendIdentifiersRequired',
      /**
       * PriceList {0:number} has the same BackendID.
       */
      DuplicateBackendID = 'Pricing:DuplicateBackendID',
      /**
       * You do not have access to pricelist {0:number}.
       */
      CannotViewPriceList = 'Pricing:CannotViewPriceList'
    }

    export const enum PriceLists {
      /**
       * Cannot create relation to historical price list
       */
      CannotCreateRelationToHistoricalPriceList = 'PriceLists:CannotCreateRelationToHistoricalPriceList',
      /**
       * The given pricelist has a SpecialPriceListID, which is already attached to the given OU. SpecialPriceList is deprecated and should be remove from the pricelist.
       */
      SpecialPriceListIsAlreadyAttachedToOrganizationUnit = 'PriceLists:SpecialPriceListIsAlreadyAttachedToOrganizationUnit'
    }

    export const enum PaymentTransactionLedgerTypes {
      /**
       * This PaymentTransactionLedgerType already exists
       */
      AlreadyExists = 'PaymentTransactionLedgerTypes:AlreadyExists',
      /**
       * This PaymentTransactionLedgerType is internal and can't be modified
       */
      IsInternal = 'PaymentTransactionLedgerTypes:IsInternal'
    }

    export const enum OrganizationUnitSets {
      /**
       * The OrganizationUnitSetScope is still being used, cannot delete.
       */
      CannotDeleteScopeInUse = 'OrganizationUnitSets:CannotDeleteScopeInUse',
      /**
       * The OrganizationUnitSet is still being used, cannot delete.
       */
      CannotDeleteInUse = 'OrganizationUnitSets:CannotDeleteInUse',
      /**
       * Set {0:string} is a set managed by EVA and cannot be modified.
       */
      CannotModifySystemSet = 'OrganizationUnitSets:CannotModifySystemSet',
      /**
       * It's not possible to use OrganizationUnitSetTypes.System to create new sets.
       */
      CannotCreateSystemSet = 'OrganizationUnitSets:CannotCreateSystemSet',
      /**
       * It's not possible to use an AdHoc set as a subset of another set.
       */
      CannotUseAdHocSetsAsSubset = 'OrganizationUnitSets:CannotUseAdHocSetsAsSubset',
      /**
       * Name is required when creating a non-AdHoc set.
       */
      NameIsRequired = 'OrganizationUnitSets:NameIsRequired'
    }

    export const enum OpeningHoursTypes {
      /**
       * This OpeningHoursType already exists
       */
      AlreadyExists = 'OpeningHoursTypes:AlreadyExists',
      /**
       * The name of an internal OpeningHoursType cannot be modified.
       */
      NameOfInternalOpeningHourTypeCannotBeModified = 'OpeningHoursTypes:NameOfInternalOpeningHourTypeCannotBeModified',
      /**
       * This OpeningHoursType is internal and cannot be deleted
       */
      InternalTypesCannotBeDeleted = 'OpeningHoursTypes:InternalTypesCannotBeDeleted',
      /**
       * This OpeningHoursType has (exception)templates attached and cannot be deleted
       */
      TypeHasTemplatesAndCannotBeDeleted = 'OpeningHoursTypes:TypeHasTemplatesAndCannotBeDeleted'
    }

    export const enum Cultures {
      /**
       * This currency already exists for this OrganizationUnit
       */
      CurrencyAlreadyExists = 'Cultures:CurrencyAlreadyExists',
      /**
       * Additional currency must differ from main currency.
       */
      AdditionalCurrencyMustDifferFromMainCurrency = 'Cultures:AdditionalCurrencyMustDifferFromMainCurrency',
      /**
       * The selected cashhandler is not available for the given currency
       */
      CashHandlerCurrencyMismatch = 'Cultures:CashHandlerCurrencyMismatch',
      /**
       * This language already exists for this organization unit
       */
      LanguageAlreadyExists = 'Cultures:LanguageAlreadyExists',
      /**
       * The organization unit must have at least one (inherited) language. Add a new language before removing this language.
       */
      MustHaveAtLeastOneLanguage = 'Cultures:MustHaveAtLeastOneLanguage'
    }

    export const enum OpeningHours {
      /**
       * There already exists opening hours for organization {organizationUnitName:string} and day {dayOfWeek:EVA.Core.DayOfWeek}
       */
      DuplicateOpeningHoursDayOfWeek = 'OpeningHours:DuplicateOpeningHoursDayOfWeek',
      /**
       * There already exists opening hours for organization {organizationUnitName:string} and date {date:string}
       */
      DuplicateOpeningHoursDate = 'OpeningHours:DuplicateOpeningHoursDate'
    }

    export const enum CreateOrderLedgerType {
      /**
       * Can't create OrderLedgerType because its name already exists
       */
      OrderLedgerTypeAlreadyExists = 'CreateOrderLedgerType:OrderLedgerTypeAlreadyExists'
    }

    export const enum DeleteOrderLedgerType {
      /**
       * Can't delete OrderLedgerType because it's not custom
       */
      OrderLedgerTypeNotCustom = 'DeleteOrderLedgerType:OrderLedgerTypeNotCustom'
    }

    export const enum RefundCorrectionReasons {
      /**
       * RefundCorrectionReason with BackendID '{0:string}' already exists.
       */
      AlreadyExists = 'RefundCorrectionReasons:AlreadyExists'
    }

    export const enum UnitPriceCorrectionReasons {
      /**
       * UnitPriceCorrectionReason with BackendID '{0:string}' already exists.
       */
      AlreadyExists = 'UnitPriceCorrectionReasons:AlreadyExists'
    }

    export const enum UpdateOrderLedgerType {
      /**
       * Can't update OrderLedgerType because it's not custom
       */
      OrderLedgerTypeNotCustom = 'UpdateOrderLedgerType:OrderLedgerTypeNotCustom',
      /**
       * Can't update OrderLedgerType because its name already exists
       */
      OrderLedgerTypeAlreadyExists = 'UpdateOrderLedgerType:OrderLedgerTypeAlreadyExists'
    }

    export const enum ReturnReasons {
      /**
       * This return reason already exists.
       */
      AlreadyExists = 'ReturnReasons:AlreadyExists',
      /**
       * Remark is required for this return reason.
       */
      RemarkIsRequired = 'ReturnReasons:RemarkIsRequired'
    }

    export const enum ClientApplications {
      /**
       * The requested BackendID is already in use
       */
      DuplicateBackendID = 'ClientApplications:DuplicateBackendID'
    }

    export const enum GiftCardConfigurations {
      /**
       * Handler is required
       */
      MissingHandler = 'GiftCardConfigurations:MissingHandler',
      /**
       * The given handler doesn't exist
       */
      UnknownHandler = 'GiftCardConfigurations:UnknownHandler',
      /**
       * The data is not in a valid format for the selected type
       */
      InvalidData = 'GiftCardConfigurations:InvalidData',
      /**
       * Usage type needs at least Sale or Payment, never None
       */
      InvalidUsageType = 'GiftCardConfigurations:InvalidUsageType',
      /**
       * The selected usage type is not supported for the selected handler
       */
      InvalidUsageTypeForHandler = 'GiftCardConfigurations:InvalidUsageTypeForHandler'
    }

    export const enum GiftCards {
      /**
       * This product already has a giftcard product
       */
      ProductAlreadyExists = 'GiftCards:ProductAlreadyExists',
      /**
       * Handler is required
       */
      MissingHandler = 'GiftCards:MissingHandler',
      /**
       * The given type doesn't exist
       */
      UnknownType = 'GiftCards:UnknownType',
      /**
       * The data is not in a valid format for the selected type
       */
      InvalidData = 'GiftCards:InvalidData',
      /**
       * The given product isn't a giftcard
       */
      InvalidProductType = 'GiftCards:InvalidProductType'
    }

    export const enum CashExpenseTypes {
      /**
       * CashExpenseType {0:string} already exists.
       */
      AlreadyExists = 'CashExpenseTypes:AlreadyExists'
    }

    export const enum ExportProductCostPriceLedgerSummary {
      /**
       * You can only export up to 100 products at a time.
       */
      TooManyProductsSelected = 'ExportProductCostPriceLedgerSummary:TooManyProductsSelected'
    }

    export const enum DiscountCouponServices {
      /**
       * UserID is required when logged in user is a Employee or API user.
       */
      UserIDRequired = 'DiscountCouponServices:UserIDRequired'
    }

    export const enum DiscountService {
      /**
       * Discount adheres to campaign start- and end date/time
       */
      DiscountAdheresToCampaignTime = 'DiscountService:DiscountAdheresToCampaignTime',
      /**
       * You don't have permission to set discount budget information.
       */
      NotAllowedToSetDiscountBudgetData = 'DiscountService:NotAllowedToSetDiscountBudgetData'
    }

    export const enum Culture {
      /**
       * Culture for country {language:string} and language {country:string} already exists.
       */
      CultureAlreadyExists = 'Culture:CultureAlreadyExists'
    }

    export const enum SettingsExcelImporter {
      /**
       * OrganizationUnit with ID {0:string} not found on row {1:number}
       */
      OrganizationUnitByIDNotFound = 'SettingsExcelImporter:OrganizationUnitByIDNotFound',
      /**
       * OrganizationUnit with BackendID {0:string} not found on row {1:number}
       */
      OrganizationUnitByBackendIDNotFound = 'SettingsExcelImporter:OrganizationUnitByBackendIDNotFound',
      /**
       * No BackendID or OrganizationUnitID provided for row {0:number}
       */
      NoOrganizationUnitIdentifier = 'SettingsExcelImporter:NoOrganizationUnitIdentifier',
      /**
       * Value on row {0:number} looks like a masked value
       */
      MaskedValueImport = 'SettingsExcelImporter:MaskedValueImport'
    }

    export const enum LoyaltyProgram {
      /**
       * Field '{0:string}' is required for the creation of a new Loyalty Program.
       */
      MissingFieldOnLoyaltyProgramCreation = 'LoyaltyProgram:MissingFieldOnLoyaltyProgramCreation'
    }

  }


  /**
   * List the users bought products.
   */
  export interface ListUserBoughtProducts {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListUserBoughtProductsFilter>;
    PageToken?: string;
  }

  export interface ListUserBoughtProductsResponse {
    Results?: ListUserBoughtProductsResponse.BoughtProduct[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListUserBoughtProductsResponse {
    export interface BoughtProduct {
      /**
       * Entity type: UserBoughtProduct
       */
      ID: number;
      /**
       * Entity type: User
       */
      UserID: number;
      UserFullName: string;
      /**
       * Entity type: Product
       */
      ProductID: number;
      ProductBackendID: string;
      ProductCustomID: string;
      ProductName: string;
      PrimaryImage: EVA.Core.IProductSearchItemPrimaryImage;
      SerialNumber?: string;
      LastPurchaseDate?: string;
      LastPurchasedQuantity?: number;
      TotalPurchasedQuantity?: number;
      IsUnderWarranty: boolean;
      WarrantyExpiryDate?: string;
      ManufacturerWarrantyExpiryDate?: string;
    }

  }

  /**
   * Get the user bought product by ID.
   */
  export interface GetUserBoughtProduct {
    /**
     * Entity type: UserBoughtProduct
     */
    ID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProductProperties?: string[];
  }

  export interface GetUserBoughtProductResponse {
    /**
     * Entity type: UserBoughtProduct
     */
    ID: number;
    /**
     * Entity type: User
     */
    UserID: number;
    UserFullName: string;
    Product: any;
    SerialNumber?: string;
    LastPurchaseDate?: string;
    LastPurchasedQuantity?: number;
    TotalPurchasedQuantity?: number;
    IsUnderWarranty: boolean;
    WarrantyExpiryDate?: string;
    ManufacturerWarrantyExpiryDate?: string;
    AdditionalWarrantyInfo?: string;
    Details: GetUserBoughtProductResponse.Detail[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetUserBoughtProductResponse {
    export interface Detail {
      /**
       * Entity type: UserBoughtProductDetail
       */
      ID?: number;
      FromExternal?: boolean;
      BackendSystemID?: string;
      BackendID?: string;
      /**
       * Entity type: Order
       */
      OrderID?: number;
      OrderDisplayID?: string;
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID?: number;
      PurchaseDate?: string;
      PurchasedQuantity?: number;
    }

  }

  /**
   * Get a user bought product by a product's serial number.
   */
  export interface GetUserBoughtProductBySerialNumber {
    SerialNumber: string;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProductProperties?: string[];
  }

  /**
   * Register user bought product.
   */
  export interface RegisterUserBoughtProduct {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    SerialNumber?: string;
    IsUnderWarranty?: boolean;
    WarrantyExpiryDate?: string;
    ManufacturerWarrantyExpiryDate?: string;
    AdditionalWarrantyInfo?: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Organization unit that the user bought product is registered in. Ignored when an order/line organization unit is present. When omitted, registration is under the current organization unit.
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    PurchaseDate?: string;
    PurchasedQuantity?: number;
  }

  export interface UserBoughtProductResponse {
    /**
     * Entity type: UserBoughtProduct
     */
    UserBoughtProductID: number;
    /**
     * Entity type: UserBoughtProductDetail
     */
    UserBoughtProductDetailID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update user bought product warranty.
   */
  export interface UpdateUserBoughtProductWarranty {
    /**
     * Entity type: UserBoughtProduct
     */
    UserBoughtProductID?: number;
    IsUnderWarranty?: boolean;
    WarrantyExpiryDate?: string;
    ManufacturerWarrantyExpiryDate?: string;
    AdditionalWarrantyInfo?: string;
  }

  /**
   * Register user bought product.
   */
  export interface AddUserBoughtProductDetail {
    /**
     * Entity type: UserBoughtProduct
     */
    UserBoughtProductID: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    PurchaseDate?: string;
    PurchasedQuantity: number;
  }

  /**
   * Register user bought product.
   */
  export interface UpdateUserBoughtProductDetail {
    /**
     * Entity type: UserBoughtProductDetail
     */
    ID: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Organization unit that the user bought product is registered in. Ignored when an order/line organization unit is present. When omitted, registration is under the current organization unit.
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    PurchaseDate?: string;
    PurchasedQuantity: number;
  }

  /**
   * Deletes a user bought product detail.
   */
  export interface DeleteUserBoughtProductDetail {
    /**
     * Entity type: UserBoughtProductDetail
     */
    ID: number;
  }

  /**
   * Archive the user bought product.
   */
  export interface ArchiveUserBoughtProduct {
    /**
     * Entity type: UserBoughtProduct
     */
    ID: number;
  }

  /**
   * Push user bought product.
   */
  export interface PushUserBoughtProduct {
    /**
     * Entity type: User
     */
    UserID: number;
    BoughtProducts?: PushUserBoughtProduct.PushedBoughtProduct[];
  }

  export namespace PushUserBoughtProduct {
    export interface PushedBoughtProduct {
      /**
       * Entity type: Product
       */
      ProductID: number;
      SerialNumber?: string;
      IsUnderWarranty?: boolean;
      WarrantyExpiryDate?: string;
      ManufacturerWarrantyExpiryDate?: string;
      AdditionalWarrantyInfo?: string;
      Archive: boolean;
      Details: PushUserBoughtProduct.PushedBoughtProductDetail[];
    }

    export interface PushedBoughtProductDetail {
      BackendID?: string;
      /**
       * Entity type: Order
       */
      OrderID?: number;
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      /**
       * Organization unit that the user bought product is registered in. Ignored when an order/line organization unit is present. When omitted, registration is under the current organization unit.
       */
      OrganizationUnitID?: string;
      PurchaseDate?: string;
      PurchasedQuantity?: number;
    }

  }

  /**
   * Push bought products for users. Only accepts 10000 users per request
   */
  export interface PushBoughtProductsForUsers {
    BoughtProductsForUsers?: PushBoughtProductsForUsers.PushedBoughtProductForUser[];
  }

  export namespace PushBoughtProductsForUsers {
    export interface PushedBoughtProductForUser {
      /**
       * Entity type: User
       */
      UserID: number;
      BoughtProducts: PushedBoughtProduct[];
    }

  }

  export interface PushedBoughtProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
    SerialNumber?: string;
    IsUnderWarranty?: boolean;
    WarrantyExpiryDate?: string;
    ManufacturerWarrantyExpiryDate?: string;
    AdditionalWarrantyInfo?: string;
    Archive: boolean;
    Details: PushedBoughtProduct.PushedBoughtProductDetail[];
  }

  export namespace PushedBoughtProduct {
    export interface PushedBoughtProductDetail {
      BackendID?: string;
      /**
       * Entity type: Order
       */
      OrderID?: number;
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      /**
       * Organization unit that the user bought product is registered in. Ignored when an order/line organization unit is present. When omitted, registration is under the current organization unit.
       */
      OrganizationUnitID?: string;
      PurchaseDate?: string;
      PurchasedQuantity?: number;
    }

  }

  export interface PushBoughtProductsForUsersResponse {
    FailedBoughtProductsForUsers?: PushBoughtProductsForUsersResponse.FailedUserBoughtProductsForUser[];
    SuccessfulBoughtProductsForUsers?: PushBoughtProductsForUsersResponse.SuccessfulUserBoughtProductsForUser[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace PushBoughtProductsForUsersResponse {
    export interface SuccessfulUserBoughtProductsForUser {
      /**
       * Entity type: User
       */
      UserID: number;
      UserBackendID: string;
      BoughtProducts: PushBoughtProductsForUsersResponse.BoughtProduct[];
    }

    export namespace SuccessfulUserBoughtProductsForUser {
      export interface SuccessfulBoughtProduct {
        /**
         * Entity type: UserBoughtProduct
         */
        UserBoughtProductID: number;
        /**
         * Entity type: Product
         */
        ProductID?: number;
        ProductBackendID?: string;
        SerialNumber?: string;
      }

    }

    export interface FailedUserBoughtProductsForUser {
      /**
       * Entity type: User
       */
      UserID: number;
      UserBackendID: string;
      BoughtProducts: PushBoughtProductsForUsersResponse.BoughtProduct[];
    }

    export interface BoughtProduct {
      /**
       * Entity type: Product
       */
      ProductID?: number;
      ProductBackendID?: string;
      SerialNumber?: string;
    }

  }

  /**
   * Creates a new PIN login for current user.
   * 
   * This PIN will only be valid for a limited amount of time, and only for the provided `OrganizationUnitID` (or your current organization unit if left null).
   */
  export interface CreateIdentificationPinForEmployee {
    Pin: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export interface CreateIdentificationPinForEmployeeResponse {
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GenerateIdentificationPinForEmployee {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export interface GenerateIdentificationPinForEmployeeResponse {
    Pin: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Download an Excel sample which can be filled with employees. The populated excel can be uploaded through the `UploadEmployees` service.
   */
  export interface DownloadEmployeesSample {
  }

  /**
   * Upload the Excel based on the sample from `DownloadEmployeesSample`. The uploaded file will be processed in the background and the results will be mailed to the uploader.
   */
  export interface UploadEmployees {
    Data: string;
    /**
     * Skip the configured UserRequirement for Employees when processing the excelsheet, these requirements however will be enforced when modifying the employee.
     */
    IgnoreUserRequirements?: boolean;
  }

  export interface DownloadInitialInventorySample {
  }

  export interface UploadInitialInventory {
    Data: string;
    IgnoreInTransitStock?: boolean;
  }

  export interface UploadInitialInventoryResponse {
    Messages: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListRestockedProducts {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    From: string;
    To?: string;
    /**
     * Entity type: StockLabel
     */
    StockLabelIDs: number[];
  }

  export interface ListRestockedProductsResponse {
    /**
     * Entity type: StockLabel
     */
    Results: { [key: number]: number[] };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the Stock per product/stocklabel for a subset of OrganizationUnits.
   * 
   * The page size `Limit` has a maximum value of `1.024` for this service (unless `DownloadOverview` is `true`).
   * 
   * If neither `OrganizationUnitIDs` nor `OrganizationUnitSetID` are specified, the service will return an empty result.
   */
  export interface ListStockForOrganizationUnits {
    /**
     * The organization units to list the stock for, will be ignored if `OrganizationUnitSetID` is specified
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * The organization units to list the stock for, when specified, `OrganizationUnitIDs` will be ignored
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Filter on products, is used as input in ElasticSearch
     */
    Query?: string;
    /**
     * View the stock on a certain moment in time
     */
    DateTime?: string;
    /**
     * If specified as true, stock with a quantity of zero is also returned by this service. Defaults to false, meaning that products with a zero stock quantity will not be returned by this service.
     */
    IncludeZeroQuantityStock?: boolean;
    PageConfig?: EVA.Core.PageConfig<ListStockForOrganizationUnitsFilter>;
  }

  export interface ListStockForOrganizationUnitsFilter {
    /**
     * If other `BackendID` and/or `CustomID` are specified as well, only products that match all those filters will be returned
     * Entity type: Product
     */
    ProductIDs?: number[];
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    /**
     * If other filters are specified as well, only products matching all the filters will be returned
     */
    SerialNumber?: string;
  }

  export interface ListStockForOrganizationUnitsResponse {
    /**
     * Entity type: Product
     */
    Products: { [key: number]: ListStockForOrganizationUnitsResponse.ProductDto };
    Url: string;
    Result?: EVA.Core.PagedResult<ListStockForOrganizationUnitsResponse.StockDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListStockForOrganizationUnitsResponse {
    export interface StockDto {
      /**
       * Entity type: Product
       */
      ProductID: number;
      /**
       * Entity type: StockLabel
       */
      StockLabel: number;
      StockLabelName: string;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID?: number;
      OrganizationUnitName: string;
      OrganizationUnitCurrencyID: string;
      StockProducts: ListStockForOrganizationUnitsResponse.StockDto[];
      QuantityOnHand: number;
      QuantityCommitted: number;
      QuantityAvailable: number;
      /**
       * `UnitPriceInTax` times the `QuantityOnHand`. Rounded to the currency's precision
       */
      TotalAmountInTax: number;
      TaxRate: number;
      /**
       * Entity type: TaxCode
       */
      TaxCodeID: number;
      UnitCost: number;
      UnitPrice: number;
      UnitPriceInTax: number;
      /**
       * `UnitCost` times the `QuantityOnHand`. Rounded to the currency's precision
       */
      TotalUnitCost: number;
    }

    export interface ProductDto {
      Product: any;
      SerialNumberRequirementID?: number;
      IsElevatedProduct: boolean;
    }

  }

  export interface ExportUnshippedPurchaseOrdersToExcel {
    /**
     * Entity type: OrganizationUnit
     */
    ShipFromOrganizationUnitID: number;
  }

  export interface ExportUnshippedPurchaseOrdersToExcelResponse {
    DownloadUrl: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ProcessUnshippedPurchaseOrdersFromExcel {
    Data: string;
  }

  export interface GeneratePurchaseOrderExcelSample {
  }

  export interface UploadPurchaseOrderExcel {
    Data: string;
  }

  /**
   * Generates a sample file for `UploadSalesOrderExcel` service
   */
  export interface GenerateSalesOrderExcelSample {
  }

  /**
   * Uploads a new sales order, attached to specified customer (but not paid, placed, or anything!)
   */
  export interface UploadSalesOrderExcel {
    Data: string;
    EmailAddress?: string;
  }

  export interface GetFraudItem {
    /**
     * Entity type: FraudItem
     */
    ID: number;
  }

  export interface GetFraudItemResponse {
    /**
     * Entity type: FraudItem
     */
    ID: number;
    TypeID: number;
    Type: EVA.Core.FraudDataType;
    Data: string;
    Object: any;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListFraudItems {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListFraudItemsFilter>;
  }

  export interface ListFraudItemsResponse {
    Result?: EVA.Core.PagedResult<ListFraudItemsResponse.Item>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListFraudItemsResponse {
    export interface Item {
      /**
       * Entity type: FraudItem
       */
      ID: number;
      TypeID: number;
      Type: EVA.Core.FraudDataType;
      Data: string;
      Object: any;
    }

  }

  export interface UpdateFraudItem {
    /**
     * Entity type: FraudItem
     */
    ID: number;
    Data?: string;
    Object?: any;
  }

  export interface DeleteFraudItem {
    /**
     * Entity type: FraudItem
     */
    ID: number;
  }

  export interface CreateFraudItem {
    Type: EVA.Core.FraudDataType;
    Data?: string;
    Object?: any;
  }

  export interface CreateFraudItemResponse {
    /**
     * Entity type: FraudItem
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface DownloadFraudItems {
  }

  export interface UploadFraudItems {
    Data: string;
  }

  export interface ExportGeneralLedgerSummaryToExcel {
    Filter?: EVA.Core.ListGeneralLedgersFilter;
  }

  /**
   * Create a new assortment.
   * You can provide either OrganizationUnitIDs or and OrganizationUnitSetID (which will translate to OrganizationUnitIDs) to be attached to the assortment that is being created.
   * OrganizationUnitIDs will take precedence over OrganizationUnitSetID.
   */
  export interface CreateAssortment {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Name: string;
    Code?: string;
    /**
     * Products to add to the assortment.
     */
    Products?: CreateAssortment.AssortmentProduct[];
  }

  export namespace CreateAssortment {
    export interface AssortmentProduct {
      /**
       * Entity type: Product
       */
      ProductID: number;
      ProductStatus: EVA.Core.ProductStatus;
      AnnouncementDate?: string;
      PreSaleDate?: string;
      ShipmentDate?: string;
      StartDate?: string;
      EndDate?: string;
    }

  }

  export interface CreateAssortmentResponse {
    /**
     * Entity type: Assortment
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing assortment
   */
  export interface UpdateAssortment {
    /**
     * Entity type: Assortment
     */
    ID: number;
    Name?: string;
    Code?: string;
  }

  /**
   * Delete an existing assortment
   */
  export interface DeleteAssortment {
    /**
     * Entity type: Assortment
     */
    ID: number;
  }

  /**
   * List existing assortments
   */
  export interface ListAssortments {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListAssortmentsFilter>;
  }

  export interface ListAssortmentsResponse {
    Result?: EVA.Core.PagedResult<ListAssortmentsResponse.AssortmentDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListAssortmentsResponse {
    export interface AssortmentDto {
      /**
       * Entity type: Assortment
       */
      ID: number;
      Name: string;
      IsDefault: boolean;
      Code: string;
    }

  }

  /**
   * Get an existing Assortment by ID
   */
  export interface GetAssortmentByID {
    /**
     * Entity type: Assortment
     */
    ID: number;
  }

  export interface GetAssortmentByIDResponse {
    /**
     * Entity type: Assortment
     */
    ID: number;
    Name: string;
    IsDefault: boolean;
    Code: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get all OrganizationUnits that are connected to the Assortment
   */
  export interface GetAssortmentOrganizationUnits {
    /**
     * Entity type: Assortment
     */
    ID: number;
  }

  export interface GetAssortmentOrganizationUnitsResponse {
    OrganizationUnits: GetAssortmentOrganizationUnitsResponse.OrganizationUnitDTO[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAssortmentOrganizationUnitsResponse {
    export interface OrganizationUnitDTO {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Attach an assortment to specified organization units or -set
   */
  export interface AttachAssortmentToOrganizationUnit {
    /**
     * Entity type: Assortment
     */
    ID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
  }

  /**
   * Adds or updates the given products to the assortment.
   * 
   * When the given products are all root products, the request will automaticly update all childeren.
   * But if the list is a mixed product list, all updates will be applied according to the given information.
   */
  export interface AddProductsToAssortment {
    /**
     * Entity type: Assortment
     */
    AssortmentID: number;
    /**
     * Specific product IDs that will be added to the assortment.
     */
    Products?: AddProductsToAssortment.AssortmentProduct[];
    /**
     * Only update products that are already part of the assortment
     */
    UpdateOnly?: boolean;
  }

  export namespace AddProductsToAssortment {
    export interface AssortmentProduct {
      /**
       * Entity type: Product
       */
      ProductID: number;
      ProductStatus: EVA.Core.ProductStatus;
      StartDate?: string;
      EndDate?: string;
      AnnouncementDate?: string;
      PreSaleDate?: string;
      ShipmentDate?: string;
      ProductStatusesToIgnoreToChildProducts?: EVA.Core.ProductStatus;
      IgnoreStartDateToChildProducts?: boolean;
      IgnoreEndDateToChildProducts?: boolean;
      IgnoreAnnouncementDateToChildProducts?: boolean;
      IgnorePreSaleDateToChildProducts?: boolean;
      IgnoreShipmentDateToChildProducts?: boolean;
    }

  }

  /**
   * Removes products from an assortment. When the product is not part of the assortment an error is returned.
   */
  export interface RemoveProductsFromAssortment {
    /**
     * Entity type: Assortment
     */
    AssortmentID: number;
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
  }

  /**
   * Returns a paged result of all products in all assortments, unless a filter is provided on AssortmentID or ProductID.
   * In this manner, you can either get all products for an assortment (by filtering on AssortmentID), all assortments for a product (by filtering on ProductID)
   * or to get a specific product in an assortment by filtering on both.
   */
  export interface ListAssortmentProducts {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListAssortmentProductsFilter>;
  }

  export interface ListAssortmentProductsResponse {
    Result?: EVA.Core.PagedResult<ListAssortmentProductsResponse.AssortmentProduct>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListAssortmentProductsResponse {
    export interface AssortmentProduct {
      /**
       * Entity type: Product
       */
      ProductID: number;
      ProductCustomID: string;
      ProductBackendID: string;
      ProductType: EVA.Core.ProductTypes;
      /**
       * Entity type: Assortment
       */
      AssortmentID: number;
      AssortmentName: string;
      AssortmentCode: string;
      ProductStatus: EVA.Core.ProductStatus;
      StartDate?: string;
      EndDate?: string;
      AnnouncementDate?: string;
      PreSaleDate?: string;
      ShipmentDate?: string;
    }

  }

  /**
   * Returns a paged result of root products in an assortment.
   */
  export interface GetAssortmentRootProducts {
    /**
     * Entity type: Assortment
     */
    AssortmentID: number;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface GetAssortmentRootProductsResponse {
    Result?: EVA.Core.PagedResult<GetAssortmentRootProductsResponse.AssortmentProduct>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAssortmentRootProductsResponse {
    export interface AssortmentProduct {
      /**
       * Entity type: Product
       */
      ProductID: number;
      ProductBackendID: string;
      ProductType: EVA.Core.ProductTypes;
      ProductDetails: any;
      ProductStatus: EVA.Core.ProductStatus;
      MixedProductStatuses: EVA.Core.ProductStatus;
      StartDate?: string;
      EndDate?: string;
      AnnouncementDate?: string;
      PreSaleDate?: string;
      ShipmentDate?: string;
      HasChildren: boolean;
      IsPartiallyIncludedInAssortment: boolean;
    }

  }

  /**
   * Returns a paged result of root products in an assortment.
   */
  export interface GetAssortmentProductTree {
    /**
     * Entity type: Assortment
     */
    AssortmentID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface GetAssortmentProductTreeResponse {
    Parent: GetAssortmentProductTreeResponse.GetAssortmentProductTreeProduct;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAssortmentProductTreeResponse {
    export interface GetAssortmentProductTreeProduct {
      IsRequestedProduct: boolean;
      IsIncludedInAssortment: boolean;
      /**
       * Entity type: Product
       */
      ProductID: number;
      ProductBackendID: string;
      ProductType: EVA.Core.ProductTypes;
      ProductDetails: any;
      ProductStatus: EVA.Core.ProductStatus;
      MixedProductStatuses: EVA.Core.ProductStatus;
      StartDate?: string;
      EndDate?: string;
      AnnouncementDate?: string;
      PreSaleDate?: string;
      ShipmentDate?: string;
      Children: GetAssortmentProductTreeResponse.GetAssortmentProductTreeProduct[];
    }

  }

  /**
   * Returns an Excel file that contains all products in an assortment, which can then be updated and reuploaded using UploadAssortmentProducts.
   */
  export interface DownloadAssortmentProducts {
    /**
     * Entity type: Assortment
     */
    AssortmentID: number;
  }

  /**
   * Performs a bulk update of an assortment's products.
   * The data for this service can be gotten by first calling DownloadAssortmentProducts, then make your changes and reupload it using this service.
   */
  export interface UploadAssortmentProducts {
    /**
     * Entity type: Assortment
     */
    AssortmentID: number;
    Data: string;
    /**
     * When a product is currently part of the assortment but is not present in the Excel that is uploaded, it's removed from the assortment.
     */
    DeleteMissing?: boolean;
  }

  export interface UploadAssortmentProductsResponse {
    Messages: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Gets an VisibilityGroup by its ID and returns the basic information.
   */
  export interface GetVisibilityGroupByID {
    /**
     * Entity type: VisibilityGroup
     */
    ID: number;
  }

  export interface GetVisibilityGroupByIDResponse {
    /**
     * Entity type: VisibilityGroup
     */
    ID: number;
    Name: string;
    Description?: string;
    AllowCustomerStandardAccounts: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new VisibilityGroup.
   */
  export interface CreateVisibilityGroup {
    Name: string;
    Description?: string;
    AllowCustomerStandardAccounts: boolean;
  }

  export interface CreateVisibilityGroupResponse {
    /**
     * Entity type: VisibilityGroup
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing VisibilityGroup.
   */
  export interface UpdateVisibilityGroup {
    /**
     * Entity type: VisibilityGroup
     */
    ID: number;
    Name?: string;
    Description?: string;
    AllowCustomerStandardAccounts?: boolean;
  }

  /**
   * Delete a VisibilityGroup
   */
  export interface DeleteVisibilityGroup {
    /**
     * Entity type: VisibilityGroup
     */
    ID: number;
  }

  /**
   * List VisibilityGroups. Returns a paged response.
   */
  export interface ListVisibilityGroups {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListVisibilityGroupsFilter>;
  }

  export interface ListVisibilityGroupsResponse {
    Result?: EVA.Core.PagedResult<ListVisibilityGroupsResponse.VisibilityGroupDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListVisibilityGroupsResponse {
    export interface VisibilityGroupDto {
      /**
       * Entity type: VisibilityGroup
       */
      ID: number;
      Name: string;
      Description?: string;
      AllowCustomerStandardAccounts: boolean;
    }

  }

  /**
   * Gets an VisibilityGroup to VisibilityGroup configuration by its unique identifiers and returns the basic information.
   */
  export interface GetVisibilityGroupConfiguration {
    /**
     * Entity type: VisibilityGroup
     */
    FromID: number;
    /**
     * Entity type: VisibilityGroup
     */
    ToID: number;
  }

  export interface GetVisibilityGroupConfigurationResponse {
    From: GetVisibilityGroupConfigurationResponse.VisibilityGroupDto;
    To: GetVisibilityGroupConfigurationResponse.VisibilityGroupDto;
    Users: boolean;
    Orders: boolean;
    OrganizationUnits: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetVisibilityGroupConfigurationResponse {
    export interface VisibilityGroupDto {
      /**
       * Entity type: VisibilityGroup
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Create or update a VisibilityGroup to VisibilityGroup configuration.
   */
  export interface CreateOrUpdateVisibilityGroupConfiguration {
    /**
     * Entity type: VisibilityGroup
     */
    FromID: number;
    /**
     * Entity type: VisibilityGroup
     */
    ToID: number;
    Users?: boolean;
    Orders?: boolean;
    OrganizationUnits?: boolean;
  }

  /**
   * Delete a VisibilityGroup to VisibilityGroup configuration
   */
  export interface DeleteVisibilityGroupConfiguration {
    /**
     * Entity type: VisibilityGroup
     */
    FromID: number;
    /**
     * Entity type: VisibilityGroup
     */
    ToID: number;
  }

  /**
   * List VisibilityGroupVisibilityGroups. Returns a paged response.
   */
  export interface ListVisibilityGroupConfigurations {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListVisibilityGroupConfigurationsFilter>;
  }

  export interface ListVisibilityGroupConfigurationsResponse {
    Result?: EVA.Core.PagedResult<ListVisibilityGroupConfigurationsResponse.VisibilityGroupVisibilityGroupDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListVisibilityGroupConfigurationsResponse {
    export interface VisibilityGroupVisibilityGroupDto {
      From: ListVisibilityGroupConfigurationsResponse.VisibilityGroupDto;
      To: ListVisibilityGroupConfigurationsResponse.VisibilityGroupDto;
      Users: boolean;
      Orders: boolean;
      OrganizationUnits: boolean;
    }

    export interface VisibilityGroupDto {
      /**
       * Entity type: VisibilityGroup
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Export all UserSubscriptions in an excel file
   */
  export interface ExportUserSubscriptions {
  }

  /**
   * Get the available UserProperties on which requirements can be set.
   */
  export interface GetAvailableUserRequirementsProperties {
  }

  export interface GetAvailableUserRequirementsPropertiesResponse {
    Properties?: string[];
    Result: { [key: string]: EVA.Core.UserRequirementProperties };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get the configured UserRequirements for the current, or given, `OrganizationUnit`.
   */
  export interface GetUserRequirements {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Subscription
     */
    SubscriptionID?: number;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    UserType?: EVA.Core.UserTypes;
  }

  export interface GetUserRequirementsResponse {
    Requirements: { [key: string]: EVA.Core.UserRequirementResponse };
    PropertyRequirements: { [key: string]: EVA.Core.UserRequirementResponse[] };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get the configured UserRequirements for the given Subscriptions.
   */
  export interface GetUserRequirementsForSubscriptions {
    /**
     * Entity type: Subscription
     */
    SubscriptionIDs: number[];
  }

  export interface GetUserRequirementsForSubscriptionsResponse {
    Requirements: { [key: number]: EVA.Core.UserRequirementForSubscriptionResponse[] };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * The service enables endpoints to push user subscriptions based on the user backend id and subscription backend id.
   * Multiple subscriptions can be pushed at once.
   * 
   * Additionally, a SubscriptionID and Balance can be provided
   * NOTE THAT Only subscriptions that allow for local storage can be pushed. Subscriptions fully depending on external services cannot be pushed.
   * NOTE THAT Balance can only be provided for loyalty subscriptions that have a EVA loyalty handler.
   */
  export interface PushUserSubscription {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Subscription
     */
    SubscriptionID?: number;
    UserSubscriptionIdentifier?: string;
    UserSubscriptionSourceIdentifier?: string;
    UserUnsubscribeReason?: string;
    IsSubscribed?: boolean;
    Balance?: number;
    SubscribedOn?: string;
  }

  /**
   * List the subscription organization unit sets.
   */
  export interface ListSubscriptionOrganizationUnitSets {
    /**
     * Entity type: Subscription
     */
    SubscriptionID: number;
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListSubscriptionOrganizationUnitSetsFilter>;
    PageToken?: string;
  }

  export interface ListSubscriptionOrganizationUnitSetsResponse {
    Results?: ListSubscriptionOrganizationUnitSetsResponse.SubscriptionOrganizationUnitSetDto[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListSubscriptionOrganizationUnitSetsResponse {
    export interface SubscriptionOrganizationUnitSetDto {
      /**
       * Entity type: SubscriptionOrganizationUnitSet
       */
      ID: number;
      Enabled: boolean;
      Default: boolean;
      SubscriptionConfirmation: EVA.Core.SubscriptionConfirmation;
      Hidden: boolean;
      Preferred: boolean;
      Priority: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID?: number;
      Subscription: ListSubscriptionOrganizationUnitSetsResponse.SubscriptionDto;
      OrganizationUnitSet: ListSubscriptionOrganizationUnitSetsResponse.OrganizationUnitSetDto;
    }

    export interface SubscriptionDto {
      /**
       * Entity type: Subscription
       */
      ID?: number;
      Name?: string;
    }

    export interface OrganizationUnitSetDto {
      /**
       * Entity type: OrganizationUnitSet
       */
      ID?: number;
      Name?: string;
      Description?: string;
      Type?: EVA.Core.OrganizationUnitSetTypes;
    }

  }

  /**
   * @deprecated Use ListSubscriptionOrganizationUnitSets instead.
   * Gets all the SubscriptionOrganizationUnitSets and returns a paged response.
   */
  export interface GetSubscriptionOrganizationUnitSets {
  }

  export interface GetSubscriptionOrganizationUnitSetsResponse {
    SubscriptionOrganizationUnitSets: GetSubscriptionOrganizationUnitSetsResponse.SubscriptionOrganizationUnitSetDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetSubscriptionOrganizationUnitSetsResponse {
    export interface SubscriptionOrganizationUnitSetDto {
      /**
       * Entity type: SubscriptionOrganizationUnitSet
       */
      ID: number;
      /**
       * Entity type: Subscription
       */
      SubscriptionID: number;
      SubscriptionName: string;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID?: number;
      /**
       * Entity type: OrganizationUnitSet
       */
      OrganizationUnitSetID: number;
      OrganizationUnitSetName: string;
      OrganizationUnitSetDescription: string;
      OrganizationUnitSetType?: EVA.Core.OrganizationUnitSetTypes;
      Enabled: boolean;
      Default: boolean;
      SubscriptionConfirmation: EVA.Core.SubscriptionConfirmation;
      Hidden: boolean;
      Preferred: boolean;
      Priority: number;
    }

  }

  /**
   * Creates a new SubscriptionOrganizationUnitSet and returns the ID of the new record.
   */
  export interface CreateSubscriptionOrganizationUnitSet {
    /**
     * Entity type: Subscription
     */
    SubscriptionID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    Enabled: boolean;
    Default: boolean;
    SubscriptionConfirmation: EVA.Core.SubscriptionConfirmation;
    Hidden?: boolean;
    Preferred?: boolean;
    Priority?: number;
  }

  export interface CreateSubscriptionOrganizationUnitSetResponse {
    /**
     * Entity type: SubscriptionOrganizationUnitSet
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Updates an existing SubscriptionOrganizationUnitSet.
   */
  export interface UpdateSubscriptionOrganizationUnitSet {
    /**
     * Entity type: SubscriptionOrganizationUnitSet
     */
    ID: number;
    Enabled: boolean;
    Default: boolean;
    SubscriptionConfirmation?: EVA.Core.SubscriptionConfirmation;
    Hidden?: boolean;
    Preferred?: boolean;
    Priority?: number;
  }

  /**
   * Deletes a SubscriptionOrganizationUnitSet by its ID.
   */
  export interface DeleteSubscriptionOrganizationUnitSet {
    /**
     * Entity type: SubscriptionOrganizationUnitSet
     */
    ID: number;
  }

  /**
   * List the Subscriptions
   */
  export interface ListSubscriptions {
  }

  export interface ListSubscriptionsResponse {
    Subscriptions: ListSubscriptionsResponse.SubscriptionDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListSubscriptionsResponse {
    export interface SubscriptionDto {
      /**
       * Entity type: Subscription
       */
      ID?: number;
      Name?: string;
      Description?: string;
      BackendID?: string;
      /**
       * @deprecated No longer supported in this service
       */
      Type?: EVA.Core.SubscriptionType;
      /**
       * @deprecated No longer supported in this service
       */
      Handler?: string;
      /**
       * Entity type: LoyaltyProgram
       * @deprecated No longer supported in this service
       */
      LoyaltyProgramID?: number;
      /**
       * @deprecated No longer supported in this service
       */
      LoyaltyProgramName?: string;
      /**
       * Entity type: CustomField
       * @deprecated No longer supported in this service
       */
      IdentifierCustomFieldID?: number;
      /**
       * @deprecated No longer supported in this service
       */
      IdentifierCustomFieldName?: string;
      /**
       * @deprecated No longer supported in this service
       */
      ManualUserIdentifiers?: boolean;
      /**
       * @deprecated No longer supported in this service
       */
      InquiryID?: number;
      /**
       * @deprecated No longer supported in this service
       */
      InquiryName?: string;
      /**
       * @deprecated No longer supported in this service
       */
      IsExternal?: boolean;
      /**
       * @deprecated No longer supported in this service
       */
      UserIdentifierPrefix?: string;
      /**
       * @deprecated No longer supported in this service
       */
      UserIdentifierStartNumber?: number;
      /**
       * @deprecated No longer supported in this service
       */
      UserIdentifierCurrentNumber?: number;
      /**
       * @deprecated No longer supported in this service
       */
      UserIdentifierSuffix?: string;
      /**
       * @deprecated No longer supported in this service
       */
      ResubscribeHandling?: EVA.Core.ResubscribeHandlingType;
      /**
       * @deprecated No longer supported in this service
       */
      AllowUnsubscribeBy?: EVA.Core.AllowUnsubscribeByType;
    }

  }

  /**
   * Get the subscription details
   */
  export interface GetSubscriptionByID {
    /**
     * Entity type: Subscription
     */
    ID: number;
  }

  export interface GetSubscriptionByIDResponse {
    /**
     * Entity type: Subscription
     */
    ID?: number;
    BackendID?: string;
    Name?: string;
    Description?: string;
    AllowUnsubscribeBy?: EVA.Core.AllowUnsubscribeByType;
    ResubscribeHandling?: EVA.Core.ResubscribeHandlingType;
    Type?: EVA.Core.SubscriptionType;
    Handler?: string;
    IsExternal?: boolean;
    ManualUserIdentifiers?: boolean;
    UserIdentifierPrefix?: string;
    UserIdentifierStartNumber?: number;
    UserIdentifierCurrentNumber?: number;
    UserIdentifierSuffix?: string;
    IdentifierCustomField?: GetSubscriptionByIDResponse.CustomFieldDto;
    Inquiry?: GetSubscriptionByIDResponse.InquiryDto;
    LoyaltyProgram?: GetSubscriptionByIDResponse.LoyaltyProgramDto;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetSubscriptionByIDResponse {
    export interface CustomFieldDto {
      /**
       * Entity type: CustomField
       */
      ID: number;
      Name: string;
    }

    export interface InquiryDto {
      /**
       * Entity type: Inquiry
       */
      ID: number;
      Name: string;
    }

    export interface LoyaltyProgramDto {
      /**
       * Entity type: LoyaltyProgram
       */
      ID: number;
      Name: string;
      Options?: EVA.Core.LoyaltyProgramOptions;
      PointUsageOptions?: EVA.Core.LoyaltyPointUsageOptions;
      Company: GetSubscriptionByIDResponse.CompanyDto;
    }

    export interface CompanyDto {
      /**
       * Entity type: Company
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Create a new Subscription
   */
  export interface CreateSubscription {
    /**
     * The name of the subscription
     */
    Name?: string;
    Description?: string;
    /**
     * The (optional) BackendID of the subscription
     */
    BackendID?: string;
    /**
     * The handler for the actions on this subscription. Available handlers can be listed with the `GetSubscriptionHandlers` service.
     */
    Handler?: string;
    /**
     * The LoyaltyProgram the subscription is bound to.
     * Entity type: LoyaltyProgram
     * @deprecated Loyalty programs can now be created with the subscription info.
     */
    LoyaltyProgramID?: number;
    /**
     * The (optional) custom field the UserIdentifier of the subscription is written back to. Values from in the custom field are informational only.
     * Entity type: CustomField
     */
    IdentifierCustomFieldID?: number;
    /**
     * When set to true, subscribing the user will require a UserIdentifier to be given.
     */
    ManualUserIdentifiers?: boolean;
    UserIdentifierPrefix?: string;
    /**
     * Min: 0
     */
    UserIdentifierStartNumber?: number;
    UserIdentifierSuffix?: string;
    /**
     * Entity type: Inquiry
     */
    InquiryID?: number;
    /**
     * Handling when a user is unsubscribed and re-subscribes.
     */
    ResubscribeHandling?: EVA.Core.ResubscribeHandlingType;
    /**
     * Indicates if the subscription can be unsubscribed and if so, who can do the unsubscribe.
     */
    AllowUnsubscribeBy?: EVA.Core.AllowUnsubscribeByType;
  }

  export interface CreateSubscriptionResponse {
    /**
     * Entity type: Subscription
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing Subscription
   */
  export interface UpdateSubscription {
    /**
     * Entity type: Subscription
     */
    ID: number;
    /**
     * The name of the subscription
     */
    Name?: string;
    Description?: string;
    /**
     * The (optional) BackendID of the subscription
     */
    BackendID?: string;
    /**
     * Entity type: Inquiry
     */
    InquiryID?: number;
    /**
     * Handling when a user is unsubscribed and re-subscribes.
     */
    ResubscribeHandling?: EVA.Core.ResubscribeHandlingType;
    /**
     * Indicates if the subscription can be unsubscribed and if so, who can do the unsubscribe.
     */
    AllowUnsubscribeBy?: EVA.Core.AllowUnsubscribeByType;
  }

  /**
   * Delete a Subscription.
   */
  export interface DeleteSubscription {
    /**
     * Entity type: Subscription
     */
    ID: number;
    /**
     * You can provide the property `Force` to force remaining subscribed users to be unsubscribed. Doing so requires ForceDeleteSubscription functionality.
     */
    Force?: boolean;
  }

  /**
   * Get the available subscription handlers
   */
  export interface GetSubscriptionHandlers {
  }

  export interface GetSubscriptionHandlersResponse {
    HandlersDetails: GetSubscriptionHandlersResponse.Handler[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetSubscriptionHandlersResponse {
    export interface Handler {
      Name: string;
      AllowRequestConfirmation: boolean;
    }

  }

  /**
   * Block a users subscription without unsubscribing.
   */
  export interface BlockUserSubscription {
    /**
     * Entity type: Subscription
     */
    SubscriptionID: number;
    /**
     * Entity type: User
     */
    UserID: number;
  }

  /**
   * Unblock a users subscription.
   */
  export interface UnblockUserSubscription {
    /**
     * Entity type: Subscription
     */
    SubscriptionID: number;
    /**
     * Entity type: User
     */
    UserID: number;
  }

  /**
   * Generate a user subscription identifier barcode for the given user and subscription
   */
  export interface GetUserSubscriptionBarcode {
    /**
     * Entity type: User
     */
    UserID: number;
    /**
     * Entity type: Subscription
     */
    SubscriptionID: number;
  }

  export interface GetUserSubscriptionBarcodeResponse {
    Barcode: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * @deprecated Users can now be searched by SubscriptionID via the SearchUsers. Service will be removed.
   * List all users attached to a subscription. Requires View rights on Subscriptions and Customers functionalities.
   */
  export interface ListSubscriptionUsers {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListSubscriptionUsersFilter>;
    PageToken?: string;
  }

  export interface ListSubscriptionUsersResponse {
    Results?: ListSubscriptionUsersResponse.SubscriptionUser[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListSubscriptionUsersResponse {
    export interface SubscriptionUser {
      /**
       * Entity type: Subscription
       */
      SubscriptionID: number;
      Status: EVA.Core.SubscriptionStatus;
      IsBlocked: boolean;
      UserIdentifier?: string;
      /**
       * Entity type: OrganizationUnit
       */
      OriginatingOrganizationUnitID?: number;
      /**
       * Entity type: User
       */
      UserID: number;
      User: ListSubscriptionUsersResponse.UserInfo;
    }

    export interface UserInfo {
      FirstName: string;
      LastName: string;
      FullName: string;
      EmailAddress: string;
    }

  }

  /**
   * Update all UserRequirements on a Subscription.
   * 
   * Updates the given requirements and removes all other requirements from the Subscription
   */
  export interface UpdateSubscriptionUserRequirements {
    /**
     * Entity type: Subscription
     */
    ID: number;
    Requirements: UpdateSubscriptionUserRequirements.UserRequirementDto[];
  }

  export namespace UpdateSubscriptionUserRequirements {
    export interface UserRequirementDto {
      /**
       * Entity type: UserRequirement
       */
      ID?: number;
      Property?: string;
      UserType?: EVA.Core.UserTypes;
      AccountType?: EVA.Core.UserAccountType;
      RequiredFor?: EVA.Core.UserRequirementFor;
      Preferred?: boolean;
      Display?: boolean;
      CustomValidators?: { [key: string]: any };
    }

  }

  /**
   * List the UserOrigins
   */
  export interface GetUserOrigins {
  }

  export interface GetUserOriginsResponse {
    UserOrigins: GetUserOriginsResponse.UserOriginDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetUserOriginsResponse {
    export interface UserOriginDto {
      BackendID: string;
      /**
       * Entity type: Enum
       */
      ID: number;
      /**
       * Usually an internal & unchangable code - for display, use `Description`
       */
      Name: string;
      Description: string;
    }

  }

  /**
   * Create a new UserOrigin
   */
  export interface CreateUserOrigin {
    Name: string;
    Description?: string;
    BackendID?: string;
  }

  export interface CreateUserOriginResponse {
    /**
     * Entity type: UserOrigin
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing UserOrigin
   */
  export interface UpdateUserOrigin {
    /**
     * Entity type: UserOrigin
     */
    ID: number;
    Name: string;
    Description?: string;
    BackendID?: string;
  }

  /**
   * Delete a UserOrigin
   */
  export interface DeleteUserOrigin {
    /**
     * Entity type: UserOrigin
     */
    ID: number;
  }

  /**
   * Get all personalized promotions for the logged in user or the given user.
   */
  export interface ListUserPersonalizedPromotions {
    /**
     * Entity type: User
     */
    UserID?: number;
  }

  export interface ListUserPersonalizedPromotionsResponse {
    PersonalizedPromotions: ListUserPersonalizedPromotionsResponse.PersonalizedPromotion[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListUserPersonalizedPromotionsResponse {
    export interface PersonalizedPromotion {
      /**
       * Entity type: PersonalizedPromotion
       */
      ID: number;
      BackendID: string;
      Name: string;
      Description: string;
      MaximumDistinctProducts?: number;
      LockAfterFirstApply: boolean;
      IsLocked: boolean;
    }

  }

  /**
   * Get all products for a personalized promotion for the logged in user or the given user.
   */
  export interface GetUserPersonalizedPromotionProducts {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: PersonalizedPromotion
     */
    PersonalizedPromotionID: number;
  }

  export interface GetUserPersonalizedPromotionProductsResponse {
    /**
     * Entity type: PersonalizedPromotion
     */
    PersonalizedPromotionID: number;
    PersonalizedPromotionBackendID: string;
    Name: string;
    Description: string;
    ApplicableProducts: any[];
    SelectedProducts: any[];
    MaximumDistinctProducts?: number;
    IsLocked: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Set selected products for personalized promotion for the logged in user or the given user. Overwrites existing selection.
   */
  export interface SelectUserPersonalizedPromotionProducts {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: PersonalizedPromotion
     */
    PersonalizedPromotionID?: number;
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
  }

  /**
   * List the UserRequirements.
   */
  export interface ListUserRequirements {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListUserRequirementsFilter>;
  }

  export interface ListUserRequirementsResponse {
    Result?: EVA.Core.PagedResult<ListUserRequirementsResponse.UserRequirementDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListUserRequirementsResponse {
    export interface UserRequirementDto {
      /**
       * Entity type: UserRequirement
       */
      ID: number;
      Property: string;
      UserType?: EVA.Core.UserTypes;
      AccountType?: EVA.Core.UserAccountType;
      RequiredFor: EVA.Core.UserRequirementFor;
      Preferred: boolean;
      Display: boolean;
      CustomValidators?: { [key: string]: any };
    }

  }

  /**
   * Creates a new UserRequirement and returns the ID of the new record.
   */
  export interface CreateUserRequirement {
    /**
     * Entity type: UserRequirementSet
     */
    UserRequirementSetID?: number;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    Property: string;
    /**
     * Entity type: Subscription
     */
    SubscriptionID?: number;
    UserType: EVA.Core.UserTypes;
    AccountType?: EVA.Core.UserAccountType;
    RequiredFor: EVA.Core.UserRequirementFor;
    Preferred?: boolean;
    Display?: boolean;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    CustomValidators?: { [key: string]: any };
  }

  export interface CreateUserRequirementResponse {
    /**
     * Entity type: UserRequirement
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Updates an existing UserRequirement.
   */
  export interface UpdateUserRequirement {
    /**
     * Entity type: UserRequirement
     */
    ID: number;
    Property?: string;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    UserType?: EVA.Core.UserTypes;
    AccountType?: EVA.Core.UserAccountType;
    RequiredFor?: EVA.Core.UserRequirementFor;
    Preferred?: boolean;
    Display?: boolean;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    CustomValidators?: { [key: string]: any };
  }

  /**
   * Deletes a UserRequirement by its ID.
   */
  export interface DeleteUserRequirement {
    /**
     * Entity type: UserRequirement
     */
    ID: number;
  }

  /**
   * Gets UserRequirement by its ID.
   */
  export interface GetUserRequirement {
    /**
     * Entity type: UserRequirement
     */
    ID: number;
  }

  export interface GetUserRequirementResponse {
    /**
     * Entity type: UserRequirement
     */
    ID: number;
    /**
     * Entity type: UserRequirementSet
     */
    UserRequirementSetID?: number;
    UserRequirementSetName?: string;
    Property: string;
    UserType?: EVA.Core.UserTypes;
    AccountType?: EVA.Core.UserAccountType;
    RequiredFor: EVA.Core.UserRequirementFor;
    Preferred: boolean;
    Display: boolean;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    CustomValidators?: { [key: string]: any };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the UserRequirementSets.
   */
  export interface ListUserRequirementSets {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListUserRequirementSetsFilter>;
  }

  export interface ListUserRequirementSetsResponse {
    Result?: EVA.Core.PagedResult<ListUserRequirementSetsResponse.UserRequirementSetDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListUserRequirementSetsResponse {
    export interface UserRequirementSetDto {
      /**
       * Entity type: UserRequirementSet
       */
      ID: number;
      Name: string;
      /**
       * Entity type: OrganizationUnitSet
       */
      OrganizationUnitSetID: number;
      OrganizationUnitSetName: string;
      OrganizationUnitSetDescription: string;
      OrganizationUnitSetType?: EVA.Core.OrganizationUnitSetTypes;
    }

  }

  /**
   * Creates a new UserRequirementSet and returns the ID of the new record.
   */
  export interface CreateUserRequirementSet {
    Name: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
  }

  export interface CreateUserRequirementSetResponse {
    /**
     * Entity type: UserRequirementSet
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Updates an existing UserRequirementSet.
   */
  export interface UpdateUserRequirementSet {
    /**
     * Entity type: UserRequirementSet
     */
    ID: number;
    Name?: string;
    /**
     * Entity type: OrganizationUnitSet
     * @deprecated Updating this property makes no sense. Create a duplicate and remove this one if you want to move to another OU set.
     */
    OrganizationUnitSetID?: number;
  }

  /**
   * Deletes a UserRequirementSet by its ID. Will also delete the underlying requirements.
   */
  export interface DeleteUserRequirementSet {
    /**
     * Entity type: UserRequirementSet
     */
    ID: number;
  }

  /**
   * Update all requirements on a UserRequirementSet.
   */
  export interface UpdateUserRequirementSetRequirements {
    /**
     * Entity type: UserRequirementSet
     */
    ID: number;
    Requirements: UpdateUserRequirementSetRequirements.UserRequirementDto[];
  }

  export namespace UpdateUserRequirementSetRequirements {
    export interface UserRequirementDto {
      /**
       * Entity type: UserRequirement
       */
      ID?: number;
      Property?: string;
      /**
       * Entity type: ShippingMethod
       */
      ShippingMethodID?: number;
      UserType?: EVA.Core.UserTypes;
      AccountType?: EVA.Core.UserAccountType;
      RequiredFor?: EVA.Core.UserRequirementFor;
      Preferred?: boolean;
      Display?: boolean;
      /**
       * Entity type: Script
       */
      ScriptID?: number;
      CustomValidators?: { [key: string]: any };
    }

  }

  /**
   * Duplicate the requirements of an existing set to a new set.
   */
  export interface DuplicateUserRequirementSet {
    /**
     * Entity type: UserRequirementSet
     */
    SetToDuplicateID: number;
    Name: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
  }

  export interface DuplicateUserRequirementSetResponse {
    /**
     * Entity type: UserRequirementSet
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the wishlists.
   */
  export interface ListWishlists {
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProperties?: string[];
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListWishlistsFilter>;
    PageToken?: string;
  }

  export interface ListWishlistsResponse {
    Results?: ListWishlistsResponse.Wishlist[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListWishlistsResponse {
    export interface Wishlist {
      /**
       * Entity type: Wishlist
       */
      ID: number;
      /**
       * Entity type: User
       */
      UserID: number;
      UserFullName: string;
      Name: string;
      Description: string;
      CreatedOn: string;
      LastReadTime: string;
      CreatedByEmployee: boolean;
      HiddenFromUser: boolean;
      FirstProduct?: any;
      ItemCount: number;
      IsShared: boolean;
    }

  }

  /**
   * Get the wishlist by ID.
   */
  export interface GetWishlist {
    /**
     * Entity type: Wishlist
     */
    ID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProperties?: string[];
  }

  export interface GetWishlistResponse {
    /**
     * Entity type: Wishlist
     */
    ID: number;
    /**
     * Entity type: User
     */
    UserID: number;
    UserFullName: string;
    Name: string;
    Description: string;
    CreatedOn: string;
    LastModifiedOn?: string;
    LastReadTime: string;
    CreatedByEmployee: boolean;
    HiddenFromUser: boolean;
    IsShared: boolean;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: EVA.Core.CustomFieldValueWithOptions };
    FirstProduct?: any;
    Products?: any[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new Employee
   */
  export interface CreateEmployeeUser {
    FirstName?: string;
    LastName?: string;
    Nickname?: string;
    EmailAddress?: string;
    Gender?: string;
    PhoneNumber?: string;
    DateOfBirth?: string;
    Password?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    EmployeeNumber?: string;
    Function?: string;
    /**
     * Entity type: OrganizationUnit
     */
    PrimaryOrganizationUnitID?: number;
    /**
     * Entity type: User
     */
    ManagerID?: number;
    UserRoles?: CreateEmployeeUser.UserRole[];
    /**
     * Optional additional custom fields
     */
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
    PricingGroupID?: string;
    IsSingleSignOnOnly?: boolean;
  }

  export namespace CreateEmployeeUser {
    export interface UserRole {
      /**
       * Entity type: Role
       */
      RoleID: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
    }

  }

  export interface CreateEmployeeUserResponse {
    /**
     * Entity type: User
     */
    UserID?: number;
    Result: CreateEmployeeResults;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export const enum CreateEmployeeResults {
    CreatedNewUser = 0,
    UpgradedExistingUser = 1,
    UpdatedExistingUser = 2
  }

  /**
   * Fetch a users employee data by `UserID`.
   */
  export interface GetEmployeeData {
    /**
     * Entity type: User
     */
    UserID: number;
  }

  export interface GetEmployeeDataResponse {
    /**
     * Entity type: User
     */
    UserID?: number;
    UserFullName?: string;
    UserEmailAddress?: string;
    EmployeeNumber?: string;
    Function?: string;
    PrimaryOrganizationUnitName?: string;
    /**
     * Entity type: User
     */
    ManagerID?: number;
    ManagerFullName?: string;
    ManagerEmailAddress?: string;
    /**
     * Entity type: OrganizationUnit
     */
    PrimaryOrganizationUnitID?: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create or update a users employee data.
   */
  export interface CreateOrUpdateEmployeeData {
    /**
     * Entity type: User
     */
    UserID: number;
    EmployeeNumber?: string;
    Function?: string;
    /**
     * Entity type: User
     */
    ManagerID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    PrimaryOrganizationUnitID?: number;
  }

  /**
   * Remove a users employee data.
   */
  export interface DeleteEmployeeData {
    /**
     * Entity type: User
     */
    UserID: number;
  }

  export interface GenerateIdentificationCodeForEmployee {
  }

  export interface GenerateIdentificationCodeForEmployeeResponse {
    Result: GenerateIdentificationCodeForEmployeeResponse.UserIdWithIdentificationCodeDto;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GenerateIdentificationCodeForEmployeeResponse {
    export interface UserIdWithIdentificationCodeDto {
      /**
       * Entity type: User
       */
      UserId: number;
      IdentificationCode: string;
    }

  }

  /**
   * Export all Employees with their roles in an excel file
   */
  export interface ExportEmployeeRoles {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  /**
   * Download an Excel sample which can be filled with customers. The populated excel can be uploaded through the `UploadCustomers` service.
   */
  export interface DownloadCustomersSample {
  }

  /**
   * Upload the Excel based on the sample from `DownloadCustomersSample`.
   * 
   * The uploaded file will be processed in the background and the results will be mailed to the uploader.
   */
  export interface UploadCustomers {
    Data: string;
  }

  /**
   * A service to upload an Excel containing tax codes info that.
   * The actions that can be taken on the tax codes are: create(C), update(U) or delete(D), according to the value specified in 'Action' column.
   */
  export interface UploadTaxCodesExcel {
    Data: string;
  }

  /**
   * Downloads an Excel file containing tax codes according to the specified PageConfig. To get an empty template Excel, specify a page size of zero.
   */
  export interface DownloadTaxCodesExcel {
  }

  /**
   * A service to upload an Excel containing tax rates.
   * The actions that can be applied on the tax rates are: Create, Update or Delete, according to the value specified in 'Action' column.
   */
  export interface UploadTaxRateExcel {
    Data: string;
  }

  /**
   * Downloads an Excel file containing tax rates according to the specified PageConfig.
   */
  export interface DownloadTaxRateExcel {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListTaxRateModelFilters>;
  }

  /**
   * Returns available survey triggers.
   */
  export interface GetAvailableSurveyTriggers {
    SurveyContext: EVA.Core.SurveyContext;
  }

  export interface GetAvailableSurveyTriggersResponse {
    Triggers: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Returns available survey distribution handlers.
   */
  export interface GetAvailableSurveyDistributionHandlers {
  }

  export interface GetAvailableSurveyDistributionHandlersResponse {
    Handlers: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the surveys
   */
  export interface ListSurveys {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListSurveyFilter>;
    PageToken?: string;
  }

  export interface ListSurveysResponse {
    Results?: ListSurveysResponse.SurveyDto[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListSurveysResponse {
    export interface SurveyDto {
      /**
       * Entity type: Survey
       */
      ID: number;
      Name: string;
      Description?: string;
      BackendID?: string;
      /**
       * Entity type: OrganizationUnitSet
       */
      OrganizationUnitSetID?: number;
      SurveyContext: EVA.Core.SurveyContext;
      SurveyTrigger: string;
      SurveyDistributionHandler: string;
      StartDate?: string;
      EndDate?: string;
      OneTimeUseOnly: boolean;
      DeactivationReasons: EVA.Core.SurveyDeactivationReasons;
      HasUnpublishedChanges: boolean;
      IsPublishing: boolean;
      HasActivePublishedVersion: boolean;
      LastPublishedVersion?: number;
      StartedResponses: number;
      CompletedResponses: number;
    }

  }

  /**
   * Get the survey
   */
  export interface GetSurveyByID {
    /**
     * Entity type: Survey
     */
    ID: number;
  }

  export interface GetSurveyByIDResponse {
    EditAllowed?: boolean;
    /**
     * Entity type: Survey
     */
    ID?: number;
    Name?: string;
    Description?: string;
    IntroductionTitle?: string;
    IntroductionMessage?: string;
    IntroductionBlob?: EVA.Core.BlobDto;
    ClosingRemarkTitle?: string;
    ClosingRemarkMessage?: string;
    ClosingRemarkBlob?: EVA.Core.BlobDto;
    BackendID?: string;
    SurveyContext?: EVA.Core.SurveyContext;
    SurveyTrigger?: string;
    SurveyTriggerData?: any;
    SurveyDistributionHandler?: string;
    SurveyDistributionHandlerData?: any;
    StartDate?: string;
    EndDate?: string;
    OneTimeUseOnly?: boolean;
    DeactivationReasons?: EVA.Core.SurveyDeactivationReasons;
    StartedResponses?: number;
    LastResponseStartedOn?: string;
    CompletedResponses?: number;
    LastResponseCompletedOn?: string;
    HasUnpublishedChanges?: boolean;
    IsPublishing?: boolean;
    HasActivePublishedVersion?: boolean;
    LastPublishedVersion?: number;
    LastPublishedBy?: GetSurveyByIDResponse.User;
    LastPublishedOn?: string;
    DeactivatedBy?: GetSurveyByIDResponse.User;
    DeactivatedOn?: string;
    OrganizationUnitSet?: GetSurveyByIDResponse.OrganizationUnitSetDto;
    AfterEffects?: EVA.Core.SurveyAfterEffectDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetSurveyByIDResponse {
    export interface User {
      /**
       * Entity type: User
       */
      ID: number;
      FullName: string;
    }

    export interface OrganizationUnitSetDto {
      /**
       * Entity type: OrganizationUnitSet
       */
      ID: number;
      BackendID?: string;
      Name: string;
      Type: EVA.Core.OrganizationUnitSetTypes;
    }

  }

  /**
   * Creates a new survey
   */
  export interface CreateSurvey {
    Name?: string;
    Description?: string;
    IntroductionTitle?: string;
    IntroductionMessage?: string;
    IntroductionBlobID?: string;
    ClosingRemarkTitle?: string;
    ClosingRemarkMessage?: string;
    ClosingRemarkBlobID?: string;
    BackendID?: string;
    SurveyContext?: EVA.Core.SurveyContext;
    SurveyTrigger?: string;
    SurveyTriggerData?: any;
    SurveyDistributionHandler?: string;
    SurveyDistributionHandlerData?: any;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    StartDate?: string;
    EndDate?: string;
    OneTimeUseOnly?: boolean;
    LoadPreviousResponseAnswers?: boolean;
    AfterEffects?: EVA.Core.SurveyAfterEffectDto[];
  }

  export interface CreateSurveyResponse {
    /**
     * Entity type: Survey
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update a survey.
   * NOTE THAT after update, the published survey will remain active and the current data will be taken into draft mode for republishing.
   * After publishing you can no longer change the OrganizationUnitSetID, SurveyContext, Trigger and (depending on the Trigger) some of the TriggerData properties.
   */
  export interface UpdateSurvey {
    /**
     * Entity type: Survey
     */
    ID: number;
    Name?: string;
    Description?: string;
    IntroductionTitle?: string;
    IntroductionMessage?: string;
    IntroductionBlobID?: string;
    ClosingRemarkTitle?: string;
    ClosingRemarkMessage?: string;
    ClosingRemarkBlobID?: string;
    BackendID?: string;
    SurveyContext?: EVA.Core.SurveyContext;
    SurveyTrigger?: string;
    SurveyTriggerData?: any;
    SurveyDistributionHandler?: string;
    SurveyDistributionHandlerData?: any;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    StartDate?: string;
    EndDate?: string;
    OneTimeUseOnly?: boolean;
    LoadPreviousResponseAnswers?: boolean;
    AfterEffects?: EVA.Core.SurveyAfterEffectDto[];
  }

  /**
   * Delete a survey
   */
  export interface DeleteSurvey {
    /**
     * Entity type: Survey
     */
    ID: number;
  }

  /**
   * Create and start a preview.
   */
  export interface StartSurveyPreview {
    /**
     * Entity type: Survey
     */
    SurveyID: number;
  }

  export interface StartSurveyPreviewResponse {
    Token: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Publishes all changes made to the survey.
   * 
   * Service will return an error when the survey is already published.
   * 
   * Survey cannot be published by the same user as the one who created / modified the survey, unless they have the right 'SurveySelfPublish'.
   * The service will return an error if the same user without the right 'SurveySelfPublish' tries to publish the survey.
   */
  export interface PublishSurvey {
    /**
     * Entity type: Survey
     */
    SurveyID: number;
    ValidateOnly?: boolean;
  }

  /**
   * Deactivates a survey.
   * NOTE THAT this deactivates all published versions of the survey, so it can no longer be responded to at the end of the grace period.
   * It will also take the survey back into draft.
   * The survey is re-enabled when a new version is published.
   */
  export interface DeactivateSurvey {
    /**
     * Entity type: Survey
     */
    SurveyID: number;
  }

  /**
   * Returns available survey after effects.
   */
  export interface GetAvailableSurveyAfterEffectTypes {
    SurveyContext: EVA.Core.SurveyContext;
  }

  export interface GetAvailableSurveyAfterEffectTypesResponse {
    AfterEffects: GetAvailableSurveyAfterEffectTypesResponse.AfterEffect[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAvailableSurveyAfterEffectTypesResponse {
    export interface AfterEffect {
      Type: string;
      MessageTemplates?: GetAvailableSurveyAfterEffectTypesResponse.MessageTemplate[];
    }

    export interface MessageTemplate {
      Name: string;
      IsAvailable: boolean;
    }

  }

  /**
   * List the survey questions
   */
  export interface GetSurveyQuestions {
    /**
     * Entity type: Survey
     */
    SurveyID: number;
  }

  export interface GetSurveyQuestionsResponse {
    Questions: GetSurveyQuestionsResponse.Question[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetSurveyQuestionsResponse {
    export interface Question {
      /**
       * Entity type: SurveyQuestion
       */
      ID?: number;
      BackendID?: string;
      Sequence?: number;
      Text?: string;
      Description?: string;
      Remark?: string;
      Blob?: EVA.Core.BlobDto;
      /**
       * Entity type: CustomField
       */
      SurveyContextCustomFieldID?: number;
      StoreAnswerOnContextCustomField?: boolean;
      UseContextCustomFieldDataAsPrefill?: boolean;
      DataType?: EVA.Core.CustomFieldDataTypes;
      OptionalAnswers?: { [key: string]: string };
      AllowMultipleAnswers?: boolean;
      DisplayType?: string;
      InputHint?: string;
      MinimumValue?: number;
      MaximumValue?: number;
      MinimumLength?: number;
      MaximumLength?: number;
      MinimumDate?: string;
      MaximumDate?: string;
      Required?: boolean;
      Routes?: GetSurveyQuestionsResponse.Route[];
      Type?: EVA.Core.SurveyQuestionType;
    }

    export interface Route {
      /**
       * Entity type: SurveyQuestionRoute
       */
      ID?: number;
      Sequence?: number;
      Filter?: EVA.Core.SurveyQuestionRouteFilter;
      /**
       * Entity type: SurveyQuestion
       */
      RouteToQuestionID?: number;
      ExitRemarkTitle?: string;
      ExitRemarkMessage?: string;
      ExitBlob?: EVA.Core.BlobDto;
    }

  }

  /**
   * Creates a new survey
   */
  export interface CreateSurveyQuestion {
    /**
     * Entity type: Survey
     */
    SurveyID?: number;
    BackendID?: string;
    Text?: string;
    Description?: string;
    Remark?: string;
    /**
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * A custom field that is available from the SurveyContext.
     * If context for example is `User`, all custom fields of the user are available.
     * If context for example is `Order`, all custom fields from the order and customer (user) on the order are available.
     * 
     * NOTE THAT this value cannot be update. If this question is based upon the custom field, any changes to the markup are rejected.
     * 
     * NOTE THAT any security settings on the custom field are ignored.
     * 
     * NOTE THAT when this value is set, the markup of the custom field is copied as markup for the survey question, and the response data is saved within the survey.
     * If the value also needs to be stored on the context entity self (e.g. order, user, etc), the setting `StoreAnswerOnContextCustomField` needs to be set.
     * When `StoreAnswerOnContextCustomField` is set to true, changes to the custom field itself will also be blocked while the survey is active.
     * Entity type: CustomField
     */
    SurveyContextCustomFieldID?: number;
    StoreAnswerOnContextCustomField?: boolean;
    UseContextCustomFieldDataAsPrefill?: boolean;
    DataType?: EVA.Core.CustomFieldDataTypes;
    OptionalAnswers?: { [key: string]: string };
    AllowMultipleAnswers?: boolean;
    DisplayType?: string;
    InputHint?: string;
    MinimumValue?: number;
    MaximumValue?: number;
    MinimumLength?: number;
    MaximumLength?: number;
    MinimumDate?: string;
    MaximumDate?: string;
    Required?: boolean;
    /**
     * When type Statement is selected, an answer won't be required and data type and custom field settings are ignored.
     */
    Type?: EVA.Core.SurveyQuestionType;
  }

  export interface CreateSurveyQuestionResponse {
    /**
     * Entity type: SurveyQuestion
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update a survey question
   */
  export interface UpdateSurveyQuestion {
    /**
     * Entity type: SurveyQuestion
     */
    ID: number;
    Text?: string;
    Description?: string;
    Remark?: string;
    BackendID?: string;
    /**
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * A custom field that is available from the SurveyContext.
     * If context for example is `User`, all custom fields of the user are available.
     * If context for example is `Order`, all custom fields from the order and customer (user) on the order are available.
     * 
     * NOTE THAT this value cannot be update. If this question is based upon the custom field, any changes to the markup are rejected.
     * 
     * NOTE THAT any security settings on the custom field are ignored.
     * 
     * NOTE THAT when this value is set, the markup of the custom field is copied as markup for the survey question, and the response data is saved within the survey.
     * If the value also needs to be stored on the context entity self (e.g. order, user, etc), the setting `StoreAnswerOnContextCustomField` needs to be set.
     * When `StoreAnswerOnContextCustomField` is set to true, changes to the custom field itself will also be blocked while the survey is active.
     * Entity type: CustomField
     */
    SurveyContextCustomFieldID?: number;
    StoreAnswerOnContextCustomField?: boolean;
    UseContextCustomFieldDataAsPrefill?: boolean;
    DataType?: EVA.Core.CustomFieldDataTypes;
    OptionalAnswers?: { [key: string]: string };
    AllowMultipleAnswers?: boolean;
    DisplayType?: string;
    InputHint?: string;
    MinimumValue?: number;
    MaximumValue?: number;
    MinimumLength?: number;
    MaximumLength?: number;
    MinimumDate?: string;
    MaximumDate?: string;
    Required?: boolean;
    Type?: EVA.Core.SurveyQuestionType;
  }

  /**
   * Delete a survey question
   */
  export interface DeleteSurveyQuestion {
    /**
     * Entity type: SurveyQuestion
     */
    ID: number;
  }

  /**
   * Creates a new survey question route
   */
  export interface CreateSurveyQuestionRoute {
    /**
     * Entity type: SurveyQuestion
     */
    ParentQuestionID?: number;
    /**
     * Entity type: SurveyQuestion
     */
    RouteToQuestionID?: number;
    Filter?: EVA.Core.SurveyQuestionRouteFilter;
    ExitBlobID?: string;
    ExitRemarkTitle?: string;
    ExitRemarkMessage?: string;
  }

  export interface CreateSurveyQuestionRouteResponse {
    /**
     * Entity type: SurveyQuestionRoute
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update a survey question route
   */
  export interface UpdateSurveyQuestionRoute {
    /**
     * Entity type: SurveyQuestionRoute
     */
    ID: number;
    /**
     * Entity type: SurveyQuestion
     */
    RouteToQuestionID?: number;
    Filter?: EVA.Core.SurveyQuestionRouteFilter;
    ExitBlobID?: string;
    ExitRemarkTitle?: string;
    ExitRemarkMessage?: string;
  }

  /**
   * Delete a survey question route.
   */
  export interface DeleteSurveyQuestionRoute {
    /**
     * Entity type: SurveyQuestionRoute
     */
    ID: number;
  }

  /**
   * Takes in all questions of a survey and sets their sequences.
   */
  export interface SetSurveyQuestionSequences {
    /**
     * Entity type: Survey
     */
    SurveyID: number;
    /**
     * Entity type: SurveyQuestion
     */
    SurveyQuestionIDs: number[];
  }

  /**
   * Takes in all routings of a question and sets their sequences.
   */
  export interface SetSurveyQuestionRoutingSequences {
    /**
     * Entity type: SurveyQuestion
     */
    SurveyQuestionID: number;
    /**
     * Entity type: SurveyQuestionRoute
     */
    SurveyQuestionRoutingIDs: number[];
  }

  /**
   * List the available custom fields for a given survey context
   */
  export interface ListCustomFieldsForSurvey {
    SurveyContext?: EVA.Core.SurveyContext;
    CustomFieldName?: string;
    /**
     * Entity type: CustomFieldType
     */
    CustomFieldTypeIDs?: number[];
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListCustomFieldsForSurveyResponse {
    AvailableCustomFieldTypes?: ListCustomFieldsForSurveyResponse.AvailableCustomFieldType[];
    Result?: EVA.Core.PagedResult<EVA.Core.CustomFieldMetadata>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCustomFieldsForSurveyResponse {
    export interface AvailableCustomFieldType {
      /**
       * Entity type: CustomFieldType
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Get all available surveys for user
   */
  export interface GetAvailableSurveys {
    /**
     * Organization unit in which surveys are available. When omitted, falls back to the current organization. Ignored when logged in user is a customer
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * User for which surveys are available. When omitted, falls back to the current user.
     * Entity type: User
     */
    UserID?: number;
  }

  export interface GetAvailableSurveysResponse {
    Surveys: GetAvailableSurveysResponse.AvailableSurvey[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAvailableSurveysResponse {
    export interface AvailableSurvey {
      /**
       * Entity type: Survey
       */
      ID: number;
      Name: string;
      Description?: string;
      Context: EVA.Core.SurveyContext;
      ContextSourceID?: number;
      Status: EVA.Core.SurveyResponseStatus;
      /**
       * Time the survey was started or the first question was answered.
       */
      FirstInteractionTime?: string;
      /**
       * Time the last question was answered.
       */
      LastInteractionTime?: string;
    }

  }

  /**
   * Get all available surveys for user and given context
   */
  export interface GetAvailableSurveysForContext {
    SurveyContext: EVA.Core.SurveyContext;
    SurveyContextSourceID: number;
    /**
     * Organization unit in which surveys are available. When omitted, falls back to the current organization. Ignored when logged in user is a customer
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  /**
   * Start a survey
   */
  export interface StartSurvey {
    Token?: string;
    /**
     * Entity type: Survey
     */
    SurveyID?: number;
    SurveyContextSourceID?: number;
  }

  export interface StartSurveyResponse {
    Token?: string;
    /**
     * The ID of the previous question.
     * Entity type: SurveyQuestion
     */
    PreviousQuestionID?: number;
    /**
     * Question to be answered. When null, the survey is done.
     */
    Question?: SurveyQuestionDto;
    /**
     * Indicates if the question has been answered before.
     */
    HasBeenAnswered?: boolean;
    /**
     * The answer given previously.
     */
    GivenAnswer?: EVA.Core.CustomFieldValue;
    /**
     * Filled when it's the first question of the survey.
     */
    Introduction?: QuestionResponse.SurveyRemark;
    /**
     * Filled when there is no question left to answer.
     */
    ClosingRemark?: QuestionResponse.SurveyRemark;
    /**
     * Indicates if the survey response is previously completed.
     */
    SurveyResponsePreviouslyCompleted?: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface SurveyQuestionDto {
    /**
     * Entity type: SurveyQuestion
     */
    ID?: number;
    Text?: string;
    Description?: string;
    Remark?: string;
    BackendID?: string;
    Blob?: EVA.Core.BlobDto;
    DataType?: EVA.Core.CustomFieldDataTypes;
    Type?: EVA.Core.SurveyQuestionType;
    OptionalAnswers?: { [key: string]: string };
    AllowMultipleAnswers?: boolean;
    DisplayType?: string;
    InputHint?: string;
    MinimumValue?: number;
    MaximumValue?: number;
    MinimumLength?: number;
    MaximumLength?: number;
    MinimumDate?: string;
    MaximumDate?: string;
    Required?: boolean;
  }

  /**
   * Get a question that is already answered (to navigate back and forth in the survey)
   */
  export interface GetSurveyQuestionAnswer {
    Token: string;
    /**
     * Entity type: SurveyQuestion
     */
    SurveyQuestionID: number;
  }

  export interface GetSurveyQuestionAnswerResponse {
    /**
     * The ID of the next question.
     * Entity type: SurveyQuestion
     */
    NextQuestion?: number;
    /**
     * Indicates if the next question has been answered before.
     */
    NextQuestionHasBeenAnswered: boolean;
    /**
     * The ID of the previous question.
     * Entity type: SurveyQuestion
     */
    PreviousQuestionID?: number;
    /**
     * Question to be answered. When null, the survey is done.
     */
    Question?: SurveyQuestionDto;
    /**
     * Indicates if the question has been answered before.
     */
    HasBeenAnswered?: boolean;
    /**
     * The answer given previously.
     */
    GivenAnswer?: EVA.Core.CustomFieldValue;
    /**
     * Filled when it's the first question of the survey.
     */
    Introduction?: QuestionResponse.SurveyRemark;
    /**
     * Filled when there is no question left to answer.
     */
    ClosingRemark?: QuestionResponse.SurveyRemark;
    /**
     * Indicates if the survey response is previously completed.
     */
    SurveyResponsePreviouslyCompleted?: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Answer a survey question
   */
  export interface AnswerSurveyQuestion {
    Token?: string;
    /**
     * Entity type: SurveyQuestion
     */
    SurveyQuestionID?: number;
    /**
     * Required unless the question is optional.
     */
    Answer?: EVA.Core.CustomFieldValue;
  }

  export interface QuestionResponse {
    /**
     * The ID of the previous question.
     * Entity type: SurveyQuestion
     */
    PreviousQuestionID?: number;
    /**
     * Question to be answered. When null, the survey is done.
     */
    Question?: SurveyQuestionDto;
    /**
     * Indicates if the question has been answered before.
     */
    HasBeenAnswered?: boolean;
    /**
     * The answer given previously.
     */
    GivenAnswer?: EVA.Core.CustomFieldValue;
    /**
     * Filled when it's the first question of the survey.
     */
    Introduction?: QuestionResponse.SurveyRemark;
    /**
     * Filled when there is no question left to answer.
     */
    ClosingRemark?: QuestionResponse.SurveyRemark;
    /**
     * Indicates if the survey response is previously completed.
     */
    SurveyResponsePreviouslyCompleted?: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace QuestionResponse {
    export interface SurveyRemark {
      Title?: string;
      Message?: string;
      Blob?: EVA.Core.BlobDto;
    }

  }

  /**
   * Restart the survey response
   */
  export interface RestartSurveyResponse {
    Token: string;
  }

  /**
   * Cancel the survey response
   */
  export interface CancelSurveyResponse {
    Token?: string;
    /**
     * Entity type: Survey
     */
    SurveyID?: number;
    SurveyContextSourceID?: number;
  }

  /**
   * Returns all translatable items within the survey.
   */
  export interface GetSurveyTranslatableItems {
    /**
     * Entity type: Survey
     */
    SurveyID: number;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Filter on specific country. Only returns exact matches. Translations set solely on language will not be returned because the combination does not exist.
     * Entity type: Country
     */
    CountryID?: string;
  }

  export interface GetSurveyTranslatableItemsResponse {
    TranslatableItems: TranslatableItem[];
    QuestionTranslatableItems?: QuestionTranslatableItem[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface TranslatableItem {
    TranslationKey?: string;
    OriginalValue?: string;
    TranslationValue?: string;
  }

  export interface QuestionTranslatableItem {
    /**
     * Entity type: SurveyQuestion
     */
    QuestionID: number;
    TranslatableItems?: TranslatableItem[];
    QuestionRouteTranslatableItems?: QuestionRouteTranslatableItem[];
  }

  export interface QuestionRouteTranslatableItem {
    /**
     * Entity type: SurveyQuestionRoute
     */
    QuestionRouteID: number;
    TranslatableItems: TranslatableItem[];
  }

  /**
   * Set all translatable items within the survey.
   */
  export interface SetSurveyTranslatableItems {
    /**
     * Entity type: Survey
     */
    SurveyID: number;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    TranslatableItems?: TranslatableItem[];
    QuestionTranslatableItems?: QuestionTranslatableItem[];
  }

  /**
   * Returns the translation status of the survey.
   */
  export interface GetSurveyTranslationStatus {
    /**
     * Entity type: Survey
     */
    SurveyID?: number;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
  }

  export interface GetSurveyTranslationStatusResponse {
    Statuses: GetSurveyTranslationStatusResponse.TranslationStatus[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetSurveyTranslationStatusResponse {
    export interface TranslationStatus {
      /**
       * Entity type: Language
       */
      LanguageID: string;
      /**
       * Entity type: Country
       */
      CountryID: string;
      /**
       * Percentage of translations that are set. 0-100
       */
      Progress: number;
    }

  }

  export interface ExportStockMutationSummary {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetIDs?: number[];
    ProductSearchFilters?: { [key: string]: EVA.Core.FilterModel };
    /**
     * The date to use for the stock mutation summary. Only the date component is used, which means if you send in 2023-06-29T16:00 all stock mutations on 2023-06-29 will be included.
     */
    Date?: string;
    /**
     * The date and time to use for the stock mutation summary, in UTC. Unlike the `Date` field, the time component is used.
     */
    DateTime?: string;
    EmailAddress?: string;
    SplitUnitCost?: boolean;
  }

  /**
   * Returns a list of stock mutation reasons that are currently active for the supplied OrganizationUnitID.
   */
  export interface GetRecentlyUsedStockMutationReasons {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetRecentlyUsedStockMutationReasonsResponse {
    Reasons: GetRecentlyUsedStockMutationReasonsResponse.StockMutationReason[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetRecentlyUsedStockMutationReasonsResponse {
    export interface StockMutationReason {
      ID: number;
      /**
       * Usually an internal & unchangable code - for display, use `Description`
       */
      Name: string;
      Description: string;
    }

  }

  /**
   * This service allows retrieval of StockMutations, filtered by a Query and/or a set of filters.
   */
  export interface SearchStockMutations {
    Query?: string;
    PageConfig?: EVA.Core.ScrollablePageConfig<EVA.Core.StockMutationFilters>;
    IncludedFields?: string[];
  }

  export interface SearchStockMutationsResponse {
    Result: EVA.Core.ScrollablePagedResult<EVA.Core.SearchStockMutationResult>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List internal and custom stock mutation reasons.
   */
  export interface ListStockMutationReasons {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListStockMutationReasonsModelFilters>;
  }

  export interface ListStockMutationReasonsResponse {
    Result?: EVA.Core.PagedResult<StockMutationReason>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface StockMutationReason {
    /**
     * Entity type: StockMutationReasons
     */
    ID?: number;
    /**
     * Usually an internal & unchangable code - for display, use `Description`
     */
    Name?: string;
    Description?: string;
    BackendID?: string;
    RequireRemarkForMove?: boolean;
    RequireRemarkForAdjust?: boolean;
    IsSystem?: boolean;
  }

  /**
   * Create a custom stock mutation reason.
   */
  export interface CreateStockMutationReason {
    Name: string;
    Description?: string;
    BackendID?: string;
    RequireRemarkForMove: boolean;
    RequireRemarkForAdjust: boolean;
  }

  export interface CreateStockMutationReasonResponse {
    /**
     * Entity type: StockMutationReasons
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update a custom or internal stock mutation reason. The name cannot be modified for internal reasons.
   */
  export interface UpdateStockMutationReason {
    /**
     * Entity type: StockMutationReasons
     */
    ID: number;
    Name?: string;
    Description?: string;
    BackendID?: string;
    RequireRemarkForMove?: boolean;
    RequireRemarkForAdjust?: boolean;
  }

  /**
   * Delete a custom stock mutation reason.
   */
  export interface DeleteStockMutationReason {
    /**
     * Entity type: StockMutationReasons
     */
    ID?: number;
  }

  /**
   * Download an overview of the stock for the specified organization units or the specified organization unit set.
   * NOTE THAT when `OrganizationUnitSetID` is provided, `OrganizationUnitIDs` is ignored.
   */
  export interface DownloadStockOverview {
    /**
     * The organization units to list the stock for
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs: number[];
    /**
     * The organization units set to list the stock for
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Filter on products, is used as input in ElasticSearch
     */
    Query?: string;
    /**
     * View the stock on a certain moment in time
     */
    DateTime?: string;
    /**
     * Only these products will be returned
     * Entity type: Product
     */
    ProductIDs?: number[];
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
  }

  export interface InitialReplenishment {
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrl?: string;
    EmailAddress: string;
  }

  export interface InitialReplenishmentResponse {
    TaskID: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListCumulativeStock {
    PageConfig: EVA.Core.PageConfig<EVA.Core.ListCumulativeStockFilter>;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface ListCumulativeStockResponse {
    Result?: EVA.Core.PagedResult<ListCumulativeStockResponse.Model>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCumulativeStockResponse {
    export interface Model {
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      OrganizationUnitName: string;
      OrganizationUnitBackendID: string;
      Product: any;
      QuantityOnHand: number;
    }

  }

  /**
   * Creates a StockAllocationRule for the SupplierOrganizationUnitID and OrganizationUnitID.
   * 
   * - If `ProductID` is left null, this is a 'catch-all' rule, meaning that the rule applies to all products (but it can still be overriden by a rule with a specific `ProductID`).
   * Only a reservation can be a catch-all rule, a limitation must specify a `ProductID` or a `ProductSearchTemplateID`.
   * - `RefillPeriodInDays` is ignored when the Type is not a `Limitation`, as only a `Limitation` can be refilled.
   * - If `ValueType` is `Percentage`, then `Value` must be between 0 and 100.
   * - `OrganizationUnitSupplierID` is a reference to a supplier relationship between OrganizationUnits, not to an OrganizationUnit.
   * This is for example the supplier relationship between a warehouse and a store. Available OrganizationUnitSuppliers can be found through `ListOrganizationUnitSuppliers`.
   * - When left empty, OrganizationUnitID defaults to the OrganizationUnitID on the OrganizationUnitSupplier. So if the supplier relationship is between a warehouse and a store, this will
   * default to the store. When specified, the OrganizationUnitID *must* be one that the supplier of the relationship *directly* supplies to.
   * For example, if a supplier relationship exists between a warehouse and a country OrganizationUnit then you *can't* specify a store that falls
   * under that country OrganizationUnit. In that case, you should create a StockAllocationRule between the country and the store,
   * not between the warehouse and the store.
   */
  export interface CreateStockAllocationRule {
    /**
     * Entity type: OrganizationUnitSupplier
     */
    OrganizationUnitSupplierID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    Value: number;
    ValueType: EVA.Core.StockAllocationRuleValueTypes;
    RefillPeriodInDays?: number;
    Type: EVA.Core.StockAllocationRuleTypes;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    StartDate?: string;
    EndDate?: string;
    /**
     * In case there is not enough stock, Priority is used to determine who gets preference. A higher Priority means a higher preference.
     */
    Priority: number;
  }

  export interface CreateStockAllocationRuleResponse {
    /**
     * Entity type: StockAllocationRule
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Allows updating a StockAllocationRule. Only `Value`, `ValueType`, `RefillPeriodInDays`, `Priority`, `StartDate` and `EndDate` can be updated. To update the other fields, the rule must be re-created.
   */
  export interface UpdateStockAllocationRule {
    /**
     * Entity type: StockAllocationRule
     */
    ID: number;
    Value?: number;
    ValueType?: EVA.Core.StockAllocationRuleValueTypes;
    RefillPeriodInDays?: number;
    StartDate?: string;
    EndDate?: string;
    /**
     * In case there is not enough stock, Priority is used to determine who gets preference. A higher Priority means a higher preference.
     */
    Priority?: number;
  }

  /**
   * Deletes a StockAllocationRule.
   */
  export interface DeleteStockAllocationRule {
    /**
     * Entity type: StockAllocationRule
     */
    ID: number;
  }

  export interface ListStockAllocationRules {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListStockAllocationRulesFilter>;
  }

  export interface ListStockAllocationRulesResponse {
    Result?: EVA.Core.PagedResult<EVA.Core.ListStockAllocationRulesItem>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Reallocates the stock for a StockLocationRule with `Type` = `Limitation`.
   */
  export interface RefillStockAllocation {
    /**
     * Entity type: StockAllocationRule
     */
    ID: number;
    ValueOverride?: number;
  }

  /**
   * A service to upload an Excel containing StockAllocationRules that should be created or updated according to the values specified in the sheet.
   * 
   * An example Excel file containing the expected structure can be retrieved by calling the `DownloadStockAllocationRulesExcel` service. Important to note however
   * is that the first column ('C/U/D' which stands for Create/Update/Delete) will be empty in the Excel file returned by `DownloadStockAllocationRulesExcel`, but to update
   * or create a record the first column must have a value according to what you want to do with it. To create a row, the first column must contain 'C', to update it must contain 'U' (and the ID column must have a value pointing to the correct record)
   * and to delete it it must contain 'D'.
   */
  export interface UploadStockAllocationRulesExcel {
    Data: string;
  }

  /**
   * Downloads an Excel file containing StockAllocationRules according to the specified PageConfig. To get an empty template Excel, specify a page size of zero.
   */
  export interface DownloadStockAllocationRulesExcel {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListStockAllocationRulesFilter>;
  }

  /**
   * Create a new StockLabel
   * 
   * Name is required
   */
  export interface CreateStockLabel {
    Name?: string;
    Description?: string;
    DisplayName?: string;
    LedgerClassID?: string;
  }

  export interface CreateStockLabelResponse {
    /**
     * Entity type: StockLabel
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update the description or ledgerclass of StockLabel
   */
  export interface UpdateStockLabel {
    /**
     * Entity type: StockLabel
     */
    ID: number;
    Description?: string;
    DisplayName?: string;
    LedgerClassID?: string;
  }

  /**
   * Create a new Carrier
   */
  export interface CreateCarrier {
    Name: string;
    Code?: string;
    BackendID?: string;
  }

  export interface CreateCarrierResponse {
    /**
     * Entity type: Carrier
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get a Carrier
   */
  export interface GetCarrierByID {
    /**
     * Entity type: Carrier
     */
    ID: number;
  }

  export interface GetCarrierByIDResponse {
    ID: number;
    Name: string;
    Code: string;
    BackendID: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the Carriers
   */
  export interface ListCarriers {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListCarriersFilter>;
  }

  export interface ListCarriersResponse {
    Result?: EVA.Core.PagedResult<CarrierDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface CarrierDto {
    /**
     * Entity type: Carrier
     */
    ID: number;
    Name: string;
    Code: string;
    BackendID: string;
  }

  /**
   * Update a Carrier
   */
  export interface UpdateCarrier {
    /**
     * Entity type: Carrier
     */
    ID: number;
    Name: string;
    Code?: string;
    BackendID?: string;
  }

  /**
   * Returns available handlers for shipping methods
   */
  export interface GetAvailableShippingMethodHandlers {
  }

  export interface GetAvailableShippingMethodHandlersResponse {
    Handlers: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListShippingMethods {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListShippingMethodsFilter>;
  }

  export interface ListShippingMethodsResponse {
    Result?: EVA.Core.PagedResult<ListShippingMethodsResponse.ShippingMethodDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListShippingMethodsResponse {
    export interface ShippingMethodDto {
      /**
       * Entity type: ShippingMethod
       */
      ID: number;
      Name: string;
      /**
       * Entity type: Carrier
       */
      CarrierID: number;
      CarrierName: string;
      /**
       * Entity type: ProductSearchTemplate
       */
      ProductSearchTemplateID?: number;
      ProductSearchTemplateName: string;
    }

  }

  /**
   * Get an OrganizationUnitShippingMethod
   */
  export interface GetOrganizationUnitShippingMethodByID {
    /**
     * Entity type: OrganizationUnitShippingMethod
     */
    ID: number;
  }

  export interface GetOrganizationUnitShippingMethodByIDResponse {
    /**
     * Entity type: OrganizationUnitShippingMethod
     */
    ID: number;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID: number;
    ShippingMethodName: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    Priority: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create an OrganizationUnitShippingMethod
   * 
   * A ShippingMethod, OrganizationUnit and Priority are required
   */
  export interface CreateOrganizationUnitShippingMethod {
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    Priority: number;
  }

  export interface CreateOrganizationUnitShippingMethodResponse {
    /**
     * Entity type: OrganizationUnitShippingMethod
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an OrganizationUnitShippingMethod
   * 
   * A ShippingMethod, OrganizationUnit and Priority are required
   */
  export interface UpdateOrganizationUnitShippingMethod {
    /**
     * Entity type: OrganizationUnitShippingMethod
     */
    ID: number;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    Priority: number;
  }

  /**
   * Delete an OrganizationUnitShippingMethod
   */
  export interface DeleteOrganizationUnitShippingMethod {
    /**
     * Entity type: OrganizationUnitShippingMethod
     */
    ID: number;
  }

  /**
   * List the OrganizationUnitShippingMethods
   * 
   * There are filters available on:
   *  - ShippingMethodID
   *  - OrganizationUnitID
   */
  export interface ListOrganizationUnitShippingMethods {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListOrganizationUnitShippingMethodsFilter>;
  }

  export interface ListOrganizationUnitShippingMethodsResponse {
    Result?: EVA.Core.PagedResult<OrganizationUnitShippingMethodDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface OrganizationUnitShippingMethodDto {
    /**
     * Entity type: OrganizationUnitShippingMethod
     */
    ID: number;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID: number;
    ShippingMethodName: string;
    ShippingMethodCarrierName: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    Priority: number;
  }

  /**
   * Create a new package, with dimensions in millimeters (mm) and weight in grams (g).
   */
  export interface CreatePackage {
    Description?: string;
    Code?: string;
    /**
     * mm
     * Min: 1
     */
    Length: number;
    /**
     * mm
     * Min: 1
     */
    Width: number;
    /**
     * mm
     * Min: 1
     */
    Height: number;
    /**
     * g
     * Min: 1
     */
    Weight: number;
  }

  export interface CreatePackageResponse {
    /**
     * Entity type: Package
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get all packages, with dimensions in millimeters (mm) and weight in grams (g).
   */
  export interface GetPackages {
  }

  export interface GetPackagesResponse {
    Result: PackageDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface PackageDto {
    IsDefault: boolean;
    /**
     * Entity type: Package
     */
    ID: number;
    Description: string;
    Code?: string;
    Length: number;
    Width: number;
    Height: number;
    Weight: number;
  }

  /**
   * Update a package, with dimensions in millimeters (mm) and weight in grams (g).
   */
  export interface UpdatePackage {
    /**
     * Entity type: Package
     */
    ID: number;
    Description?: string;
    Code?: string;
    /**
     * mm
     * Min: 1
     */
    Length: number;
    /**
     * mm
     * Min: 1
     */
    Width: number;
    /**
     * mm
     * Min: 1
     */
    Height: number;
    /**
     * g
     * Min: 1
     */
    Weight: number;
  }

  /**
   * Delete a package
   */
  export interface DeletePackage {
    /**
     * Entity type: Package
     */
    ID: number;
  }

  /**
   * Get all packages for a carrier, with dimensions in millimeters (mm) and weight in grams (g).
   */
  export interface GetPackagesForCarrier {
    /**
     * Entity type: Carrier
     */
    CarrierID: number;
  }

  /**
   * Add a package to a carrier
   */
  export interface AddPackageToCarrier {
    /**
     * Entity type: Package
     */
    PackageID: number;
    /**
     * Entity type: Carrier
     */
    CarrierID: number;
    IsDefault?: boolean;
  }

  /**
   * Remove a package from a carrier
   */
  export interface RemovePackageFromCarrier {
    /**
     * Entity type: Package
     */
    PackageID: number;
    /**
     * Entity type: Carrier
     */
    CarrierID: number;
  }

  /**
   * Get a `ShippingCost`
   */
  export interface GetShippingCostByID {
    /**
     * Entity type: ShippingCost
     */
    ID: number;
  }

  export interface GetShippingCostByIDResponse {
    /**
     * Entity type: ShippingCost
     */
    ID: number;
    BackendID: string;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    ShippingMethodName: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OrganizationUnitName: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    MinimumOrderAmount?: number;
    MaximumOrderAmount?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    Amount: number;
    ZipCodes: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a `ShippingCost`
   */
  export interface CreateShippingCost {
    BackendID?: string;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    ZipCodes?: string[];
    MinimumOrderAmount?: number;
    MaximumOrderAmount?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    Amount?: number;
  }

  export interface CreateShippingCostResponse {
    /**
     * Entity type: ShippingCost
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update a `ShippingCost`
   */
  export interface UpdateShippingCost {
    /**
     * Entity type: ShippingCost
     */
    ID: number;
    BackendID?: string;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    ZipCodes?: string[];
    MinimumOrderAmount?: number;
    MaximumOrderAmount?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    Amount?: number;
  }

  /**
   * Delete a `ShippingCost`
   */
  export interface DeleteShippingCost {
    /**
     * Entity type: ShippingCost
     */
    ID: number;
  }

  /**
   * List the available `ShippingCost`
   */
  export interface ListShippingCosts {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListShippingCostsFilter>;
  }

  export interface ListShippingCostsResponse {
    Result?: EVA.Core.PagedResult<ShippingCostDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ShippingCostDto {
    /**
     * Entity type: ShippingCost
     */
    ID: number;
    BackendID: string;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    ShippingMethodName: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OrganizationUnitName: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    ZipCodes: string[];
    MinimumOrderAmount?: number;
    MaximumOrderAmount?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    Amount: number;
  }

  /**
   * Create a new ShippingMethod
   */
  export interface CreateShippingMethod {
    Name: string;
    Code?: string;
    Handler?: string;
    /**
     * Entity type: Carrier
     */
    CarrierID: number;
    DeliveryType: EVA.Core.ShippingMethodDeliveryTypes;
    ExcludeProductsFromShippingMethod?: boolean;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    PaymentHandledByCarrier?: boolean;
    ShippingHandledByCarrier?: boolean;
    InvoicingHandledByCarrier?: boolean;
    SupportsPickupAddress?: boolean;
    /**
     * Optional additional custom fields
     */
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
    /**
     * Entity type: EndpointConfiguration
     */
    EndpointConfigurationID?: number;
  }

  export interface CreateShippingMethodResponse {
    /**
     * Entity type: ShippingMethod
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get an existing ShippingMethod by ID
   */
  export interface GetShippingMethodByID {
    /**
     * Entity type: ShippingMethod
     */
    ID: number;
  }

  export interface GetShippingMethodByIDResponse {
    /**
     * Entity type: ShippingMethod
     */
    ID: number;
    Name: string;
    Code: string;
    Handler: string;
    PaymentHandledByCarrier: boolean;
    ShippingHandledByCarrier: boolean;
    InvoicingHandledByCarrier: boolean;
    /**
     * Entity type: Carrier
     */
    CarrierID: number;
    CarrierName: string;
    CarrierCode: string;
    DeliveryType: EVA.Core.ShippingMethodDeliveryTypes;
    ExcludeProductsFromShippingMethod: boolean;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: EVA.Core.CustomFieldValueWithOptions };
    /**
     * Entity type: EndpointConfiguration
     */
    EndpointConfigurationID?: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the ShippingMethods
   */
  export interface ListManagementShippingMethods {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListShippingMethodsFilter>;
  }

  export interface ListManagementShippingMethodsResponse {
    Result?: EVA.Core.PagedResult<ListManagementShippingMethodsResponse.Data>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListManagementShippingMethodsResponse {
    export interface Data {
      /**
       * Entity type: ShippingMethod
       */
      ID: number;
      Name: string;
      Code: string;
      Handler: string;
      PaymentHandledByCarrier: boolean;
      ShippingHandledByCarrier: boolean;
      InvoicingHandledByCarrier: boolean;
      /**
       * Entity type: Carrier
       */
      CarrierID: number;
      CarrierName: string;
      CarrierCode: string;
      DeliveryType: EVA.Core.ShippingMethodDeliveryTypes;
      /**
       * Entity type: ProductSearchTemplate
       */
      ProductSearchTemplateID?: number;
      ProductSearchTemplateName: string;
      /**
       * Entity type: CustomField
       */
      CustomFieldValuesWithOptions?: { [key: number]: EVA.Core.CustomFieldValueWithOptions };
      /**
       * Entity type: EndpointConfiguration
       */
      EndpointConfigurationID?: number;
    }

  }

  /**
   * Update an existing ShippingMethod
   */
  export interface UpdateShippingMethod {
    /**
     * Entity type: ShippingMethod
     */
    ID: number;
    Name: string;
    Code?: string;
    Handler?: string;
    /**
     * Entity type: Carrier
     */
    CarrierID: number;
    DeliveryType: EVA.Core.ShippingMethodDeliveryTypes;
    ExcludeProductsFromShippingMethod?: boolean;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    PaymentHandledByCarrier?: boolean;
    ShippingHandledByCarrier?: boolean;
    InvoicingHandledByCarrier?: boolean;
    SupportsPickupAddress?: boolean;
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
    /**
     * Entity type: EndpointConfiguration
     */
    EndpointConfigurationID?: number;
  }

  /**
   * Creates a new ShippingMethodTransportationTime.
   */
  export interface CreateShippingMethodTransportationTime {
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    /**
     * Entity type: Country
     */
    FromCountryID?: string;
    /**
     * Entity type: Country
     */
    ToCountryID?: string;
    TimeInDays: number;
  }

  export interface CreateShippingMethodTransportationTimeResponse {
    /**
     * Entity type: ShippingMethodTransportationTime
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Updates a ShippingMethodTransportationTime.
   * If you want to preserve the current value of a field, provide it to this service as the current value;
   *  if it's sent in as null the value will be set to null.
   */
  export interface UpdateShippingMethodTransportationTime {
    /**
     * Entity type: ShippingMethodTransportationTime
     */
    ID: number;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    /**
     * Entity type: Country
     */
    FromCountryID?: string;
    /**
     * Entity type: Country
     */
    ToCountryID?: string;
    TimeInDays: number;
  }

  /**
   * Deletes a ShippingMethodTransportationTime.
   */
  export interface DeleteShippingMethodTransportationTime {
    /**
     * Entity type: ShippingMethodTransportationTime
     */
    ID: number;
  }

  /**
   * Lists current ShippingMethodTransportationTimes, optionally filtered.
   */
  export interface ListShippingMethodTransportationTimes {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListTransportationTimesFilter>;
  }

  export interface ListShippingMethodTransportationTimesResponse {
    Result: EVA.Core.PagedResult<EVA.Core.ShippingMethodTransportationTimeItem>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Gets a ShippingRestriction by its ID and returns the set's basic information.
   */
  export interface GetShippingRestrictionByID {
    /**
     * Entity type: ShippingRestriction
     */
    ID: number;
  }

  export interface GetShippingRestrictionByIDResponse {
    /**
     * Entity type: ShippingRestriction
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OrganizationUnitName: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    OrganizationUnitSetName?: string;
    OrganizationUnitSetDescription?: string;
    OrganizationUnitSetType?: EVA.Core.OrganizationUnitSetTypes;
    CountryID?: string;
    CountryName?: string;
    ZipCodeFrom: string;
    ZipCodeTo: string;
    /**
     * Entity type: ProductPropertyType
     */
    ProductPropertyTypeID: string;
    ProductPropertyTypeValues: string[];
    Type: EVA.Core.ShippingRestrictionType;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    CheckScriptOnly: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Creates a new ShippingRestriction.
   */
  export interface CreateShippingRestriction {
    /**
     * Either an OrganizationUnitID or an OrganizationUnitSetID is required when there is no ScriptID set or CheckScriptOnly is 'false'
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Either an OrganizationUnitID or an OrganizationUnitSetID is required when there is no ScriptID set or CheckScriptOnly is 'false'
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Required when there is no ScriptID set or CheckScriptOnly is 'false'
     * Entity type: Country
     */
    CountryID?: string;
    ZipCodeFrom?: string;
    ZipCodeTo?: string;
    /**
     * Entity type: ProductPropertyType
     */
    ProductPropertyTypeID?: string;
    ProductPropertyTypeValues?: string[];
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    /**
     * When set to `true`, the script will be leading for the entire order. Default is `true`
     */
    CheckScriptOnly?: boolean;
    Type: EVA.Core.ShippingRestrictionType;
  }

  export interface CreateShippingRestrictionResponse {
    /**
     * Entity type: ShippingRestriction
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Updates a ShippingRestriction.
   */
  export interface UpdateShippingRestriction {
    /**
     * Entity type: ShippingRestriction
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    ZipCodeFrom?: string;
    ZipCodeTo?: string;
    /**
     * Entity type: ProductPropertyType
     */
    ProductPropertyTypeID?: string;
    ProductPropertyTypeValues?: string[];
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    /**
     * When set to `true`, the script will be leading for the entire order.
     */
    CheckScriptOnly?: boolean;
    Type?: EVA.Core.ShippingRestrictionType;
  }

  /**
   * Deletes a ShippingRestriction by its ID.
   */
  export interface DeleteShippingRestriction {
    /**
     * Entity type: ShippingRestriction
     */
    ID: number;
  }

  /**
   * List ShippingRestrictions. Returns a paged response. Filter options are;
   */
  export interface ListShippingRestrictions {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListShippingRestrictionsFilter>;
  }

  export interface ListShippingRestrictionsResponse {
    Result?: EVA.Core.PagedResult<ShippingRestrictionDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ShippingRestrictionDto {
    /**
     * Entity type: ShippingRestriction
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OrganizationUnitName: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    OrganizationUnitSetName?: string;
    OrganizationUnitSetDescription?: string;
    OrganizationUnitSetType?: EVA.Core.OrganizationUnitSetTypes;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    CountryName?: string;
    ZipCodeFrom: string;
    ZipCodeTo: string;
    /**
     * Entity type: ProductPropertyType
     */
    ProductPropertyTypeID: string;
    ProductPropertyTypeValues: string[];
    Type: EVA.Core.ShippingRestrictionType;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    /**
     * ID of the script that is associated with this shipping restriction.
     * Entity type: Script
     */
    ScriptID?: number;
    /**
     * Name of the script that is associated with this shipping restriction.
     */
    ScriptName?: string;
  }

  export interface GetAvailableRoles {
    /**
     * Entity type: User
     */
    UserID: number;
  }

  export interface GetAvailableRolesResponse {
    AvailableRoles: RoleDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface RoleDto {
    /**
     * Entity type: Role
     */
    ID: number;
    Name: string;
    UserType: EVA.Core.UserTypes;
    Code: string;
    /**
     * If this is set, any users that have not logged in after said days will get disabled
     */
    DeactivateUserAfterInactiveDays?: number;
    IsSystemDefined: boolean;
  }

  /**
   * Returns all available categories for functionalities
   */
  export interface GetFunctionalityCategories {
  }

  export interface GetFunctionalityCategoriesResponse {
    Categories: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GetSupportedFunctionalities {
    Category?: string;
  }

  export interface GetSupportedFunctionalitiesResponse {
    ScopedFunctionalities: GetSupportedFunctionalitiesResponse.FunctionalityDefinition[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetSupportedFunctionalitiesResponse {
    export interface FunctionalityDefinition {
      Name: string;
      Description: string;
      Unscoped: boolean;
      Categories: string[];
    }

  }

  /**
   * Fetch the current attached roles to an User in a specific OrganizationUnit
   */
  export interface GetUserRolesByUserID {
    /**
     * Entity type: User
     */
    UserID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetUserRolesByUserIDResponse {
    Result: GetUserRolesByUserIDResponse.UserRoleDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetUserRolesByUserIDResponse {
    export interface UserRoleDto {
      /**
       * Entity type: UserRole
       */
      ID: number;
      /**
       * Entity type: User
       */
      UserID: number;
      /**
       * Entity type: OrganizationUnitSet
       */
      OrganizationUnitSetID?: number;
      /**
       * Entity type: Role
       */
      RoleID: number;
      EndDate?: string;
      Role: RoleDto;
    }

  }

  /**
   * Return the current Roles for an User.
   */
  export interface GetUserRoles {
    /**
     * Entity type: User
     */
    UserID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export interface GetUserRolesResponse {
    Roles: UserRoleModel[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface UserRoleModel {
    /**
     * Entity type: Role
     */
    RoleID?: number;
    RoleName?: string;
    RoleCode?: string;
    EndDate?: string;
    UserType?: EVA.Core.UserTypes;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    OrganizationUnitSetName?: string;
    OrganizationUnitSetBackendID?: string;
  }

  /**
   * Lists organization units and roles for user
   */
  export interface ListUserOrganizationUnitRoles {
    /**
     * Entity type: User
     */
    UserID: number;
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListUserOrganizationUnitRolesFilter>;
  }

  export interface ListUserOrganizationUnitRolesResponse {
    Result?: EVA.Core.PagedResult<ListUserOrganizationUnitRolesResponse.OrganizationUnit>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListUserOrganizationUnitRolesResponse {
    export interface OrganizationUnit {
      ID: number;
      OrganizationUnitSetID: number;
      Name: string;
      Roles: OrganizationUnit.Role[];
    }

    export namespace OrganizationUnit {
      export interface Role {
        ID: number;
        Name: string;
        Code: string;
      }

    }

  }

  /**
   * Get role with its functionalities by it's ID.
   */
  export interface GetRole {
    /**
     * Entity type: Role
     */
    ID: number;
  }

  export interface GetRoleResponse {
    Result: RoleWithFunctionalitiesDto;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface RoleWithFunctionalitiesDto {
    /**
     * Entity type: Role
     */
    ID: number;
    Name: string;
    UserType: EVA.Core.UserTypes;
    Code: string;
    /**
     * If this is set, any users that have not logged in after said days will get disabled
     */
    DeactivateUserAfterInactiveDays?: number;
    IsSystemDefined: boolean;
    Functionalities: Record<'None' | 'Elevation' | 'Verification', { [key: string]: EVA.Core.FunctionalityScope }>;
  }

  /**
   * List all roles.
   */
  export interface ListRoles {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListRolesFilter>;
  }

  export interface ListRolesResponse {
    Result?: EVA.Core.PagedResult<RoleDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new role.
   */
  export interface CreateRole {
    Name: string;
    Code?: string;
    UserType?: EVA.Core.UserTypes;
    /**
     * If this is set, any users that have not logged in after said days will get disabled
     */
    DeactivateUserAfterInactiveDays?: number;
  }

  export interface CreateRoleResponse {
    /**
     * Entity type: Role
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update a role.
   */
  export interface UpdateRole {
    /**
     * Entity type: Role
     */
    ID: number;
    Name?: string;
    UserType?: EVA.Core.UserTypes;
    Code?: string;
    /**
     * If this is set, any users that have not logged in after said days will get disabled
     */
    DeactivateUserAfterInactiveDays?: number;
  }

  /**
   * Delete a role.
   */
  export interface DeleteRole {
    /**
     * Entity type: Role
     */
    ID: number;
  }

  /**
   * Update functionalities on a role.
   */
  export interface UpdateRoleFunctionalities {
    /**
     * Entity type: Role
     */
    RoleID: number;
    Functionalities: UpdateRoleFunctionalities.FunctionalityToUpdate[];
  }

  export namespace UpdateRoleFunctionalities {
    export interface FunctionalityToUpdate {
      Functionality: string;
      /**
       * Full list of scopes defined for this functionality - anything omitted will be deleted, submitting an empty object will remove the functionality for this role entirely.
       */
      Scopes: Record<'None' | 'Create' | 'Edit' | 'Delete' | 'View' | 'Manage' | 'Settings' | 'Scripting' | 'All', EVA.Core.ElevationType>;
    }

  }

  /**
   * List role functionalities.
   */
  export interface ListRoleFunctionalities {
    /**
     * Entity type: Role
     */
    RoleID: number;
    ShowAll?: boolean;
    PageConfig?: EVA.Core.PageConfig<ListRoleFunctionalitiesFilter>;
  }

  export interface ListRoleFunctionalitiesFilter {
    Functionality?: string;
  }

  export interface ListRoleFunctionalitiesResponse {
    Result?: EVA.Core.PagedResult<ListRoleFunctionalitiesItem>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListRoleFunctionalitiesItem {
    Name: string;
    Description: string;
    Categories: string[];
    Scopes: Record<'None' | 'Create' | 'Edit' | 'Delete' | 'View' | 'Manage' | 'Settings' | 'Scripting' | 'All', EVA.Core.ElevationType>;
  }

  export interface GetRoleSetByID {
    /**
     * Entity type: RoleSet
     */
    ID: number;
  }

  export interface GetRoleSetByIDResponse {
    /**
     * Entity type: RoleSet
     */
    ID: number;
    Name: string;
    BackendID?: string;
    Roles: RoleDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List role sets.
   */
  export interface ListRoleSets {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListRoleSetsFilter>;
  }

  export interface ListRoleSetsResponse {
    Result?: EVA.Core.PagedResult<ListRoleSetsResponse.RoleSetDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListRoleSetsResponse {
    export interface RoleSetDto {
      /**
       * Entity type: RoleSet
       */
      ID: number;
      Name: string;
      BackendID?: string;
    }

  }

  export interface CreateRoleSet {
    Name: string;
    BackendID?: string;
  }

  export interface CreateRoleSetResponse {
    /**
     * Entity type: RoleSet
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface UpdateRoleSet {
    /**
     * Entity type: RoleSet
     */
    ID: number;
    Name: string;
    BackendID?: string;
  }

  export interface DeleteRoleSet {
    /**
     * Entity type: RoleSet
     */
    ID: number;
  }

  export interface SetRolesForRoleSet {
    /**
     * Entity type: RoleSet
     */
    RoleSetID: number;
    /**
     * Entity type: Role
     */
    Roles?: number[];
  }

  export interface GetRolesForOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetRolesForOrganizationUnitResponse {
    Roles: RoleDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GetRolesForOrganizationUnitSet {
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Returns roles that are assignable for all organization units within the given `OrganizationUnitSetID`
     */
    AssignableOnly?: boolean;
  }

  export interface GetRolesForOrganizationUnitSetResponse {
    Roles: RoleDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update the Roles for an User. The roles provided will replace any existing roles on this user!
   * 
   * When an empty list is provided all roles will be removed.
   * 
   * The UserType defines as which UserType the User will act when logging in. For employees this wil normally be UserTypes.Employee (1)
   */
  export interface SetUserRoles {
    /**
     * Entity type: User
     */
    UserID: number;
    Roles: RoleOrganizationUnitSet[];
  }

  export interface RoleOrganizationUnitSet {
    /**
     * Entity type: Role
     */
    RoleID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * This will be mapped to the matching OrganizationUnitSet
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    EndDate?: string;
    UserType?: EVA.Core.UserTypes;
  }

  export interface UpdateUserRoles {
    /**
     * Entity type: User
     */
    UserID: number;
    Roles?: UpdateUserRoles.UpdateRole[];
  }

  export namespace UpdateUserRoles {
    export interface UpdateRole {
      /**
       * Entity type: Role
       */
      RoleID: number;
      /**
       * Entity type: OrganizationUnitSet
       */
      OrganizationUnitSetID?: number;
      IsRemoved: boolean;
      EndDate?: string;
      UserType?: EVA.Core.UserTypes;
    }

  }

  /**
   * This service creates a ProductSubscription for the given SubscriptionProductID.
   */
  export interface CreateProductSubscription {
    BackendID?: string;
    Name: string;
    Description?: string;
    Interval: EVA.Core.ProductSubscriptionInterval;
    IsActive?: boolean;
    ShowModal?: boolean;
    /**
     * Entity type: Product
     */
    TriggerProductIDs?: number[];
    /**
     * Entity type: Product
     */
    SubscriptionProductID: number;
  }

  export interface CreateProductSubscriptionResponse {
    /**
     * Entity type: ProductSubscription
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * This service is largely the same as CreateProductSubscription.
   */
  export interface UpdateProductSubscription {
    /**
     * Entity type: ProductSubscription
     */
    ID: number;
    BackendID?: string;
    Name?: string;
    Description?: string;
    IsActive?: boolean;
    ShowModal?: boolean;
    /**
     * Entity type: Product
     */
    TriggerProductIDs?: number[];
  }

  /**
   * Deletes a ProductSubscription.
   */
  export interface DeleteProductSubscription {
    /**
     * Entity type: ProductSubscription
     */
    ID: number;
  }

  /**
   * This service returns a paged summary of `ProductSubscriptions`, for each subscription it contains the `SubscriptionProduct` and the pricing information for the subscription.
   */
  export interface ListProductSubscriptions {
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListProductSubscriptionsFilter>;
    PageToken?: string;
  }

  export interface ListProductSubscriptionsResponse {
    Results?: ListProductSubscriptionsResponseResult[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListProductSubscriptionsResponseResult {
    /**
     * Entity type: ProductSubscription
     */
    ID: number;
    BackendID: string;
    Name: string;
    Description?: string;
    Interval: EVA.Core.ProductSubscriptionInterval;
    IsActive: boolean;
    ShowModal: boolean;
    /**
     * Entity type: Product
     */
    TriggerProductIDs: number[];
    SubscriptionProduct: EVA.Core.ProductSubscriptionProductInfo;
    SubscriptionPricing: EVA.Core.SubscriptionProductPriceInfo;
  }

  /**
   * This service is used to fetch a `ProductSubscription` by its ID.
   */
  export interface GetProductSubscription {
    /**
     * Entity type: ProductSubscription
     */
    ID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface GetProductSubscriptionResponse {
    /**
     * Entity type: ProductSubscription
     */
    ID: number;
    BackendID?: string;
    Name: string;
    Description?: string;
    Interval: EVA.Core.ProductSubscriptionInterval;
    IsActive: boolean;
    ShowModal: boolean;
    /**
     * Entity type: Product
     */
    TriggerProductIDs: number[];
    SubscriptionProduct: EVA.Core.ProductSubscriptionProductInfo;
    SubscriptionPricing: EVA.Core.SubscriptionProductPriceInfo;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Creates a barcode for a product for a specific unit of measure.
   * 
   * Optionally adds a record in the ProductUnitOfMeasure conversion table for the supplied Quantity.
   */
  export interface CreateProductBarcode {
    /**
     * Entity type: Product
     */
    ProductID: number;
    Barcode: string;
    /**
     * Entity type: UnitOfMeasure
     */
    UnitOfMeasureID: number;
    Name?: string;
    Quantity?: number;
  }

  /**
   * Delete a barcode from eva
   * 
   * When it's SupplierBarcode all matching barcodes will be removed
   */
  export interface DeleteProductBarcode {
    Barcode: string;
    /**
     * @default false
     */
    IsSupplierBarcode?: boolean;
  }

  /**
   * The page size `Limit` has a maximum value of `1.000` for this service.
   */
  export interface ListProductBarcodes {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListProductBarcodesFilter>;
  }

  export interface ListProductBarcodesResponse {
    Result?: EVA.Core.PagedResult<ListProductBarcodesResponse.ProductBarcodeDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListProductBarcodesResponse {
    export interface ProductBarcodeDto {
      ProductID: number;
      ProductCustomID: string;
      ProductBackendID: string;
      CatalogID?: number;
      Origin: EVA.Core.ProductBarcodeOrigin;
      Barcode: string;
      ProductDisplayValue: string;
      Quantity: number;
      Name: string;
      UnitOfMeasure: EVA.Core.EnumDto;
      IsSupplierProduct: boolean;
    }

  }

  /**
   * Get all available custom handler for ProductRequirements
   * 
   * These handlers are custom build to fetch values for ProductRequirements from external systems
   */
  export interface GetProductRequirementHandlers {
  }

  export interface GetProductRequirementHandlersResponse {
    Handlers: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get all info for a Product Requirement
   */
  export interface GetProductRequirementByID {
    /**
     * Entity type: ProductRequirement
     */
    ID: number;
  }

  export interface GetProductRequirementByIDResponse {
    /**
     * Entity type: ProductRequirement
     */
    ID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    Name: string;
    ProductName: string;
    DataType: EVA.Core.ProductRequirementDataTypes;
    BackendID?: string;
    Handler?: string;
    OrderType?: EVA.Core.OrderTypes;
    ProductBackendID?: string;
    ProductCustomID?: string;
    RequirementOptions?: EVA.Core.ProductRequirementOptions;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new Product Requirement
   */
  export interface CreateProductRequirement {
    /**
     * Entity type: Product
     */
    ProductID: number;
    Name: string;
    DataType: EVA.Core.ProductRequirementDataTypes;
    BackendID?: string;
    Handler?: string;
    OrderType?: EVA.Core.OrderTypes;
    RequirementOptions?: EVA.Core.ProductRequirementOptions;
  }

  export interface CreateProductRequirementResponse {
    /**
     * Entity type: ProductRequirement
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing Product Requirement
   */
  export interface UpdateProductRequirement {
    /**
     * Entity type: ProductRequirement
     */
    ID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    Name: string;
    DataType: EVA.Core.ProductRequirementDataTypes;
    BackendID?: string;
    Handler?: string;
    OrderType?: EVA.Core.OrderTypes;
    RequirementOptions?: EVA.Core.ProductRequirementOptions;
  }

  /**
   * Delete an existing Product Requirement
   */
  export interface DeleteProductRequirement {
    /**
     * Entity type: ProductRequirement
     */
    ID: number;
  }

  /**
   * List existing Product Requirements
   */
  export interface ListProductRequirements {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListProductRequirementsFilter>;
  }

  export interface ListProductRequirementsResponse {
    Result?: EVA.Core.PagedResult<ProductRequirementDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ProductRequirementDto {
    /**
     * Entity type: ProductRequirement
     */
    ID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    Name: string;
    ProductName: string;
    DataType: EVA.Core.ProductRequirementDataTypes;
    BackendID?: string;
    Handler?: string;
    OrderType?: EVA.Core.OrderTypes;
    ProductBackendID?: string;
    ProductCustomID?: string;
    RequirementOptions?: EVA.Core.ProductRequirementOptions;
  }

  /**
   * List the ProductSearchTemplates
   */
  export interface ListProductSearchTemplates {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ProductSearchTemplateFilters>;
  }

  export interface ListProductSearchTemplatesResponse {
    Result?: EVA.Core.PagedResult<ListProductSearchTemplatesResponse.ProductSearchDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListProductSearchTemplatesResponse {
    export interface ProductSearchDto {
      /**
       * Entity type: ProductSearchTemplate
       */
      ID: number;
      BackendID?: string;
      Name: string;
      /**
       * Entity type: Language
       */
      LanguageID: string;
      /**
       * Entity type: Country
       */
      CountryID: string;
      Filters: { [key: string]: EVA.Core.FilterModel };
      AggregationOptions?: { [key: string]: EVA.Core.AggregationFilterModel };
      Type: EVA.Core.ProductSearchTemplateTypes;
      MinimumRefreshInterval?: string;
      IncludeLeafProducts: boolean;
    }

  }

  /**
   * Create a new ProductSearchTemplate
   */
  export interface CreateProductSearchTemplate {
    BackendID?: string;
    Name: string;
    Filters: { [key: string]: EVA.Core.FilterModel };
    AggregationOptions?: { [key: string]: EVA.Core.AggregationFilterModel };
    Type: EVA.Core.ProductSearchTemplateTypes;
    MinimumRefreshInterval?: string;
    IncludeLeafProducts?: boolean;
  }

  export interface CreateProductSearchTemplateResponse {
    /**
     * Entity type: ProductSearchTemplate
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing ProductSearchTemplate
   */
  export interface UpdateProductSearchTemplate {
    /**
     * Entity type: ProductSearchTemplate
     */
    ID: number;
    BackendID?: string;
    Name?: string;
    Filters?: { [key: string]: EVA.Core.FilterModel };
    AggregationOptions?: { [key: string]: EVA.Core.AggregationFilterModel };
    Type?: EVA.Core.ProductSearchTemplateTypes;
    MinimumRefreshInterval?: string;
    IncludeLeafProducts?: boolean;
  }

  /**
   * Delete a ProductSearchTemplate
   */
  export interface DeleteProductSearchTemplate {
    /**
     * Entity type: ProductSearchTemplate
     */
    ID: number;
  }

  /**
   * Get an exisiting ProductSearchTemplate by ID
   */
  export interface GetProductSearchTemplateByID {
    /**
     * Entity type: ProductSearchTemplate
     */
    ID: number;
  }

  export interface GetProductSearchTemplateByIDResponse {
    BackendID?: string;
    Name: string;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    Filters: { [key: string]: EVA.Core.FilterModel };
    AggregationOptions?: { [key: string]: EVA.Core.AggregationFilterModel };
    Type: EVA.Core.ProductSearchTemplateTypes;
    MinimumRefreshInterval?: string;
    IncludeLeafProducts: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Returns the product count within the persisted product search template
   * When product id is given, it wil checks if a product is part of the persisted product search template result.
   * NOTE THAT after product search template creation/update if can take a few minutes for the result to be updated.
   */
  export interface CheckProductSearchTemplate {
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
  }

  export interface CheckProductSearchTemplateResponse {
    /**
     * Total count of products withing the product search template result.
     */
    ResultCount: number;
    /**
     * Will return true/false is the given product is present. If no product is given it will return null
     */
    IsPresent?: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the ProductUnitOfMeasures
   */
  export interface ListProductUnitOfMeasures {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListProductUnitOfMeasuresFilter>;
  }

  export interface ListProductUnitOfMeasuresResponse {
    Result?: EVA.Core.PagedResult<ListProductUnitOfMeasuresResponse.ProductUnitOfMeasureDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListProductUnitOfMeasuresResponse {
    export interface ProductUnitOfMeasureDto {
      ID: number;
      ProductID: number;
      ProductName: string;
      UnitOfMeasureID: number;
      UnitOfMeasure: EVA.Core.EnumDto;
      Quantity: number;
    }

  }

  /**
   * Create a new ProductUnitOfMeasure
   */
  export interface CreateProductUnitOfMeasure {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: UnitOfMeasure
     */
    UnitOfMeasureID: number;
    Quantity: number;
  }

  export interface CreateProductUnitOfMeasureResponse {
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing ProductUnitOfMeasure
   */
  export interface UpdateProductUnitOfMeasure {
    /**
     * Entity type: ProductUnitOfMeasure
     */
    ID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: UnitOfMeasure
     */
    UnitOfMeasureID: number;
    Quantity: number;
  }

  /**
   * Delete a ProductUnitOfMeasure
   */
  export interface DeleteProductUnitOfMeasure {
    /**
     * Entity type: ProductUnitOfMeasure
     */
    ID: number;
  }

  /**
   * List the SupplierProducts
   * 
   * `SupplierProduct`: an item that describes the giftcard properties of a product with type GiftCard
   */
  export interface ListSupplierProducts {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListSupplierProductsFilter>;
  }

  export interface ListSupplierProductsResponse {
    Result?: EVA.Core.PagedResult<ListSupplierProductsResponse.SupplierProductDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListSupplierProductsResponse {
    export interface SupplierProductDto {
      ID: number;
      BackendID: string;
      BrandName: string;
      PrimitiveName: string;
      Status: EVA.Core.ProductStatus;
      Description: string;
      PreferredMinimumOrderQuantity?: number;
      TaxCode: EVA.Core.EnumDto;
      QuantityOnHand: number;
      CostPrice?: number;
      RecommendedRecommendedRetailPrice?: number;
      CurrencyID: string;
    }

  }

  /**
   * Get a SupplierProduct by ID
   */
  export interface GetSupplierProductByID {
    /**
     * Entity type: Product
     */
    ID: number;
  }

  export interface GetSupplierProductByIDResponse {
    ID: number;
    BackendID: string;
    BrandName: string;
    PrimitiveName: string;
    Status: EVA.Core.ProductStatus;
    Description: string;
    PreferredMinimumOrderQuantity?: number;
    TaxCode: EVA.Core.EnumDto;
    QuantityOnHand: number;
    CostPrice?: number;
    RecommendedRecommendedRetailPrice?: number;
    CurrencyID: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new SupplierProduct
   */
  export interface CreateSupplierProduct {
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID: number;
    BackendID: string;
    BrandName?: string;
    PrimitiveName: string;
    Status: EVA.Core.ProductStatus;
    Description?: string;
    PreferredMinimumOrderQuantity?: number;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID: number;
  }

  export interface CreateSupplierProductResponse {
    /**
     * Entity type: Product
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing SupplierProduct
   */
  export interface UpdateSupplierProduct {
    /**
     * Entity type: Product
     */
    ID: number;
    BackendID: string;
    BrandName?: string;
    PrimitiveName: string;
    Status: EVA.Core.ProductStatus;
    Description?: string;
    PreferredMinimumOrderQuantity?: number;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID: number;
  }

  /**
   * Update the stock of a SupplierProduct, this is handled in the background
   */
  export interface UpdateSupplierProductStock {
    /**
     * Entity type: Product
     */
    ID: number;
    Quantity: number;
  }

  /**
   * Update the prices of a SupplierProduct, this is handled in the background
   */
  export interface UpdateSupplierProductPrices {
    /**
     * Entity type: Product
     */
    ID: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    UnitCost?: number;
    RecommendedRetailPrice?: number;
  }

  /**
   * Delete a SupplierProduct
   */
  export interface DeleteSupplierProduct {
    /**
     * Entity type: Product
     */
    ID: number;
  }

  /**
   * Retrieves the suppliers (Organization Units) for the given Product.
   */
  export interface GetSuppliersForProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
  }

  export interface GetSupplierForProductResponse {
    Result: GetSupplierForProductResponse.SupplierDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetSupplierForProductResponse {
    export interface SupplierDto {
      ID: number;
      Name: string;
      UnitCost: number;
      Stock: number;
    }

  }

  /**
   * Upload new products for a Supplier.
   * Fetch a sample with the `DownloadSupplierProductsSample`.
   * Fetch the current products with the `DownloadSupplierProducts`.
   */
  export interface UploadSupplierProducts {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    Data: string;
  }

  export interface UploadSupplierProductsResponse {
    TotalProductCount: number;
    FailedCount: number;
    Messages: { [key: string]: string };
    DeletedCount: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Upload new stock for the products of a Supplier.
   * Fetch a sample with the `DownloadSupplierProductsStockSample`.
   * Fetch the current stock with the `DownloadSupplierProductsStock`.
   */
  export interface UploadSupplierProductsStock {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    Data: string;
  }

  /**
   * Upload new prices for the products of a Supplier.
   * Fetch a sample with the `DownloadSupplierProductsPricingSample`.
   * Fetch the current prices with the `DownloadSupplierProductsPricing`.
   */
  export interface UploadSupplierProductsPricing {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    Data: string;
  }

  /**
   * Upload new barcodes for the products of a Supplier.
   * Fetch a sample with the `DownloadSupplierProductsBarcodesSample`.
   * Fetch the current prices with the `DownloadSupplierProductsBarcodes`.
   */
  export interface UploadSupplierProductsBarcodes {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    Data: string;
  }

  /**
   * Download a sample for the `UploadSupplierProducts`.
   */
  export interface DownloadSupplierProductsSample {
  }

  /**
   * Download a sample for the `UploadSupplierProductsStock`.
   */
  export interface DownloadSupplierProductsStockSample {
  }

  /**
   * Download a sample for the `UploadSupplierProductsPricing`.
   */
  export interface DownloadSupplierProductsPricingSample {
  }

  /**
   * Download a sample for the `UploadSupplierProductsBarcodes`.
   */
  export interface DownloadSupplierProductsBarcodesSample {
  }

  /**
   * Download the current supplier products.
   */
  export interface DownloadSupplierProducts {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  /**
   * Download the current stock for the supplier products.
   */
  export interface DownloadSupplierProductsStock {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  /**
   * Download the current prices for the supplier products in the given Currency.
   */
  export interface DownloadSupplierProductsPricing {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
  }

  /**
   * Download the current barcodes for the supplier products.
   */
  export interface DownloadSupplierProductsBarcodes {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  /**
   * List the UnitOfMeasures
   */
  export interface GetUnitOfMeasures {
  }

  export interface GetUnitOfMeasuresResponse {
    UnitOfMeasures: GetUnitOfMeasuresResponse.UnitOfMeasureDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetUnitOfMeasuresResponse {
    export interface UnitOfMeasureDto {
      BackendID: string;
      /**
       * Entity type: Enum
       */
      ID: number;
      /**
       * Usually an internal & unchangable code - for display, use `Description`
       */
      Name: string;
      Description: string;
    }

  }

  /**
   * Create a new UnitOfMeasure
   */
  export interface CreateUnitOfMeasure {
    Name: string;
    Description?: string;
    BackendID?: string;
  }

  export interface CreateUnitOfMeasureResponse {
    /**
     * Entity type: UnitOfMeasure
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing UnitOfMeasure
   */
  export interface UpdateUnitOfMeasure {
    /**
     * Entity type: UnitOfMeasure
     */
    ID: number;
    Name: string;
    Description?: string;
    BackendID?: string;
  }

  /**
   * Delete a UnitOfMeasure
   */
  export interface DeleteUnitOfMeasure {
    /**
     * Entity type: UnitOfMeasure
     */
    ID: number;
  }

  /**
   * Creates a printer type
   */
  export interface CreatePrinterType {
    /**
     * Name of the type
     */
    Name: string;
    /**
     * Description of the type
     */
    Description?: string;
    PaperWidth: number;
  }

  export interface CreatePrinterTypeResponse {
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Deletes a printer type
   */
  export interface DeletePrinterType {
    /**
     * Entity type: PrinterType
     */
    ID: number;
  }

  /**
   * Gets a printer type
   */
  export interface GetPrinterTypeByID {
    /**
     * Entity type: PrinterType
     */
    ID: number;
  }

  export interface GetPrinterTypeByIDResponse {
    ID: number;
    Name: string;
    Description?: string;
    PaperWidth: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Gets all printer types
   */
  export interface GetPrinterTypes {
  }

  export interface GetPrinterTypesResponse {
    PrinterTypes: GetPrinterTypesResponse.PrinterTypeModel[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetPrinterTypesResponse {
    export interface PrinterTypeModel {
      ID: number;
      Name: string;
      Description?: string;
      PaperWidth: number;
    }

  }

  /**
   * Updates a printer type
   */
  export interface UpdatePrinterType {
    /**
     * Entity type: PrinterType
     */
    ID: number;
    Name: string;
    Description?: string;
    PaperWidth: number;
  }

  /**
   * Retrieve a list of OrganizationUnit PriceLists
   * 
   * It's required to set the OrganizationUnitID filter
   */
  export interface ListPriceListsForOrganizationUnit {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListPriceListsForOrganizationUnitFilter>;
  }

  export interface ListPriceListsForOrganizationUnitResponse {
    Result?: EVA.Core.PagedResult<ListPriceListsForOrganizationUnitResponse.PriceListDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPriceListsForOrganizationUnitResponse {
    export interface PriceListDto {
      /**
       * Entity type: PriceList
       */
      PriceListID: number;
      Name: string;
      BackendID: string;
      /**
       * Entity type: Currency
       */
      CurrencyID: string;
      IsActive: boolean;
      IsFinalSalePriceList: boolean;
      IncludingVat: boolean;
      /**
       * Entity type: PriceListUsageType
       */
      PriceListUsageTypeID: number;
      PriceListUsageTypeName: string;
      PricingGroupID?: string;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      OrganizationUnitName: string;
      OrganizationUnitBackendID: string;
      /**
       * Entity type: OrganizationUnit
       */
      InheritedFromOrganizationUnitID?: number;
      InheritedFromOrganizationUnitName?: string;
      InheritedFromOrganizationUnitBackendID?: string;
      /**
       * Entity type: OrganizationUnit
       */
      TargetOrganizationUnitID?: number;
      TargetOrganizationUnitName?: string;
      TargetOrganizationUnitBackendID?: string;
    }

  }

  /**
   * List the pricechanges
   * 
   * It is required to supply some OrganizationUnitIDs or some ProductIDs in the PageConfig filter.
   */
  export interface ListProductPriceLedger {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListProductPriceLedgerFilter>;
  }

  export interface ListProductPriceLedgerResponse {
    Result?: EVA.Core.PagedResult<ListProductPriceLedgerResponse.OrganizationUnitPriceChange>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListProductPriceLedgerResponse {
    export interface OrganizationUnitPriceChange {
      ProductID: number;
      PriceListID: number;
      PriceListUsageTypeID: number;
      PriceListUsageTypeName: string;
      OrganizationUnitID: number;
      OrganizationUnitName: string;
      OldPrice?: number;
      NewPrice?: number;
      CreationTime: string;
      CurrencyID: string;
    }

  }

  /**
   * Given the data on how rounding should be applied this service will perform the rounding on the given example prices to preview what the rounding would look like.
   */
  export interface PreviewPriceListRoundingAdjustment {
    ExamplePrices?: number[];
    Data?: EVA.Core.RoundingData;
  }

  export interface PreviewPriceListRoundingAdjustmentResponse {
    Results: PreviewPriceListRoundingAdjustmentResponse.RoundingResult[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace PreviewPriceListRoundingAdjustmentResponse {
    export interface RoundingResult {
      InputPrice?: number;
      OutputPrice?: number;
    }

  }

  /**
   * Get a PriceListAdjustment
   */
  export interface GetPriceListAdjustmentByID {
    /**
     * Entity type: PriceListAdjustment
     */
    ID: number;
  }

  export interface GetPriceListAdjustmentByIDResponse {
    /**
     * Entity type: PriceListAdjustment
     */
    ID: number;
    BackendID?: string;
    /**
     * Entity type: PriceList
     */
    PriceListID: number;
    PriceList: GetPriceListAdjustmentByIDResponse.PriceListDto;
    /**
     * Entity type: PriceListAdjustment
     */
    ParentAdjustmentID?: number;
    ParentAdjustmentName?: string;
    Sequence: number;
    Name: string;
    EffectiveDate: string;
    ExpireDate?: string;
    OverridePrice: boolean;
    Type: string;
    Data?: { [key: string]: any };
    /**
     * Entity type: PriceListAdjustmentLabel
     */
    LabelID?: number;
    Label?: string;
    PricingGroupID?: string;
    SystemType: EVA.Core.PriceListAdjustmentSystemType;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetPriceListAdjustmentByIDResponse {
    export interface PriceListDto {
      Name: string;
      CurrencyID: string;
      TimeZone: string;
    }

  }

  /**
   * Create a new PriceListAdjustment
   */
  export interface CreatePriceListAdjustment {
    /**
     * Entity type: PriceList
     */
    PriceListID: number;
    BackendID?: string;
    /**
     * Entity type: PriceListAdjustment
     */
    ParentAdjustmentID?: number;
    Sequence: number;
    Name: string;
    Label?: string;
    EffectiveDate: string;
    ExpireDate?: string;
    OverridePrice?: boolean;
    Type: string;
    Data?: { [key: string]: any };
    PricingGroupID?: string;
    /**
     * If set to true, this will skip the recalculation of the price list after the adjustment is updated, defaults to false so it will always recalculate. Recalculation happens periodically thereafter.
     */
    SkipRecalculation?: boolean;
  }

  export interface CreatePriceListAdjustmentResponse {
    /**
     * Entity type: PriceListAdjustment
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing PriceListAdjustment
   */
  export interface UpdatePriceListAdjustment {
    /**
     * Entity type: PriceListAdjustment
     */
    ID: number;
    /**
     * Entity type: PriceListAdjustment
     */
    ParentAdjustmentID?: number;
    BackendID?: string;
    Sequence: number;
    Name: string;
    Label?: string;
    EffectiveDate: string;
    ExpireDate?: string;
    OverridePrice?: boolean;
    Type: string;
    Data?: { [key: string]: any };
    PricingGroupID?: string;
    /**
     * If set to true, this will skip the recalculation of the price list after the adjustment is updated, defaults to false so it will always recalculate. Recalculation happens periodically thereafter.
     */
    SkipRecalculation?: boolean;
  }

  /**
   * Delete an existing PriceListAdjustment
   */
  export interface DeletePriceListAdjustment {
    /**
     * Entity type: PriceListAdjustment
     */
    ID: number;
    /**
     * If set to true, this will skip the recalculation of the price list after the adjustment is updated, defaults to false so it will always recalculate. Recalculation happens periodically thereafter.
     */
    SkipRecalculation?: boolean;
  }

  /**
   * List the PriceListAdjustments
   */
  export interface ListPriceListAdjustments {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListPriceListAdjustmentsFilter>;
  }

  export interface ListPriceListAdjustmentsResponse {
    Result?: EVA.Core.PagedResult<ListPriceListAdjustmentsResponse.PriceListAdjustmentDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPriceListAdjustmentsResponse {
    export interface PriceListAdjustmentDto {
      /**
       * Entity type: PriceListAdjustment
       */
      ID: number;
      BackendID?: string;
      /**
       * Entity type: PriceList
       */
      PriceListID: number;
      PriceList: PriceListAdjustmentDto.PriceListDto;
      /**
       * Entity type: PriceListAdjustment
       */
      ParentAdjustmentID?: number;
      ParentAdjustmentName?: string;
      Sequence: number;
      Name: string;
      Label?: string;
      EffectiveDate: string;
      ExpireDate?: string;
      OverridePrice: boolean;
      Type: string;
      Data?: { [key: string]: any };
      PricingGroupID?: string;
      SystemType: EVA.Core.PriceListAdjustmentSystemType;
    }

    export namespace PriceListAdjustmentDto {
      export interface PriceListDto {
        Name: string;
        CurrencyID: string;
        TimeZone: string;
      }

    }

  }

  /**
   * Get a PriceList
   * 
   * A PriceList has a TimeZone, this TimeZone should be used to Display certain DateTime's on the frontend.
   * For these specific fields the TimeZone of the user should be ignored and instead the one on the PriceList should be used.
   */
  export interface GetPriceListByID {
    /**
     * Entity type: PriceList
     */
    ID: number;
  }

  export interface GetPriceListByIDResponse {
    /**
     * Entity type: PriceList
     */
    ID: number;
    Name: string;
    BackendID?: string;
    BackendSystemID?: string;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    TimeZone: string;
    IncludingVat: boolean;
    IsActive: boolean;
    IsFinalSalePriceList: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface PriceListDto {
    /**
     * Entity type: PriceList
     */
    ID: number;
    Name: string;
    BackendID?: string;
    BackendSystemID?: string;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    TimeZone: string;
    IncludingVat: boolean;
    IsActive: boolean;
    IsFinalSalePriceList: boolean;
    /**
     * Indicates if the user can view the pricelist details. This is the case when:
     * - User has 'CanViewCostPrices' AND 'CanViewPurchasePrices' functionality
     * OR
     * - User has access to an organization unit
     */
    CanViewPriceList: boolean;
  }

  /**
   * Create a new PriceList
   */
  export interface CreatePriceList {
    Name: string;
    BackendID?: string;
    BackendSystemID?: string;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    TimeZone?: string;
    IncludingVat?: boolean;
    IsActive?: boolean;
    IsFinalSalePriceList?: boolean;
  }

  export interface CreatePriceListResponse {
    /**
     * Entity type: PriceList
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing PriceList
   */
  export interface UpdatePriceList {
    /**
     * Entity type: PriceList
     */
    ID: number;
    Name?: string;
    BackendID?: string;
    BackendSystemID?: string;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    TimeZone?: string;
    IncludingVat?: boolean;
    IsActive?: boolean;
    IsFinalSalePriceList?: boolean;
  }

  /**
   * Delete a PriceList
   */
  export interface DeletePriceList {
    /**
     * Entity type: PriceList
     */
    ID: number;
  }

  /**
   * List PriceLists
   */
  export interface ListPriceLists {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListPriceListsFilter>;
  }

  export interface ListPriceListsResponse {
    Result?: EVA.Core.PagedResult<PriceListDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get a PriceListManualInputAdjustment by ID
   */
  export interface GetPriceListManualInputAdjustmentByID {
    /**
     * Entity type: PriceListManualInputAdjustment
     */
    ID: number;
  }

  export interface GetPriceListManualInputAdjustmentByIDResponse {
    /**
     * Entity type: PriceListManualInputAdjustment
     */
    ID: number;
    /**
     * Entity type: PriceListAdjustment
     */
    PriceListAdjustmentID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    ProductName: string;
    ProductCustomID: string;
    ProductBackendID: string;
    Value: number;
    EffectiveDate: string;
    ExpireDate?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new PriceListManualInputAdjustment
   */
  export interface CreatePriceListManualInputAdjustment {
    /**
     * Entity type: PriceListAdjustment
     */
    PriceListAdjustmentID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    Value: number;
    EffectiveDate: string;
    ExpireDate?: string;
  }

  export interface CreatePriceListManualInputAdjustmentResponse {
    /**
     * Entity type: PriceListManualInputAdjustment
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing new PriceListManualInputAdjustment
   */
  export interface UpdatePriceListManualInputAdjustment {
    /**
     * Entity type: PriceListManualInputAdjustment
     */
    ID: number;
    Value: number;
    EffectiveDate: string;
    ExpireDate?: string;
  }

  /**
   * Delete a PriceListManualInputAdjustment
   */
  export interface DeletePriceListManualInputAdjustment {
    /**
     * Entity type: PriceListManualInputAdjustment
     */
    ID: number;
  }

  /**
   * List the PriceListManualInputAdjustments, it is required to supply at least an PriceListAdjustmentID in the Filter
   */
  export interface ListPriceListManualInputAdjustments {
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProductProperties?: string[];
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListManualInputAdjustmentsFilter>;
  }

  export interface ListPriceListManualInputAdjustmentsResponse {
    Result?: EVA.Core.PagedResult<ListPriceListManualInputAdjustmentsResponse.PriceListManualInputAdjustmentDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPriceListManualInputAdjustmentsResponse {
    export interface PriceListManualInputAdjustmentDto {
      /**
       * Entity type: PriceListManualInputAdjustment
       */
      ID: number;
      /**
       * Entity type: Product
       */
      ProductID: number;
      ProductName: string;
      ProductCustomID: string;
      ProductBackendID: string;
      Product?: any;
      Value: number;
      EffectiveDate: string;
      ExpireDate?: string;
    }

  }

  /**
   * Generate an excel file containing all ManualInputPridceListAdjustments for the given PriceListAdjustment.
   */
  export interface DownloadPriceListManualInputAdjustments {
    /**
     * Entity type: PriceListAdjustment
     */
    PriceListAdjustmentID: number;
  }

  /**
   * Generate an excel sample file containing all ManualInputPridceListAdjustments for the given PriceListAdjustment.
   */
  export interface DownloadPriceListManualInputAdjustmentsSample {
  }

  /**
   * Upload an excel file containing all ManualInputPriceListAdjustments for the given PriceListAdjustment. These will replace all exisiting adjustments.
   */
  export interface UploadPriceListManualInputAdjustments {
    /**
     * Entity type: PriceListAdjustment
     */
    PriceListAdjustmentID: number;
    Data: string;
    ProcessAsync?: boolean;
  }

  export interface UploadPriceListManualInputAdjustmentsResponse {
    IsProcessedAsync: boolean;
    Messages: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get an existing PriceListOrganizationUnit
   */
  export interface GetPriceListOrganizationUnitByID {
    /**
     * Entity type: PriceListOrganizationUnit
     */
    ID: number;
  }

  export interface GetPriceListOrganizationUnitByIDResponse {
    ID: number;
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    /**
     * Entity type: OrganizationUnit
     */
    TargetOrganizationUnitID?: number;
    TargetOrganizationUnitName?: string;
    PriceListID: number;
    PriceList: GetPriceListOrganizationUnitByIDResponse.PriceListDto;
    PriceListUsageTypeID: number;
    PriceListUsageTypeName: string;
    PricingGroupID: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetPriceListOrganizationUnitByIDResponse {
    export interface PriceListDto {
      Name: string;
      CurrencyID: string;
    }

  }

  /**
   * Create a new PriceListOrganizationUnit
   */
  export interface CreatePriceListOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    TargetOrganizationUnitID?: number;
    /**
     * Entity type: PriceList
     */
    PriceListID?: number;
    /**
     * Entity type: PriceListUsageType
     */
    PriceListUsageTypeID?: number;
    PricingGroupID?: string;
  }

  export interface CreatePriceListOrganizationUnitResponse {
    /**
     * Entity type: PriceListOrganizationUnit
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing PriceListOrganizationUnit
   */
  export interface UpdatePriceListOrganizationUnit {
    /**
     * Entity type: PriceListOrganizationUnit
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: OrganizationUnit
     */
    TargetOrganizationUnitID?: number;
    /**
     * Entity type: PriceList
     */
    PriceListID: number;
    /**
     * Entity type: PriceListUsageType
     */
    PriceListUsageTypeID: number;
    PricingGroupID?: string;
  }

  /**
   * Delete a PriceListOrganizationUnit
   */
  export interface DeletePriceListOrganizationUnit {
    /**
     * Entity type: PriceListOrganizationUnit
     */
    ID: number;
  }

  /**
   * List the PriceListOrganizationUnits
   */
  export interface ListPriceListOrganizationUnits {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListPriceListOrganizationUnitsFilter>;
  }

  export interface ListPriceListOrganizationUnitsResponse {
    Result?: EVA.Core.PagedResult<ListPriceListOrganizationUnitsResponse.PriceListOrganizationUnitDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPriceListOrganizationUnitsResponse {
    export interface PriceListOrganizationUnitDto {
      /**
       * Entity type: PriceListOrganizationUnit
       */
      ID: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      OrganizationUnitName: string;
      /**
       * Entity type: OrganizationUnit
       */
      TargetOrganizationUnitID?: number;
      TargetOrganizationUnitName?: string;
      /**
       * Entity type: PriceList
       */
      PriceListID: number;
      PriceList: PriceListOrganizationUnitDto.PriceListDto;
      /**
       * Entity type: PriceListUsageType
       */
      PriceListUsageTypeID: number;
      PriceListUsageTypeName: string;
      PricingGroupID: string;
    }

    export namespace PriceListOrganizationUnitDto {
      export interface PriceListDto {
        Name: string;
        CurrencyID: string;
      }

    }

  }

  export interface GetPriceListUsageTypeByID {
    /**
     * Entity type: PriceListUsageType
     */
    ID: number;
  }

  export interface GetPriceListUsageTypeByIDResponse {
    ID: number;
    Name: string;
    Description: string;
    RequiredUserType: EVA.Core.UserTypes;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface CreatePriceListUsageType {
    Name: string;
    Description?: string;
    RequiredUserType: EVA.Core.UserTypes;
  }

  export interface CreatePriceListUsageTypeResponse {
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface UpdatePriceListUsageType {
    /**
     * Entity type: PriceListUsageType
     */
    ID: number;
    Description?: string;
    RequiredUserType: EVA.Core.UserTypes;
  }

  export interface DeletePriceListUsageType {
    /**
     * Entity type: PriceListUsageType
     */
    ID: number;
  }

  export interface GetPriceListUsageTypes {
  }

  export interface GetPriceListUsageTypesResponse {
    PriceListUsageTypes: GetPriceListUsageTypesResponse.PriceListUsageTypeDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetPriceListUsageTypesResponse {
    export interface PriceListUsageTypeDto {
      ID: number;
      Name: string;
      Description: string;
      RequiredUserType: EVA.Core.UserTypes;
    }

  }

  /**
   * List personalized promotions. Returns a paged response.
   */
  export interface ListPersonalizedPromotions {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListPersonalizedPromotionsFilter>;
    PageToken?: string;
  }

  export interface ListPersonalizedPromotionsResponse {
    Results?: ListPersonalizedPromotionsResponse.PersonalizedPromotion[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPersonalizedPromotionsResponse {
    export interface PersonalizedPromotion {
      /**
       * Entity type: PersonalizedPromotion
       */
      ID: number;
      Name: string;
      Description: string;
      BackendID: string;
      LockAfterFirstApply: boolean;
      MaximumDistinctProducts?: number;
    }

  }

  /**
   * Get personalized promotion by its ID.
   */
  export interface GetPersonalizedPromotionByID {
    /**
     * Entity type: PersonalizedPromotion
     */
    ID: number;
  }

  export interface GetPersonalizedPromotionByIDResponse {
    /**
     * Entity type: PersonalizedPromotion
     */
    ID: number;
    Name: string;
    Description: string;
    BackendID: string;
    LockAfterFirstApply: boolean;
    MaximumDistinctProducts?: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new personalized promotion.
   */
  export interface CreatePersonalizedPromotion {
    Name: string;
    Description?: string;
    BackendID?: string;
    LockAfterFirstApply?: boolean;
    MaximumDistinctProducts?: number;
  }

  export interface CreatePersonalizedPromotionResponse {
    /**
     * Entity type: PersonalizedPromotion
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing personalized promotion.
   */
  export interface UpdatePersonalizedPromotion {
    /**
     * Entity type: PersonalizedPromotion
     */
    ID: number;
    Name?: string;
    Description?: string;
    BackendID?: string;
    LockAfterFirstApply?: boolean;
    MaximumDistinctProducts?: number;
  }

  /**
   * Archive a personalized promotion.
   */
  export interface ArchivePersonalizedPromotion {
    /**
     * Entity type: PersonalizedPromotion
     */
    ID: number;
  }

  /**
   * Add personalized promotion products for a user.
   */
  export interface AddPersonalizedPromotionsProducts {
    /**
     * Entity type: PersonalizedPromotion
     */
    PersonalizedPromotionID: number;
    /**
     * Entity type: User
     */
    UserID: number;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
  }

  /**
   * Remove personalized promotion products attached to a user. Either ProductIDs or RemoveAll is required.
   */
  export interface RemovePersonalizedPromotionProducts {
    /**
     * Entity type: PersonalizedPromotion
     */
    PersonalizedPromotionID?: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    RemoveAll?: boolean;
  }

  /**
   * Set products for personalized promotion for the given user. Overwrites existing products and product selection. Will unset products and selection when no products are provided.
   */
  export interface PushUserPersonalizedPromotionProducts {
    UserID: string;
    PersonalizedPromotionID: string;
    /**
     * The products that the user has in this PersonalizedPromotion. Can have a maximum of 100 products.
     */
    Products?: PushUserPersonalizedPromotionProducts.PushPersonalizedPromotionProduct[];
    /**
     * When set to true, products that couldn't be resolved will be skipped. When false request will fail when a product couldn't be resolved.
     */
    SkipUnresolvedProducts?: boolean;
  }

  export namespace PushUserPersonalizedPromotionProducts {
    export interface PushPersonalizedPromotionProduct {
      ProductID: string;
      Selected: boolean;
    }

  }

  /**
   * Delete a failed or unprocessed settlement file
   * 
   * File in state processing or processed can't be deleted due to generated financial events. This is only allowed when no settlents were generated for the file.
   */
  export interface DeleteUnprocessedPaymentSettlementFile {
    /**
     * Entity type: PaymentTransactionSettlementFile
     */
    PaymentSettlementFileID: number;
  }

  /**
   * Download a settlement result file
   */
  export interface DownloadPaymentSettlementFileResult {
    /**
     * Entity type: PaymentTransactionSettlementFile
     */
    PaymentSettlementFileID: number;
  }

  /**
   * Returns the available handlers for settlement files
   */
  export interface GetAvailablePaymentSettlementFileHandlers {
  }

  export interface GetAvailablePaymentSettlementFileHandlersResponse {
    Handlers: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List uploaded settlement files
   * 
   * Filters available:
   * - Name
   * - Status
   * - Handler
   */
  export interface ListPaymentSettlementFiles {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListSettlementFilesFilter>;
  }

  export interface ListPaymentSettlementFilesResponse {
    Result?: EVA.Core.PagedResult<ListPaymentSettlementFilesResponse.PaymentSettlementFile>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPaymentSettlementFilesResponse {
    export interface PaymentSettlementFile {
      /**
       * Entity type: PaymentTransactionSettlementFile
       */
      ID: number;
      Name: string;
      OriginalBlobID: string;
      OriginalDownloadUrl: string;
      Status: EVA.Core.PaymentTransactionSettlementFileStatus;
      /**
       * Entity type: OrganizationUnit
       */
      FallbackOrganizationUnitID: number;
      FallbackOrganizationUnitName: string;
      Handler: string;
    }

  }

  /**
   * List created settlements
   * 
   * Filters available:
   * - PaymentTransactionID
   * - TypeID
   * - FinancialPeriodID
   * - OrganizationUnitID
   */
  export interface ListPaymentSettlements {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListSettlementsFilter>;
  }

  export interface ListPaymentSettlementsResponse {
    Result?: EVA.Core.PagedResult<ListPaymentSettlementsResponse.PaymentSettlement>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPaymentSettlementsResponse {
    export interface PaymentSettlement {
      /**
       * Entity type: PaymentTransactionSettlement
       */
      ID: number;
      /**
       * Entity type: PaymentTransaction
       */
      PaymentTransactionID?: number;
      /**
       * Entity type: FinancialPeriod
       */
      FinancialPeriodID: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      OrganizationUnitName: string;
      /**
       * Entity type: PaymentTransactionSettlementType
       */
      TypeID: number;
      TypeName: string;
      Amount: number;
      CurrencyID: string;
      LedgerClassID?: string;
      Offset1?: string;
      Offset2?: string;
      Offset3?: string;
      Offset4?: string;
    }

  }

  /**
   * Upload a new settlement file.
   * 
   * - The settlements in the file will be imported and booked into financial events to allow processing in cookbook
   * - It is required to supply the `Handler` to use (available handlers can be fetched with the `GetAvailablePaymentSettlementFileHandlers` service)
   * - For settlement records that don't have a matching `PaymentTransaction` in EVA there will be financial events generated (which will happen for supplied `OrganizationUnitID`)
   */
  export interface UploadPaymentSettlementFile {
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrl?: string;
    Name?: string;
    Handler?: string;
    /**
     * The OrganizationUnit that will be used to book the Settlements for payments that are not known in EVA.
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  /**
   * Return all PaymentMethods
   */
  export interface GetPaymentMethods {
  }

  export interface GetPaymentMethodsResponse {
    PaymentMethods: GetPaymentMethodsResponse.PaymentMethodDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetPaymentMethodsResponse {
    export interface PaymentMethodDto {
      /**
       * Entity type: PaymentMethod
       */
      ID: number;
      Name: string;
      Code: string;
    }

  }

  /**
   * List paymenttransactionCaptures
   * 
   * All available filters are typed in the PageConfig.Filter property.
   */
  export interface ListPaymentTransactionCaptures {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListPaymentTransactionCapturesFilter>;
  }

  export interface ListPaymentTransactionCapturesResponse {
    Result?: EVA.Core.PagedResult<ListPaymentTransactionCapturesResponse.PaymentTransactionCaptureDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPaymentTransactionCapturesResponse {
    export interface PaymentTransactionCaptureDto {
      /**
       * Entity type: PaymentTransactionCapture
       */
      ID: number;
      /**
       * Entity type: PaymentTransaction
       */
      PaymentTransactionID: number;
      /**
       * Entity type: Order
       */
      OrderID?: number;
      BackendID?: string;
      Status: EVA.Core.PaymentTransactionCaptureStatuses;
      Amount: number;
      ConfirmationDate?: string;
      /**
       * Entity type: Currency
       */
      CurrencyID: string;
      SettledAmount?: number;
      IsSettled?: boolean;
      CreationTime: string;
    }

  }

  /**
   * List paymenttransactions.
   */
  export interface ListPaymentTransactions {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListPaymentTransactionsFilter>;
  }

  export interface ListPaymentTransactionsResponse {
    Result?: EVA.Core.PagedResult<ListPaymentTransactionsResponse.PaymentTransactionDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPaymentTransactionsResponse {
    export interface PaymentTransactionDto {
      /**
       * Entity type: PaymentTransaction
       */
      ID: number;
      /**
       * Entity type: PaymentType
       */
      TypeID: number;
      /**
       * Entity type: PaymentMethod
       */
      PaymentMethodID?: number;
      /**
       * Entity type: Order
       */
      OrderID?: number;
      /**
       * Entity type: Device
       */
      DeviceID?: number;
      /**
       * Entity type: FinancialPeriod
       */
      FinancialPeriodID?: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      /**
       * Entity type: Currency
       */
      CurrencyID: string;
      TypeName: string;
      PaymentMethodName: string;
      OrderDisplayID?: string;
      BackendID: string;
      BackendSystemID: string;
      Status: EVA.Core.PaymentStatuses;
      Amount: number;
      PaidAmount: number;
      Change: number;
      PaymentDate?: string;
      OrganizationUnitName: string;
      RefundedAmount?: number;
      BackendRelationID?: string;
      Description?: string;
      SettledAmount?: number;
      CreationTime: string;
      LastModificationTime?: string;
      IsSettled?: boolean;
    }

  }

  /**
   * Create or update OrganizationUnitSetPaymentType
   * 
   * A PaymentType, OrganizationUnitSet and RefundPriority are required
   * 
   * When this OrganizationUnitSet doesn't have this PaymentType yet, it will be created. If it already exists the fields will be updated.
   */
  export interface CreateOrUpdateOrganizationUnitSetPaymentType {
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    RefundPriority?: number;
    DisplayPriority?: number;
    CaptureMoment?: EVA.Core.PaymentTypeCaptureMoment;
    AuthorizationExpirationInDays?: number;
    /**
     * Entity type: Product
     */
    DigitalGiftCardProductID?: number;
    DisableForCarryOutOrders?: boolean;
    DisableForReserveOrders?: boolean;
    DisableForDeliveryOrders?: boolean;
  }

  /**
   * Delete an OrganizationUnitSetPaymentType
   * 
   * A PaymentType and OrganizationUnitSet are required
   */
  export interface DeleteOrganizationUnitSetPaymentType {
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
  }

  /**
   * List the OrganizationUnitSetPaymentTypes
   * 
   * There are filters available on:
   *  - PaymentTypeID
   *  - OrganizationUnitSetID
   *  - RefundPriority
   *  - CaptureMoment
   *  - DisableForDeliveryOrders
   *  - DisableForReserveOrders
   *  - DisableForCarryOutOrders
   */
  export interface ListOrganizationUnitSetPaymentTypes {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListOrganizationUnitSetPaymentTypesFilter>;
  }

  export interface ListOrganizationUnitSetPaymentTypesResponse {
    Result?: EVA.Core.PagedResult<OrganizationUnitSetPaymentTypeDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface OrganizationUnitSetPaymentTypeDto {
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID: number;
    PaymentTypeName: string;
    /**
     * Entity type: PaymentMethod
     */
    PaymentMethodID: number;
    PaymentMethodName: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    OrganizationUnitSetName: string;
    RefundPriority?: number;
    DisplayPriority: number;
    CaptureMoment?: EVA.Core.PaymentTypeCaptureMoment;
    AuthorizationExpirationInDays?: number;
    /**
     * Entity type: Product
     */
    DigitalGiftCardProductID?: number;
    DisableForCarryOutOrders?: boolean;
    DisableForReserveOrders?: boolean;
    DisableForDeliveryOrders?: boolean;
  }

  /**
   * Gets an PaymentMethod by its ID and returns the basic information.
   */
  export interface GetPaymentMethodByID {
    /**
     * Entity type: PaymentMethod
     */
    ID: number;
  }

  export interface GetPaymentMethodByIDResponse {
    /**
     * Entity type: PaymentMethod
     */
    ID: number;
    Name: string;
    Code: string;
    IsCustom: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new custom PaymentMethod.
   */
  export interface CreatePaymentMethod {
    Name: string;
    Code: string;
  }

  export interface CreatePaymentMethodResponse {
    /**
     * Entity type: PaymentMethod
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing custom PaymentMethod.
   */
  export interface UpdatePaymentMethod {
    /**
     * Entity type: PaymentMethod
     */
    ID: number;
    Name: string;
    Code: string;
  }

  /**
   * Delete a PaymentMethod
   */
  export interface DeletePaymentMethod {
    /**
     * Entity type: PaymentMethod
     */
    ID: number;
  }

  /**
   * List PaymentMethods. Returns a paged response.
   */
  export interface ListPaymentMethods {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListPaymentMethodsFilter>;
  }

  export interface ListPaymentMethodsResponse {
    Result?: EVA.Core.PagedResult<ListPaymentMethodsResponse.PaymentMethodDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPaymentMethodsResponse {
    export interface PaymentMethodDto {
      /**
       * Entity type: PaymentMethod
       */
      ID: number;
      Name: string;
      Code: string;
      IsCustom: boolean;
    }

  }

  /**
   * Create a new PaymentTransactionLedgerType
   */
  export interface CreatePaymentTransactionLedgerType {
    Name: string;
    Description?: string;
  }

  export interface CreatePaymentTransactionLedgerTypeResponse {
    /**
     * Entity type: PaymentTransactionLedgerType
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update the description of a PaymentTransactionLedgerType. Only custom made types can be updated.
   */
  export interface UpdatePaymentTransactionLedgerType {
    /**
     * Entity type: PaymentTransactionLedgerType
     */
    ID: number;
    Description?: string;
  }

  /**
   * Delete a PaymentTransactionLedgerType. Only custom made types can be deleted that are not in use.
   */
  export interface DeletePaymentTransactionLedgerType {
    /**
     * Entity type: PaymentTransactionLedgerType
     */
    ID: number;
  }

  /**
   * Gets an PaymentType by its ID and returns the basic information.
   */
  export interface GetPaymentTypeByID {
    /**
     * Entity type: PaymentType
     */
    ID: number;
  }

  export interface GetPaymentTypeByIDResponse {
    /**
     * Entity type: PaymentType
     */
    ID: number;
    /**
     * Entity type: PaymentMethod
     */
    PaymentMethodID: number;
    /**
     * Entity type: LedgerClass
     */
    LedgerClassID: string;
    PaymentMethodName: string;
    PaymentMethodCode: string;
    PaymentMethodIsCustom: boolean;
    OrganizationUnitSetName: string;
    OrganizationUnitSetDescription: string;
    OrganizationUnitSetType?: EVA.Core.OrganizationUnitSetTypes;
    Name: string;
    Code: string;
    IsActive: boolean;
    IsRoundingType: boolean;
    ReturnAction: EVA.Core.PaymentReturnActions;
    PrintOnDocuments: boolean;
    BackendRelationID: string;
    BackendID?: string;
    AutoFinalizeOnOrderPaid: boolean;
    CashJournalMethod: EVA.Core.PaymentCashJournalMethod;
    Category: EVA.Core.PaymentTypeCategory;
    Options?: EVA.Core.PaymentTypeOptions;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    ScriptName?: string;
    Roles: GetPaymentTypeByIDResponse.PaymentTypeRole[];
    AllowMultiCurrency: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetPaymentTypeByIDResponse {
    export interface PaymentTypeRole {
      RoleID: number;
      Name: string;
    }

  }

  /**
   * Create a new PaymentType.
   */
  export interface CreatePaymentType {
    /**
     * Entity type: PaymentMethod
     */
    PaymentMethodID: number;
    /**
     * Entity type: LedgerClass
     */
    LedgerClassID?: string;
    Name: string;
    Code: string;
    IsActive?: boolean;
    ReturnAction: EVA.Core.PaymentReturnActions;
    PrintOnDocuments?: boolean;
    BackendRelationID?: string;
    BackendID?: string;
    AutoFinalizeOnOrderPaid?: boolean;
    CashJournalMethod: EVA.Core.PaymentCashJournalMethod;
    Category?: EVA.Core.PaymentTypeCategory;
    Options?: EVA.Core.PaymentTypeOptions;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    Roles?: CreatePaymentType.PaymentTypeRole[];
    /**
     * @default false
     */
    AllowMultiCurrency?: boolean;
  }

  export namespace CreatePaymentType {
    export interface PaymentTypeRole {
      /**
       * Entity type: Role
       */
      RoleID: number;
    }

  }

  export interface CreatePaymentTypeResponse {
    /**
     * Entity type: PaymentType
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing PaymentType.
   */
  export interface UpdatePaymentType {
    /**
     * Entity type: PaymentType
     */
    ID: number;
    /**
     * Entity type: PaymentMethod
     */
    PaymentMethodID?: number;
    /**
     * Entity type: LedgerClass
     */
    LedgerClassID?: string;
    Name?: string;
    Code?: string;
    IsActive?: boolean;
    ReturnAction?: EVA.Core.PaymentReturnActions;
    PrintOnDocuments?: boolean;
    BackendRelationID?: string;
    BackendID?: string;
    AutoFinalizeOnOrderPaid?: boolean;
    CashJournalMethod?: EVA.Core.PaymentCashJournalMethod;
    Category?: EVA.Core.PaymentTypeCategory;
    Options?: UpdatePaymentType.PaymentTypeOptionsMaybe;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    Roles?: UpdatePaymentType.PaymentTypeRole[];
    AllowMultiCurrency?: boolean;
  }

  export namespace UpdatePaymentType {
    export interface PaymentTypeRole {
      /**
       * Entity type: Role
       */
      RoleID: number;
    }

    export interface PaymentTypeOptionsMaybe {
      RequiredUserType?: EVA.Core.UserTypes;
      RequiredFunctionality?: string;
      RequiredFunctionalityScope?: EVA.Core.FunctionalityScope;
      Pending?: boolean;
      RefundPending?: boolean;
      /**
       * Setting this to false results in refund only, will therefor only work with CanBeRefunded:true and CanRefundWithoutOriginalPaymentTransaction:true
       */
      CanBeUsedForPayments?: boolean;
      CanBeRefunded?: boolean;
      CanBeCancelled?: boolean;
      CanRefundWithoutOriginalPaymentTransaction?: boolean;
      RequiresInteractionForRefunds?: boolean;
      /**
       * Entity type: GiftCardConfiguration
       */
      GiftCardConfigurationID?: number;
      /**
       * Entity type: LoyaltyProgram
       */
      LoyaltyProgramID?: number;
      PinHandler?: string;
      PinManualKeyEntry?: boolean;
      RequiresAmount?: boolean;
      RequiresConfirmationForPayments?: boolean;
      RequiresConfirmationForRefunds?: boolean;
      OnlyAvailableInLocalMode?: boolean;
      BlockOverPayments?: boolean;
    }

  }

  /**
   * Delete a PaymentType
   */
  export interface DeletePaymentType {
    /**
     * Entity type: PaymentType
     */
    ID: number;
  }

  /**
   * List PaymentTypes. Returns a paged response.
   */
  export interface ListPaymentTypes {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListPaymentTypesFilter>;
  }

  export interface ListPaymentTypesResponse {
    Result?: EVA.Core.PagedResult<ListPaymentTypesResponse.PaymentTypeDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPaymentTypesResponse {
    export interface PaymentTypeDto {
      /**
       * Entity type: PaymentType
       */
      ID: number;
      /**
       * Entity type: PaymentMethod
       */
      PaymentMethodID: number;
      /**
       * Entity type: LedgerClass
       */
      LedgerClassID: string;
      PaymentMethodName: string;
      Name: string;
      Code: string;
      IsActive: boolean;
      IsRoundingType: boolean;
      ReturnAction: EVA.Core.PaymentReturnActions;
      PrintOnDocuments: boolean;
      BackendRelationID: string;
      BackendID?: string;
      AutoFinalizeOnOrderPaid: boolean;
      CashJournalMethod: EVA.Core.PaymentCashJournalMethod;
      Options?: EVA.Core.PaymentTypeOptions;
      /**
       * Entity type: Script
       */
      ScriptID?: number;
      OrganizationUnitSetPaymentTypes: ListPaymentTypesResponse.OrganizationUnitSetPaymentTypeDto[];
    }

    export interface OrganizationUnitSetPaymentTypeDto {
      OrganizationUnitSetID: number;
      OrganizationUnitSetName: string;
      RefundPriority?: number;
      DisplayPriority: number;
      CaptureMoment?: EVA.Core.PaymentTypeCaptureMoment;
    }

  }

  /**
   * Get's the ID/Name of all paymenttypes to use for filter inputs
   */
  export interface GetPaymentTypesForFilter {
    Name?: string;
  }

  export interface GetPaymentTypesForFilterResponse {
    PaymentTypes: GetPaymentTypesForFilterResponse.PaymentType[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetPaymentTypesForFilterResponse {
    export interface PaymentType {
      /**
       * Entity type: PaymentType
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Check or perform the migration for setting `PaymentMethods:PaymentTypeAvailabilityByOuSetType`.
   * 
   * Omitting `SaveChanges` will default to `false`, returning the changes it would have done, but don't actually persist them. Pass `true` explicitly if you want to actually migrate (use with caution!).
   * 
   * The payment type property `OrganizationUnitSetID` is hence-forth known as 'the legacy filter', where as the configured list of `OrganizationUnitSetPaymentType` is called 'the sets' or 'a set'.
   * 
   * Will execute for each active payment type;
   * 
   * - If it has no legacy filter configured, will remove any set that might be configured for this payment type
   * - If it *has* a legacy filter configured;
   *  - This legacy filter will be removed
   *  - If there is no matching set configured, it will add it
   *  - If there is a matching set configured but it is limited (disabled for delivery etc.), those limitations will be lifted
   *  - If there are any other set configured, those will be removed
   * 
   * And finally, the setting will be enabled on root level.
   * 
   * This migration will not run if the setting is already set (at any level!).
   */
  export interface MigratePaymentTypeOrganizationUnitSetting {
    /**
     * @default false
     */
    SaveChanges?: boolean;
  }

  export interface MigratePaymentTypeOrganizationUnitSettingResponse {
    /**
     * Entity type: PaymentType
     */
    Output: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get CustomFields for the given payment type.
   */
  export interface GetPaymentTypeCustomFields {
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID: number;
  }

  export interface GetPaymentTypeCustomFieldsResponse {
    CustomFields: GetPaymentTypeCustomFieldsResponse.CustomFieldDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetPaymentTypeCustomFieldsResponse {
    export interface CustomFieldDto {
      /**
       * Entity type: CustomField
       */
      ID: number;
      /**
       * Entity type: CustomFieldType
       */
      TypeID: number;
      TypeName: string;
      Name: string;
      DisplayName?: string;
      DataType: EVA.Core.CustomFieldDataTypes;
      Order: number;
      BackendID?: string;
      IsArray: boolean;
      EnumValues?: { [key: string]: string };
    }

  }

  export interface SetPaymentTypeRoles {
    /**
     * Entity type: PaymentMethod
     */
    ID: number;
    Roles?: SetPaymentTypeRoles.PaymentTypeRole[];
  }

  export namespace SetPaymentTypeRoles {
    export interface PaymentTypeRole {
      /**
       * Entity type: Role
       */
      RoleID: number;
    }

  }

  /**
   * List paymenttransactionssettlements
   * 
   * Filters available to be sent in the request:
   * - FinancialPeriodID
   * - PaymentReference
   * - MerchantReference
   * - Type
   * - SubType
   */
  export interface ListPaymentTransactionSettlements {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    PaymentReference?: string;
    MerchantReference?: string;
    /**
     * Entity type: PaymentTransactionSettlementType
     */
    TypeID?: number;
    SubType?: string;
  }

  export interface ListPaymentTransactionsSettlementsResponse {
    PaymentTransactions: ListPaymentTransactionsSettlementsResponse.ResultPaymentTransaction[];
    Settlements: ListPaymentTransactionsSettlementsResponse.ResultSettlement[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPaymentTransactionsSettlementsResponse {
    export interface ResultPaymentTransaction {
      /**
       * Entity type: PaymentTransaction
       */
      PaymentTransactionID: number;
      SettledAmount: number;
      PaymentTransactionCaptures: ListPaymentTransactionsSettlementsResponse.ResultPaymentTransactionCapture[];
      Settlements: ListPaymentTransactionsSettlementsResponse.ResultSettlement[];
    }

    export interface ResultPaymentTransactionCapture {
      /**
       * Entity type: PaymentTransactionCapture
       */
      PaymentTransactionCaptureID: number;
      Settlements: ListPaymentTransactionsSettlementsResponse.ResultSettlement[];
      SettledAmount: number;
    }

    export interface ResultSettlement {
      Type: EVA.Core.EnumDto;
      Subtype: string;
      Amount: number;
      PaymentReference: string;
      MerchantReference: string;
    }

  }

  /**
   * Creates a new OrganizationUnitSetScope.
   * 
   * When OrganizationUnitUniqueInScope is specified as true, then a single OrganizationUnit can only occur once
   * among all OrganizationUnitSets that have this scope.
   */
  export interface CreateOrganizationUnitSetScope {
    Name: string;
    OrganizationUnitUniqueInScope?: boolean;
  }

  export interface CreateOrganizationUnitSetScopeResponse {
    /**
     * Entity type: OrganizationUnitSetScope
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Returns all current scopes.
   */
  export interface GetOrganizationUnitSetScopes {
  }

  export interface GetOrganizationUnitSetScopesResponse {
    Scopes: GetOrganizationUnitSetScopesResponse.OrganizationUnitSetScope[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetOrganizationUnitSetScopesResponse {
    export interface OrganizationUnitSetScope {
      /**
       * Entity type: OrganizationUnitSetScope
       */
      ID: number;
      Name: string;
      Description: string;
      OrganizationUnitUniqueInScope: boolean;
    }

  }

  /**
   * Deletes a OrganizationUnitSetScope.
   * 
   * It's not possible to delete a scope that is still in use by an OrganizationUnitSet.
   */
  export interface DeleteOrganizationUnitSetScope {
    /**
     * Entity type: OrganizationUnitSetScope
     */
    ID: number;
  }

  /**
   * Updates a OrganizationUnitSetScope.
   * 
   * When OrganizationUnitUniqueInScope is specified as true, then a single OrganizationUnit can only occur once
   * among all OrganizationUnitSets that have this scope.
   */
  export interface UpdateOrganizationUnitSetScope {
    /**
     * Entity type: OrganizationUnitSetScope
     */
    ID: number;
    Name: string;
    Description?: string;
    OrganizationUnitUniqueInScope?: boolean;
  }

  /**
   * Creates a new `OrganizationUnitSet`.
   * 
   *   Optionally a definition can be provided, which defines a set of filters.
   *   Any `OrganizationUnit` that matches the filters are automatically part of the set.
   * 
   *   If a definition is provided without any filters, it's ignored.
   * 
   *   The ScopeID refers to an `OrganizationUnitSetScope` and can be used to create collections of sets for specific purposes, such as discounts.
   */
  export interface CreateOrganizationUnitSet {
    /**
     * Name is only optional when creating an AdHoc set.
     */
    Name?: string;
    /**
     * Description.
     */
    Description?: string;
    BackendID?: string;
    Type?: EVA.Core.OrganizationUnitSetTypes;
    /**
     * Entity type: OrganizationUnitSetScope
     */
    ScopeID?: number;
    Definition?: EVA.Core.OrganizationUnitSetDefinition;
    /**
     * When specified, adds the sets contained in Subsets as a subset of the new set.
     */
    Subsets?: CreateOrganizationUnitSet.OrganizationUnitSubSetDefinition[];
    SubsetOrdering?: OrganizationSubsetOrdering;
  }

  export namespace CreateOrganizationUnitSet {
    export interface OrganizationUnitSubSetDefinition {
      /**
       * Entity type: OrganizationUnitSet
       */
      ID: number;
      OperatorType: EVA.Core.OrganizationUnitSetOperatorTypes;
    }

  }

  export const enum OrganizationSubsetOrdering {
    Ascending = 0,
    Descending = 1
  }

  export interface CreateOrganizationUnitSetResponse {
    /**
     * Entity type: OrganizationUnitSet
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Gets a detailed view of an `OrganizationUnitSet` by its ID and returns it. This service recursively returns the set with its subsets and so on.
   */
  export interface GetOrganizationUnitSetDetails {
    /**
     * Entity type: OrganizationUnitSet
     */
    ID: number;
    SubsetOrdering?: OrganizationSubsetOrdering;
  }

  export interface GetOrganizationUnitSetDetailsResponse {
    Set: OrganizationUnitSetDetails;
    DeclaredSubsets: GetOrganizationUnitSetDetailsResponse.OrganizationUnitSubset[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetOrganizationUnitSetDetailsResponse {
    export interface OrganizationUnitSubset {
      /**
       * Entity type: OrganizationUnitSubset
       */
      ID: number;
      SequenceNumber: number;
      Name: string;
      Description: string;
      Type: EVA.Core.OrganizationUnitSetOperatorTypes;
      BackendID?: string;
    }

  }

  export interface OrganizationUnitSetDetails {
    /**
     * Entity type: OrganizationUnitSubset
     */
    ID: number;
    Name: string;
    Description: string;
    Type: EVA.Core.OrganizationUnitSetTypes;
    OperatorType: EVA.Core.OrganizationUnitSetOperatorTypes;
    Definition: EVA.Core.OrganizationUnitSetDefinition;
    Subsets: OrganizationUnitSetDetails[];
    Scope: EVA.Core.EnumDto;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    BackendID?: string;
  }

  /**
   * Updates an OrganizationUnitSet.
   * 
   *   Optionally a definition can be provided, which defines a set of filters.
   *   Any `OrganizationUnit` that matches the filters are automatically part of the set.
   * 
   *   To remove a definition from a set, pass it as `null` or as an empty object to this service. If you don't want to override
   *   it, pass the definition you got back from the `GetOrganizationUnitSet` service.
   */
  export interface UpdateOrganizationUnitSet {
    /**
     * Entity type: OrganizationUnitSet
     */
    ID: number;
    Name?: string;
    BackendID?: string;
    Description?: string;
    /**
     * Entity type: OrganizationUnitSetScope
     */
    ScopeID?: number;
    Definition?: EVA.Core.OrganizationUnitSetDefinition;
  }

  /**
   * Lists OrganizationUnitSets, optionally filtered and paged.
   */
  export interface ListOrganizationUnitSets {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListOrganizationUnitSetsFilter>;
  }

  export interface ListOrganizationUnitSetsResponse {
    Result?: EVA.Core.PagedResult<EVA.Core.ListOrganizationUnitSetsItem>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Deletes an OrganizationUnitSet by its ID.
   * 
   *   It's currently not possible to delete a set that is still in use. Trying to do so will return an OrganizationUnitSets:CannotDeleteInUse error.
   */
  export interface DeleteOrganizationUnitSet {
    /**
     * Entity type: OrganizationUnitSet
     */
    ID: number;
  }

  /**
   * Adds one set (`SubsetID`) as the subset of another set (`SetID`).
   *   If this subset relation already exists, the type is updated.
   * 
   *   The Type determines whether the relation is additive or subtractive.
   *   If it's additive, the SubsetID and and all its subsets (recursively) becomes part of this set.
   * 
   *   If it's subtractive, the SubsetID and all its subsets will not be part of this set.
   */
  export interface CreateOrUpdateOrganizationUnitSubset {
    /**
     * Entity type: OrganizationUnitSet
     */
    SetID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    SubsetID: number;
    Type: EVA.Core.OrganizationUnitSetOperatorTypes;
  }

  /**
   * Removes a subset (SubsetID) from a set (SetID). If it doesn't exist, nothing happens.
   */
  export interface DeleteOrganizationUnitSubset {
    /**
     * Entity type: OrganizationUnitSet
     */
    SetID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    SubsetID: number;
  }

  /**
   * Gets an `OrganizationUnitSet` by its ID and returns the set's basic information.
   */
  export interface GetOrganizationUnitSet {
    /**
     * Entity type: OrganizationUnitSet
     */
    ID: number;
  }

  export interface GetOrganizationUnitSetResponse {
    /**
     * Entity type: OrganizationUnitSet
     */
    ID: number;
    Name: string;
    Description: string;
    Type: EVA.Core.OrganizationUnitSetTypes;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    Scope: EVA.Core.EnumDto;
    BackendID?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Returns a what-if preview of what the set would contain if it existed with the provided definition (optional) or has provided sets as its subsets.
   */
  export interface PreviewOrganizationUnitSet {
    Definition?: EVA.Core.OrganizationUnitSetDefinition;
    Subsets?: PreviewOrganizationUnitSet.PreviewOrganizationUnitSubSetDefinition[];
    SubsetOrdering?: OrganizationSubsetOrdering;
  }

  export namespace PreviewOrganizationUnitSet {
    export interface PreviewOrganizationUnitSubSetDefinition {
      /**
       * Entity type: OrganizationUnitSubset
       */
      ID: number;
      OperatorType: EVA.Core.OrganizationUnitSetOperatorTypes;
      SequenceNumber?: number;
    }

  }

  export interface PreviewOrganizationUnitSetResponse {
    Set: OrganizationUnitSetDetails;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Takes in all subsets of an organization unit set and sets their sequences. All subsets are required.
   */
  export interface SetOrganizationUnitSubsetSequences {
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    SubsetIDs: number[];
  }

  /**
   * Get a CashHandler
   */
  export interface GetCashHandlerByID {
    /**
     * Entity type: CashHandler
     */
    ID: number;
  }

  export interface GetCashHandlerByIDResponse {
    ID: number;
    Name: string;
    CurrencyID: string;
    RoundingFactor: number;
    Coins: number[];
    BankNotes: number[];
    MaxAmountPerOrder?: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new CashHandler
   */
  export interface CreateCashHandler {
    Name: string;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * Range: 1-10000
     */
    RoundingFactor: number;
    /**
     * Min: 0
     */
    Coins: number[];
    /**
     * Min: 0
     */
    BankNotes: number[];
    /**
     * Min: 0
     */
    MaxAmountPerOrder?: number;
  }

  export interface CreateCashHandlerResponse {
    /**
     * Entity type: CashHandler
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing CashHandler
   */
  export interface UpdateCashHandler {
    /**
     * Entity type: CashHandler
     */
    ID: number;
    Name?: string;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    /**
     * Range: 1-10000
     */
    RoundingFactor?: number;
    /**
     * Min: 0
     */
    Coins?: number[];
    /**
     * Min: 0
     */
    BankNotes?: number[];
    /**
     * Min: 0
     */
    MaxAmountPerOrder?: number;
  }

  /**
   * Delete a CashHandler
   */
  export interface DeleteCashHandler {
    /**
     * Entity type: CashHandler
     */
    ID: number;
  }

  /**
   * List CashHandlers
   */
  export interface ListCashHandlers {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListCashHandlersFilter>;
  }

  export interface ListCashHandlersResponse {
    Result?: EVA.Core.PagedResult<ListCashHandlersResponse.CashHandlerDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCashHandlersResponse {
    export interface CashHandlerDto {
      /**
       * Entity type: CashHandler
       */
      ID: number;
      Name: string;
      /**
       * Entity type: Currency
       */
      CurrencyID: string;
      RoundingFactor: number;
      Coins: number[];
      BankNotes: number[];
      MaxAmountPerOrder?: number;
    }

  }

  /**
   * Create a new OpeningHoursType
   */
  export interface CreateOpeningHoursType {
    Name: string;
    Description?: string;
    BackendID?: string;
  }

  export interface CreateOpeningHoursTypeResponse {
    /**
     * Entity type: OpeningHoursType
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing OpeningHoursType
   */
  export interface UpdateOpeningHoursType {
    /**
     * Entity type: OpeningHoursType
     */
    ID: number;
    Name: string;
    Description?: string;
    BackendID?: string;
  }

  /**
   * Delete a OpeningHoursType
   */
  export interface DeleteOpeningHoursType {
    /**
     * Entity type: OpeningHoursType
     */
    ID: number;
  }

  /**
   * Get OpeningHoursTypes
   */
  export interface GetOpeningHoursTypes {
  }

  export interface GetOpeningHoursTypesResponse {
    OpeningHoursTypes: GetOpeningHoursTypesResponse.OpeningHoursTypeDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetOpeningHoursTypesResponse {
    export interface OpeningHoursTypeDto {
      BackendID: string;
      /**
       * Entity type: Enum
       */
      ID: number;
      /**
       * Usually an internal & unchangable code - for display, use `Description`
       */
      Name: string;
      Description: string;
    }

  }

  /**
   * List the configured additional currencies for the given OrganizationUnit
   * 
   * It is required to set the OrganizationUnitID on the filter.
   */
  export interface ListOrganizationUnitCurrencies {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.OrganizationUnitCurrencyFilter>;
  }

  export interface ListOrganizationUnitCurrenciesResponse {
    Result?: EVA.Core.PagedResult<ListOrganizationUnitCurrenciesResponse.OrganizationUnitCurrencyDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListOrganizationUnitCurrenciesResponse {
    export interface OrganizationUnitCurrencyDto {
      /**
       * Entity type: OrganizationUnitCurrency
       */
      ID?: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      OrganizationUnitName: string;
      /**
       * Entity type: Currency
       */
      CurrencyID: string;
      /**
       * Used to override the default exchange rates
       */
      ExchangeRate?: number;
      /**
       * Entity type: CashHandler
       */
      CashHandlerID: number;
      CashHandlerName: string;
      /**
       * Entity type: OrganizationUnit
       */
      InheritedFromOrganizationUnitID?: number;
      InheritedFromOrganizationUnitName?: string;
    }

  }

  /**
   * Create a new additional currency for an OrganizationUnit
   * 
   * It is required to define the CashHandler
   */
  export interface CreateOrganizationUnitCurrency {
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: CashHandler
     */
    CashHandlerID: number;
    /**
     * Used to override the default exchange rates
     */
    ExchangeRate?: number;
  }

  export interface CreateOrganizationUnitCurrencyResponse {
    /**
     * Entity type: OrganizationUnitCurrency
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update the Cashhandler for an additional Currency
   */
  export interface UpdateOrganizationUnitCurrency {
    /**
     * Entity type: OrganizationUnitCurrency
     */
    ID: number;
    /**
     * Entity type: CashHandler
     */
    CashHandlerID: number;
    /**
     * Used to override the default exchange rates
     */
    ExchangeRate?: number;
  }

  /**
   * Delete an additional Currency
   */
  export interface DeleteOrganizationUnitCurrency {
    /**
     * Entity type: OrganizationUnitCurrency
     */
    ID: number;
  }

  /**
   * List organizationunit openinghours
   */
  export interface ListOpeningHours {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListOldOpeningHoursFilter>;
  }

  export interface ListOpeningHoursResponse {
    Result?: EVA.Core.PagedResult<EVA.Core.OpeningHoursDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create new OpeningHours for OrganizationUnits
   * 
   * Multiple items can be created in a single request. Also multiple OrganizationUnits are allowed.
   * 
   * It's not allowed to create multiple items for a single day on the same store. This is checked for Day based openinghours and Date based openinghours.
   * 
   * Openinghours wit a Date component override the openinghours on Day level. They are called SpecialOpeningHours most of the time.
   * 
   * To close a store on a regular day, just don't create an openinghour for that day (or delete it).
   * To close a store on a specific date, create an openinghour with StartTime=null, EndTime=null
   */
  export interface CreateOrganizationUnitOpeningHours {
    OpeningHours: EVA.Core.OpeningHoursDataDto[];
  }

  /**
   * Update existing OpeningHours for OrganizationUnits
   * 
   * Multiple items can be updated in a single request. Also multiple OrganizationUnits are allowed.
   */
  export interface UpdateOrganizationUnitOpeningHours {
    OpeningHours: EVA.Core.OpeningHoursDto[];
  }

  /**
   * Delete a single existing OpeningHour for an OrganizationUnit
   */
  export interface DeleteOrganizationUnitOpeningHours {
    /**
     * Entity type: OpeningHours
     */
    ID: number;
  }

  export interface GetOrganizationUnitSupplierDataByOrganizationUnitID {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetOrganizationUnitSupplierDataByOrganizationUnitIDResponse {
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    EstimatedDeliveryDays?: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface SetOrganizationUnitSupplierData {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Min: 0
     */
    EstimatedDeliveryDays?: number;
  }

  /**
   * Update the regular openinghours for an OrganizationUnit
   * 
   * This service accepts a request like this:
   * ```
   * {
   *   "OrganizationUnitID": 123, // required
   *   "TypeID": 2, // required, OpeningHoursType
   *   "Sunday": {
   *     "IsClosed": false, // required
   *     "StartTime": "10:00:00", // optional
   *     "EndTime": "18:00:00", // optional
   *     "Description": "Repairs closed"// optional
   *   }, // required
   *   "Monday": ..., //required
   *   "Tuesday": ..., //required
   *   "Wednesday": ..., //required
   *   "Thursday": ..., //required
   *   "Friday": ..., //required
   *   "Saturday": ..., //required
   *   }
   * ```
   * All days are required, days can be closed and contain a description
   * 
   * To manage non-regular OpeningHours the existing CreateOrganizationUnitOpeningHours, UpdateOrganizationUnitOpeningHours, DeleteOrganizationUnitOpeningHours can be used.
   * They have a TypeID property on the OpeningHours object to specify the OpeningHoursType.
   */
  export interface UpdateOrganizationUnitRegularOpeningHours {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: OpeningHoursType
     */
    TypeID: number;
    Sunday: EVA.Core.DayOpeningHours;
    Monday: EVA.Core.DayOpeningHours;
    Tuesday: EVA.Core.DayOpeningHours;
    Wednesday: EVA.Core.DayOpeningHours;
    Thursday: EVA.Core.DayOpeningHours;
    Friday: EVA.Core.DayOpeningHours;
    Saturday: EVA.Core.DayOpeningHours;
  }

  /**
   * List the CheckoutOptionCategories
   */
  export interface ListCheckoutOptionCategories {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListCheckoutOptionCategoriesFilter>;
    PageToken?: string;
  }

  export interface ListCheckoutOptionCategoriesResponse {
    Results?: CheckoutOptionCategoryDto[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface CheckoutOptionCategoryDto {
    /**
     * Entity type: CheckoutOptionCategory
     */
    ID: number;
    Name: string;
    Description?: string;
    Sequence: number;
  }

  /**
   * Create a new CheckoutOptionCategory
   */
  export interface CreateCheckoutOptionCategory {
    Name: string;
    Description?: string;
    Sequence: number;
  }

  export interface CreateCheckoutOptionCategoryResponse {
    /**
     * Entity type: CheckoutOptionCategory
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing CheckoutOptionCategory
   */
  export interface UpdateCheckoutOptionCategory {
    /**
     * Entity type: CheckoutOptionCategory
     */
    ID: number;
    Name?: string;
    Description?: string;
    Sequence?: number;
  }

  /**
   * Delete a CheckoutOptionCategory
   */
  export interface DeleteCheckoutOptionCategory {
    /**
     * Entity type: CheckoutOptionCategory
     */
    ID: number;
  }

  /**
   * Create a new CheckoutOption
   */
  export interface CreateCheckoutOption {
    /**
     * Entity type: CheckoutOptionCategory
     */
    CategoryID?: number;
    IsActive: boolean;
    Name: string;
    Description?: string;
    Handler: string;
    Data?: any;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    Sequence: number;
  }

  export interface CreateCheckoutOptionResponse {
    /**
     * Entity type: CheckoutOption
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing CheckoutOption
   */
  export interface UpdateCheckoutOption {
    /**
     * Entity type: CheckoutOption
     */
    ID: number;
    /**
     * Entity type: CheckoutOptionCategory
     */
    CategoryID?: number;
    IsActive?: boolean;
    Name?: string;
    Description?: string;
    Handler?: string;
    Data?: any;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    Sequence?: number;
  }

  /**
   * Delete a CheckoutOption
   */
  export interface DeleteCheckoutOption {
    /**
     * Entity type: CheckoutOption
     */
    ID: number;
  }

  /**
   * Get the available checkout option handlers
   */
  export interface GetCheckoutOptionHandlers {
  }

  export interface GetCheckoutOptionHandlersResponse {
    Handlers: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Updates the sequence of supplied CheckoutOptions `IDs` matching the order they were submitted. CheckoutOptions not supplied are not touched.
   * 
   * The first supplied CheckoutOption will get `Sequence=0` and thus will be returned first. The second will get `Sequence=1`, and so on.
   */
  export interface UpdateCheckoutOptionSequences {
    /**
     * Entity type: CheckoutOption
     */
    IDs?: number[];
  }

  /**
   * Create custom "OrderLedgerType"
   */
  export interface CreateOrderLedgerType {
    Name: string;
    Description?: string;
  }

  export interface CreateOrderLedgerTypeResponse {
    /**
     * Entity type: OrderLedgerType
     */
    ID: number;
    Name: string;
    Description?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Delete existing "OrderLedgerType"
   */
  export interface DeleteOrderLedgerType {
    /**
     * Entity type: OrderLedgerType
     */
    ID: number;
  }

  /**
   * Returns a list of "OrderLedgerType"
   */
  export interface ListOrderLedgerTypes {
  }

  export interface ListOrderLedgerTypesResponse {
    OrderLedgerTypes: ListOrderLedgerTypesResponse.ResponseModel[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListOrderLedgerTypesResponse {
    export interface ResponseModel {
      /**
       * Entity type: OrderLedgerType
       */
      ID: number;
      Name: string;
      Description?: string;
    }

  }

  /**
   * Returns a paged result of all the refund reasons.
   */
  export interface ListRefundCorrectionReasons {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListRefundCorrectionReasonsFilter>;
    PageToken?: string;
  }

  export interface ListRefundCorrectionReasonsResponse {
    Results?: ListRefundCorrectionReasonsResponse.Model[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListRefundCorrectionReasonsResponse {
    export interface Model {
      /**
       * Entity type: RefundCorrectionReason
       */
      ID: number;
      BackendID?: string;
      Name: string;
      Description?: string;
      Priority: number;
      /**
       * Entity type: OrganizationUnitSet
       */
      OrganizationUnitSetID: number;
      OrganizationUnitSetName: string;
    }

  }

  /**
   * Returns a single refund reason.
   */
  export interface GetRefundCorrectionReason {
    /**
     * Entity type: RefundCorrectionReason
     */
    ID: number;
  }

  export interface GetRefundCorrectionReasonResponse {
    BackendID?: string;
    Name: string;
    Description?: string;
    Priority: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    OrganizationUnitSetName: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Creates a new refund reason.
   */
  export interface CreateRefundCorrectionReason {
    BackendID?: string;
    Name?: string;
    Description?: string;
    Priority?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
  }

  export interface CreateRefundCorrectionReasonResponse {
    /**
     * Entity type: RefundCorrectionReason
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface UpdateRefundCorrectionReason {
    /**
     * Entity type: RefundCorrectionReason
     */
    ID: number;
    BackendID?: string;
    Name?: string;
    Description?: string;
    Priority?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
  }

  /**
   * Deletes a refund reason. Note that it can still be seen on orders that have this field, but you can no longer use it.
   */
  export interface DeleteRefundCorrectionReason {
    /**
     * Entity type: RefundCorrectionReason
     */
    ID: number;
  }

  /**
   * Create a new UnitPriceCorrectionReason
   */
  export interface CreateUnitPriceCorrectionReason {
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Name?: string;
    Description?: string;
    BackendID?: string;
    Priority?: number;
  }

  export interface CreateUnitPriceCorrectionReasonResponse {
    /**
     * Entity type: UnitPriceCorrectionReason
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing UnitPriceCorrectionReason
   */
  export interface UpdateUnitPriceCorrectionReason {
    /**
     * Entity type: UnitPriceCorrectionReason
     */
    ID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Name?: string;
    Description?: string;
    BackendID?: string;
    Priority?: number;
  }

  /**
   * Delete a UnitPriceCorrectionReason
   */
  export interface DeleteUnitPriceCorrectionReason {
    /**
     * Entity type: UnitPriceCorrectionReason
     */
    ID: number;
  }

  /**
   * Returns a paged result of all the unit price correction reasons.
   */
  export interface ListUnitPriceCorrectionReasons {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListUnitPriceCorrectionReasonsFilter>;
    PageToken?: string;
  }

  export interface ListUnitPriceCorrectionReasonsResponse {
    Results?: ListUnitPriceCorrectionReasonsResponse.Model[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListUnitPriceCorrectionReasonsResponse {
    export interface Model {
      /**
       * Entity type: UnitPriceCorrectionReason
       */
      ID: number;
      Description?: string;
      BackendID?: string;
      Name: string;
      Priority: number;
      /**
       * Entity type: OrganizationUnitSet
       */
      OrganizationUnitSetID: number;
      OrganizationUnitSetName: string;
    }

  }

  /**
   * Update existing "OrderLedgerType"
   */
  export interface UpdateOrderLedgerType {
    /**
     * Entity type: OrderLedgerType
     */
    ID: number;
    Name: string;
    Description?: string;
  }

  export interface UpdateOrderLedgerTypeResponse {
    /**
     * Entity type: OrderLedgerType
     */
    ID: number;
    Name: string;
    Description?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List all return reasons. Does not support sorting. Always sorted by `Priority`
   */
  export interface ListReturnReasons {
    PageConfig?: EVA.Core.PageConfig<ListReturnReasonsFilter>;
  }

  export interface ListReturnReasonsFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Type?: EVA.Core.ReturnReasonType;
    /**
     * Entity type: ReturnReason
     */
    ID?: number;
    Name?: string;
    RemarkType?: EVA.Core.ReturnReasonRemarkType;
  }

  export interface ListReturnReasonsResponse {
    Result?: EVA.Core.PagedResult<ListReturnReasonsResponse.Reason>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListReturnReasonsResponse {
    export interface Reason {
      /**
       * Entity type: ReturnReason
       */
      ID?: number;
      Name?: string;
      Description?: string;
      BackendID?: string;
      /**
       * Entity type: OrganizationUnitSet
       */
      OrganizationUnitSetID?: number;
      OrganizationUnitSetName?: string;
      Type?: EVA.Core.ReturnReasonType;
      RemarkType?: EVA.Core.ReturnReasonRemarkType;
      Priority?: number;
    }

  }

  /**
   * Get the reasons by type.
   */
  export interface GetReturnReasonsByType {
    Type: EVA.Core.ReturnReasonType;
  }

  export interface GetReturnReasonsByTypeResponse {
    Reasons: GetReturnReasonsByTypeResponse.Reason[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetReturnReasonsByTypeResponse {
    export interface Reason {
      ID: number;
      Name: string;
      Description: string;
      BackendID: string;
      RemarkType: EVA.Core.ReturnReasonRemarkType;
    }

  }

  /**
   * Create a return reason
   */
  export interface CreateReturnReason {
    Name: string;
    Description?: string;
    BackendID?: string;
    Priority: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Optional for backwards compatibility and defaults to OrganizationUnit, but should be entered. Will be required in the future.
     */
    Type?: EVA.Core.ReturnReasonType;
    /**
     * Optional for backwards compatibility and defaults to `Hidden`, but should be entered. Will be required in the future.
     */
    RemarkType?: EVA.Core.ReturnReasonRemarkType;
  }

  export interface CreateReturnReasonResponse {
    /**
     * Entity type: ReturnReason
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Delete a return reason
   */
  export interface DeleteReturnReason {
    /**
     * Entity type: ReturnReason
     */
    ID: number;
  }

  /**
   * Update a return reason
   */
  export interface UpdateReturnReason {
    /**
     * Entity type: ReturnReason
     */
    ID: number;
    Name?: string;
    Description?: string;
    BackendID?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Optional for backwards compatibility and defaults to OrganizationUnit, but should be entered. Will be required in the future.
     */
    Type?: EVA.Core.ReturnReasonType;
    Priority?: number;
    RemarkType?: EVA.Core.ReturnReasonRemarkType;
  }

  /**
   * Duplicate an existing MessageTemplate
   */
  export interface DuplicateMessageTemplate {
    /**
     * Entity type: MessageTemplate
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    Layout?: string;
  }

  export interface DuplicateMessageTemplateResponse {
    /**
     * Entity type: MessageTemplate
     */
    ID: number;
    Type: EVA.Core.MessageTemplateTypes;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GetDataModelForTemplateHandler {
    Handler?: string;
  }

  export interface GetDataModelForTemplateHandlerResponse {
    DataModel: { [key: string]: any };
    SampleData: { [key: string]: any };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListMessageTemplateLayouts {
    Destination?: EVA.Core.MessageTemplateDestinations;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    LanguageID?: string;
    CountryID?: string;
  }

  export interface ListMessageTemplateLayoutsResponse {
    Layouts: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListTemplateHandlers {
  }

  export interface ListTemplateHandlersResponse {
    Handlers: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get a MessageTemplate
   */
  export interface GetMessageTemplateByID {
    /**
     * Entity type: MessageTemplate
     */
    ID: number;
  }

  export interface GetMessageTemplateByIDResponse {
    /**
     * Entity type: MessageTemplate
     */
    ID: number;
    Name: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OrganizationUnitName?: string;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    Header: string;
    Template: string;
    Footer: string;
    Helpers: string;
    Type: EVA.Core.MessageTemplateTypes;
    Layout: string;
    Destination: EVA.Core.MessageTemplateDestinations;
    PaperProperties: EVA.Core.PaperProperties;
    IsDisabled: boolean;
    LastModifiedByEmail?: string;
    /**
     * Entity type: User
     */
    LastModifiedByUserID?: number;
    LastModifiedAt?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new MessageTemplate
   */
  export interface CreateMessageTemplate {
    Name: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    Header?: string;
    Template: string;
    Footer?: string;
    Helpers?: string;
    Type: EVA.Core.MessageTemplateTypes;
    Layout?: string;
    Destination: EVA.Core.MessageTemplateDestinations;
    PaperProperties?: EVA.Core.PaperProperties;
    IsDisabled?: boolean;
  }

  export interface CreateMessageTemplateResponse {
    /**
     * Entity type: MessageTemplate
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing MessageTemplate
   */
  export interface UpdateMessageTemplate {
    /**
     * Entity type: MessageTemplate
     */
    ID: number;
    Name?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    Header?: string;
    Template?: string;
    Footer?: string;
    Helpers?: string;
    Layout?: string;
    Destination?: EVA.Core.MessageTemplateDestinations;
    PaperProperties?: EVA.Core.PaperProperties;
    IsDisabled?: boolean;
  }

  /**
   * Delete a MessageTemplate
   */
  export interface DeleteMessageTemplate {
    /**
     * Entity type: MessageTemplate
     */
    ID: number;
  }

  /**
   * List the MessageTemplates
   */
  export interface ListMessageTemplates {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.MessageTemplateFilter>;
  }

  export interface ListMessageTemplatesResponse {
    Result?: EVA.Core.PagedResult<ListMessageTemplatesResponse.MessageTemplateDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListMessageTemplatesResponse {
    export interface MessageTemplateDto {
      /**
       * Entity type: MessageTemplate
       */
      ID: number;
      Name: string;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID?: number;
      OrganizationUnitName: string;
      /**
       * Entity type: Language
       */
      LanguageID: string;
      /**
       * Entity type: Country
       */
      CountryID: string;
      Type: EVA.Core.MessageTemplateTypes;
      Layout: string;
      Destination: EVA.Core.MessageTemplateDestinations;
      PaperProperties: EVA.Core.PaperProperties;
      IsDisabled: boolean;
      LastModifiedByEmail?: string;
      /**
       * Entity type: User
       */
      LastModifiedByUserID?: number;
      LastModifiedAt?: string;
      ReadOnly: boolean;
    }

  }

  /**
   * Get the history of a MessageTemplate
   */
  export interface GetMessageTemplateHistoryByID {
    /**
     * Entity type: MessageTemplate
     */
    ID: number;
  }

  export interface GetMessageTemplateHistoryByIDResponse {
    Entries: GetMessageTemplateHistoryByIDResponse.MessageTemplateHistoryEntry[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetMessageTemplateHistoryByIDResponse {
    export interface MessageTemplateHistoryEntry {
      /**
       * Entity type: MessageTemplate
       */
      ID: number;
      Name: string;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID?: number;
      /**
       * Entity type: Language
       */
      LanguageID: string;
      /**
       * Entity type: Country
       */
      CountryID: string;
      Header: string;
      Template: string;
      Footer: string;
      Helpers: string;
      Type: EVA.Core.MessageTemplateTypes;
      Layout: string;
      Destination: EVA.Core.MessageTemplateDestinations;
      PaperProperties: EVA.Core.PaperProperties;
      IsDisabled: boolean;
      IsDeleted: boolean;
      ExistedFrom: string;
      ExistedTill?: string;
      ModifiedByEmail?: string;
      /**
       * Entity type: User
       */
      ModifiedByUserID?: number;
      ModifiedAt?: string;
    }

  }

  /**
   * Preview the result of the MessageTemplate
   */
  export interface PreviewMessageTemplate {
    Name: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    Header?: string;
    Template: string;
    Footer?: string;
    Helpers?: string;
    Layout?: string;
    Destination: EVA.Core.MessageTemplateDestinations;
    PaperProperties?: EVA.Core.PaperProperties;
    Type: EVA.Core.MessageTemplateTypes;
    TargetContentType: EVA.Core.MessageTargetContentTypes;
    SampleData?: { [key: string]: any };
    /**
     * Entity type: Station
     */
    StationID?: number;
    /**
     * A preview will be generated, even if device is known
     */
    ForcePreview?: boolean;
  }

  export interface PreviewMessageTemplateResponse {
    Url: string;
    Success: boolean;
    Message: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface SendSampleMailMessageTemplate {
    Name?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    Template?: string;
    Helpers?: string;
    Type: EVA.Core.MessageTemplateTypes;
    Layout?: string;
    Destination: EVA.Core.MessageTemplateDestinations;
    EmailAddress?: string;
    SampleData?: { [key: string]: any };
  }

  /**
   * List the LoyaltyProgramCondition
   */
  export interface ListLoyaltyProgramConditions {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    InitialPageConfig?: EVA.Core.PageTokenConfig<{ [key:string]: string }>;
    PageToken?: string;
  }

  export interface ListLoyaltyProgramConditionsResponse {
    Results?: ListLoyaltyProgramConditionsResponse.Item[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListLoyaltyProgramConditionsResponse {
    export interface Item {
      /**
       * Entity type: LoyaltyProgramCondition
       */
      ID: number;
      /**
       * Entity type: LoyaltyProgram
       */
      LoyaltyProgramID: number;
      BackendID?: string;
      Type: string;
    }

  }

  /**
   * Get a LoyaltyProgramCondition
   */
  export interface GetLoyaltyProgramCondition {
    /**
     * Entity type: LoyaltyProgramCondition
     */
    ID: number;
  }

  export interface GetLoyaltyProgramConditionResponse {
    /**
     * Entity type: LoyaltyProgramCondition
     */
    ID?: number;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    BackendID?: string;
    Type?: string;
    Data?: any;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new LoyaltyProgramCondition
   */
  export interface CreateLoyaltyProgramCondition {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    BackendID?: string;
    Type?: string;
    Data?: any;
  }

  export interface CreateLoyaltyProgramConditionResponse {
    /**
     * Entity type: LoyaltyProgramCondition
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing LoyaltyProgramCondition
   */
  export interface UpdateLoyaltyProgramCondition {
    /**
     * Entity type: LoyaltyProgramCondition
     */
    ID?: number;
    Data?: any;
  }

  /**
   * Delete a LoyaltyProgramCondition
   */
  export interface DeleteLoyaltyProgramCondition {
    /**
     * Entity type: LoyaltyProgramCondition
     */
    ID: number;
  }

  /**
   * List the LoyaltyPrograms
   */
  export interface ListLoyaltyPrograms {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListLoyaltyProgramsFilter>;
    PageToken?: string;
  }

  export interface ListLoyaltyProgramsResponse {
    Results?: ListLoyaltyProgramsResponse.LoyaltyProgramDto[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListLoyaltyProgramsResponse {
    export interface LoyaltyProgramDto {
      /**
       * Entity type: LoyaltyProgram
       */
      ID: number;
      BackendID?: string;
      Name: string;
      Handler: string;
      Options: EVA.Core.LoyaltyProgramOptions;
      /**
       * Entity type: Currency
       */
      BudgetCurrencyID: string;
      StartDate?: string;
      EndDate?: string;
      Status: EVA.Core.LoyaltyProgramStatus;
      DeactivationReason: EVA.Core.LoyaltyProgramDeactivationReasons;
    }

  }

  /**
   * Get a LoyaltyProgram
   */
  export interface GetLoyaltyProgram {
    /**
     * Entity type: LoyaltyProgram
     */
    ID: number;
  }

  export interface GetLoyaltyProgramResponse {
    /**
     * Entity type: LoyaltyProgram
     */
    ID?: number;
    /**
     * Entity type: LoyaltyProgramGroup
     */
    LoyaltyProgramGroupID?: number;
    BackendID?: string;
    Name?: string;
    Description?: string;
    Options?: EVA.Core.LoyaltyProgramOptions;
    StartDate?: string;
    EndDate?: string;
    Status?: EVA.Core.LoyaltyProgramStatus;
    Handler?: string;
    Data?: any;
    ReloadPolicy?: string;
    /**
     * When true, the loyalty program will only be applied when a customer is attached to the order.
     * 
     * When false, the loyalty program can be attached to the order even if there is no customer attached.
     */
    RequireCustomer?: boolean;
    /**
     * When true, the loyalty program will only be applied when a customer is attached to the order that is already subscribed to the loyalty program.
     * Also, this will make the `RequireCustomer` automatically true and `AutoSubscribeCustomer` false.
     * 
     * When false, the loyalty program can be attached to the order if a customer is attached that isn't already subscribed to the loyalty program.
     */
    RequiresSubscribedCustomer?: boolean;
    /**
     * When true, if a non anonymous customer is attached to the order they will be automatically subscribed on finishing the order.
     * When false, the customer will not be subscribed.
     * 
     * This is ignore when`RequiresSubscribedCustomer` or `RequiresSubscriptionValidation` is set to true.
     */
    AutoSubscribeCustomer?: boolean;
    /**
     * When true, the order will require that the attached customer on the order will be validated by providing the UserIdentifier in the `AttachBenefitProgramToOrder` service.
     * Also, this will make the `RequireCustomer` and `RequiresSubscribedCustomer` automatically true and `AutoSubscribeCustomer` false.
     * 
     * When false, this validation isn't required.
     */
    RequiresSubscriptionValidation?: boolean;
    LoyaltyPointUsageOptions?: EVA.Core.LoyaltyPointUsageOptions;
    PointPendingPolicyType?: string;
    PointPendingPolicyData?: any;
    PointExpirationPolicyType?: string;
    PointExpirationPolicyData?: any;
    /**
     * Entity type: Currency
     */
    BudgetCurrencyID?: string;
    Budget?: number;
    UsedBudget?: number;
    BudgetUsagePercentage?: number;
    BudgetRemaining?: number;
    DeactivateWhenBudgetIsReached?: boolean;
    UserMaximumUsage?: number;
    UserBudget?: number;
    /**
     * Entity type: LoyaltyProgram
     */
    SubscriptionID?: number;
    RequireManualUserIdentifier?: boolean;
    UserIdentifierPrefix?: string;
    UserIdentifierStartNumber?: number;
    UserIdentifierSuffix?: string;
    ResubscribeHandling?: EVA.Core.ResubscribeHandlingType;
    AllowUnsubscribeBy?: EVA.Core.AllowUnsubscribeByType;
    DeactivationReason?: EVA.Core.LoyaltyProgramDeactivationReasons;
    Company?: GetLoyaltyProgramResponse.CompanyDto;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetLoyaltyProgramResponse {
    export interface CompanyDto {
      /**
       * Entity type: Company
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Create a new LoyaltyProgram
   */
  export interface CreateLoyaltyProgram {
    /**
     * Entity type: LoyaltyProgramGroup
     */
    LoyaltyProgramGroupID?: number;
    BackendID?: string;
    Name?: string;
    Description?: string;
    Options?: EVA.Core.LoyaltyProgramOptions;
    /**
     * Entity type: Currency
     */
    BudgetCurrencyID?: string;
    StartDate?: string;
    EndDate?: string;
    Status?: EVA.Core.LoyaltyProgramStatus;
    Handler?: string;
    Data?: any;
    ReloadPolicy?: string;
    LoyaltyPointUsageOptions?: EVA.Core.LoyaltyPointUsageOptions;
    PointPendingPolicyType?: string;
    PointPendingPolicyData?: { [key: string]: any };
    PointExpirationPolicyType?: string;
    PointExpirationPolicyData?: { [key: string]: any };
    /**
     * When true, the loyalty program will only be applied when a customer is attached to the order.
     * 
     * When false, the loyalty program can be attached to the order even if there is no customer attached.
     */
    RequireCustomer?: boolean;
    /**
     * When true, the loyalty program will only be applied when a customer is attached to the order that is already subscribed to the loyalty program.
     * Also, this will make the `RequireCustomer` automatically true and `AutoSubscribeCustomer` false.
     * 
     * When false, the loyalty program can be attached to the order if a customer is attached that isn't already subscribed to the loyalty program.
     */
    RequiresSubscribedCustomer?: boolean;
    /**
     * When true, if a non anonymous customer is attached to the order they will be automatically subscribed on finishing the order.
     * When false, the customer will not be subscribed.
     * 
     * This is ignore when`RequiresSubscribedCustomer` or `RequiresSubscriptionValidation` is set to true.
     */
    AutoSubscribeCustomer?: boolean;
    /**
     * When true, the order will require that the attached customer on the order will be validated by providing the UserIdentifier in the `AttachBenefitProgramToOrder` service.
     * Also, this will make the `RequireCustomer` and `RequiresSubscribedCustomer` automatically true and `AutoSubscribeCustomer` false.
     * 
     * When false, this validation isn't required.
     */
    RequiresSubscriptionValidation?: boolean;
    UserMaximumUsage?: number;
    UserBudget?: number;
    /**
     * When set to true, subscribing the user will require a UserIdentifier to be given.
     * Attention!
     * This value will be used to create a subscription when either `RequiredCustomer` or `AutoSubscribeCustomer` is set to true.
     * When this is not the case on create, this can be introduced on update. This value cannot be changed after it is set in either the create or update.
     */
    RequireManualUserIdentifier?: boolean;
    /**
     * Attention!
     * This value will be used to create a subscription when either `RequiredCustomer` or `AutoSubscribeCustomer` is set to true.
     * When this is not the case on create, this can be introduced on update. This value cannot be changed after it is set in either the create or update.
     */
    UserIdentifierPrefix?: string;
    /**
     * Attention!
     * This value will be used to create a subscription when either `RequiredCustomer` or `AutoSubscribeCustomer` is set to true.
     * When this is not the case on create, this can be introduced on update. This value cannot be changed after it is set in either the create or update.
     * Min: 0
     */
    UserIdentifierStartNumber?: number;
    /**
     * Attention!
     * This value will be used to create a subscription when either `RequiredCustomer` or `AutoSubscribeCustomer` is set to true.
     * When this is not the case on create, this can be introduced on update. This value cannot be changed after it is set in either the create or update.
     */
    UserIdentifierSuffix?: string;
    /**
     * Handling when a user is unsubscribed and re-subscribes.
     */
    ResubscribeHandling?: EVA.Core.ResubscribeHandlingType;
    /**
     * Indicates if the subscription can be unsubscribed and if so, who can do the unsubscribe.
     */
    AllowUnsubscribeBy?: EVA.Core.AllowUnsubscribeByType;
    /**
     * Attaches the loyalty program to a consumer company.
     * Entity type: Company
     */
    CompanyID?: number;
  }

  export interface CreateLoyaltyProgramResponse {
    /**
     * Entity type: LoyaltyProgram
     */
    ID: number;
    /**
     * Entity type: Subscription
     */
    SubscriptionID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing LoyaltyProgram
   */
  export interface UpdateLoyaltyProgram {
    /**
     * Entity type: LoyaltyProgram
     */
    ID: number;
    /**
     * Entity type: LoyaltyProgramGroup
     */
    LoyaltyProgramGroupID?: number;
    BackendID?: string;
    Name?: string;
    Description?: string;
    Options?: EVA.Core.LoyaltyProgramOptions;
    /**
     * Entity type: Currency
     */
    BudgetCurrencyID?: string;
    StartDate?: string;
    EndDate?: string;
    Status?: EVA.Core.LoyaltyProgramStatus;
    Data?: any;
    ReloadPolicy?: string;
    LoyaltyPointUsageOptions?: EVA.Core.LoyaltyPointUsageOptions;
    PointPendingPolicyType?: string;
    PointPendingPolicyData?: { [key: string]: any };
    PointExpirationPolicyType?: string;
    PointExpirationPolicyData?: { [key: string]: any };
    /**
     * When true, the loyalty program will only be applied when a customer is attached to the order.
     * 
     * When false, the loyalty program can be attached to the order even if there is no customer attached.
     */
    RequireCustomer?: boolean;
    /**
     * When true, the loyalty program will only be applied when a customer is attached to the order that is already subscribed to the loyalty program.
     * Also, this will make the `RequireCustomer` automatically true and `AutoSubscribeCustomer` false.
     * 
     * When false, the loyalty program can be attached to the order if a customer is attached that isn't already subscribed to the loyalty program.
     */
    RequiresSubscribedCustomer?: boolean;
    /**
     * When true, if a non anonymous customer is attached to the order they will be automatically subscribed on finishing the order.
     * When false, the customer will not be subscribed.
     * 
     * This is ignore when`RequiresSubscribedCustomer` or `RequiresSubscriptionValidation` is set to true.
     */
    AutoSubscribeCustomer?: boolean;
    /**
     * When true, the order will require that the attached customer on the order will be validated by providing the UserIdentifier in the `AttachBenefitProgramToOrder` service.
     * Also, this will make the `RequireCustomer` and `RequiresSubscribedCustomer` automatically true and `AutoSubscribeCustomer` false.
     * 
     * When false, this validation isn't required.
     */
    RequiresSubscriptionValidation?: boolean;
    UserMaximumUsage?: number;
    UserBudget?: number;
    /**
     * When set to true, subscribing the user will require a UserIdentifier to be given. Will be ignored is this was already set on create.
     * Attention!
     * This value will be used to create a subscription when either `RequiredCustomer` or `AutoSubscribeCustomer` is set to true.
     * This value cannot be changed after it is set in either the create or update.
     */
    RequireManualUserIdentifier?: boolean;
    /**
     * Attention!
     * This value will be used to create a subscription when either `RequiredCustomer` or `AutoSubscribeCustomer` is set to true.
     * This value cannot be changed after it is set in either the create or update.
     */
    UserIdentifierPrefix?: string;
    /**
     * Attention!
     * This value will be used to create a subscription when either `RequiredCustomer` or `AutoSubscribeCustomer` is set to true.
     * This value cannot be changed after it is set in either the create or update.
     * Min: 0
     */
    UserIdentifierStartNumber?: number;
    /**
     * Attention!
     * This value will be used to create a subscription when either `RequiredCustomer` or `AutoSubscribeCustomer` is set to true.
     * This value cannot be changed after it is set in either the create or update.
     */
    UserIdentifierSuffix?: string;
    /**
     * Handling when a user is unsubscribed and re-subscribes.
     */
    ResubscribeHandling?: EVA.Core.ResubscribeHandlingType;
    /**
     * Indicates if the subscription can be unsubscribed and if so, who can do the unsubscribe.
     */
    AllowUnsubscribeBy?: EVA.Core.AllowUnsubscribeByType;
    /**
     * Attaches the loyalty program to a consumer company.
     * Entity type: Company
     */
    CompanyID?: number;
  }

  /**
   * Update the budget on the loyalty program group.
   * ATTENTION! When the currency is changed, the used budget registration will be reset to 0!
   * When the budget is lowered below the current used budget and the `DeactivateWhenBudgetIsReached` is set to true, all related programs will be deactivated.
   * When the budget is cleared or raised above the current used budget, or `DeactivateWhenBudgetIsReached` is set to false, and the `ReactivateProgramsWhenPossible` is set to true, all programs that were deactivate by the group budget will be reactivated when possible.
   */
  export interface UpdateLoyaltyProgramBudget {
    /**
     * Entity type: LoyaltyProgram
     */
    ID: number;
    Budget?: number;
    DeactivateWhenBudgetIsReached?: boolean;
    ReactivateProgramWhenPossible?: boolean;
  }

  /**
   * Delete a LoyaltyProgram
   */
  export interface DeleteLoyaltyProgram {
    /**
     * Entity type: LoyaltyProgram
     */
    ID: number;
    /**
     * You can provide the property `Force` to force remaining subscribed users to be unsubscribed. Doing so requires ForceDeleteLoyaltyProgram functionality.
     */
    Force?: boolean;
  }

  /**
   * Get the available loyalty program handlers
   */
  export interface GetLoyaltyProgramHandlers {
  }

  export interface GetLoyaltyProgramHandlersResponse {
    Handlers: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Deposit loyalty points to a user
   */
  export interface DepositLoyaltyPoints {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    /**
     * Entity type: User
     */
    UserID: number;
    /**
     * Min: 1
     */
    Points: number;
  }

  /**
   * Withdraw loyalty points from a user
   */
  export interface WithdrawLoyaltyPoints {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    /**
     * Entity type: User
     */
    UserID: number;
    /**
     * Min: 1
     */
    Points: number;
  }

  /**
   * Rebalance loyalty points of a user
   */
  export interface RebalanceLoyaltyPoints {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    /**
     * Entity type: User
     */
    UserID: number;
    /**
     * If this is set to true, pending points will be kept. When false, all pending points are also removed.
     */
    KeepPendingPoints?: boolean;
    /**
     * If this is set, the balance will be adjusted with the given point balance. This will ignore pending points when they are kept.
     * Min: 0
     */
    NewPointBalance: number;
    /**
     * Expiration date will be calculated based on the loyalty program expiration policy and current date and applied to the given NewPointBalance. Ignored when NewPointBalance is 0.
     */
    ApplyProgramExpiration?: boolean;
    /**
     * Date when the new points will be expired. When null provided, the loyalty points will not expire. When date provided, the new balance will expire on that date. Ignored when `ApplyProgramExpiration` is set to true. Ignored when NewPointBalance is 0.
     */
    ExpirationDate?: string;
  }

  /**
   * Asynchronously rebalance loyalty points of multiple users for a loyalty program.
   * This service is not transactional, meaning that if a mutation fails, other mutations that have already succeeded will not be reverted.
   * The maximum amount of users that can be rebalanced in a single request is 10,000.
   */
  export interface RebalanceLoyaltyPointsForUsers {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    UserLoyaltyPointAdjustments: UserLoyaltyPointAdjustment[];
  }

  export interface UserLoyaltyPointAdjustment {
    /**
     * Entity type: User
     */
    UserID: number;
    KeepPendingPoints: boolean;
    /**
     * How to adjust the balance. Points can be deposited, withdrew or 'rebalanced', the latter will set the balance to the given points.
     */
    AdjustmentType: LoyaltyPointAdjustmentType;
    /**
     * The amount of points to adjust.
     */
    Points: number;
    /**
     * Expiration date will be calculated based on the loyalty program expiration policy and current date and applied to the given `NewPointBalance`. Ignored if the new balance after adjustment is 0.
     */
    ApplyProgramExpiration: boolean;
    /**
     * Date when the new points will be expired. When null provided, the loyalty points will not expire. When date provided, the new balance will expire on that date. Ignored when `ApplyProgramExpiration` is set to true. Ignored if the new balance after adjustment is 0.
     */
    ExpirationDate?: string;
  }

  export const enum LoyaltyPointAdjustmentType {
    Deposit = 0,
    Withdraw = 1,
    Rebalance = 2
  }

  export interface RebalanceLoyaltyPointsForUsersResponse {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    /**
     * The users that were successfully adjusted. Null when no users were successfully adjusted.
     */
    SuccessfullyAdjustedUsers?: RebalanceLoyaltyPointsForUsersResponse.SuccessfullyAdjustedUser[];
    /**
     * The users that failed to adjust. Null when no users failed to adjust.
     */
    FailedToAdjustUsers?: RebalanceLoyaltyPointsForUsersResponse.FailedToAdjustUser[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace RebalanceLoyaltyPointsForUsersResponse {
    export interface SuccessfullyAdjustedUser {
      /**
       * Entity type: User
       */
      UserID: number;
      NewLoyaltyPointBalance: number;
    }

    export interface FailedToAdjustUser {
      /**
       * Entity type: User
       */
      UserID: number;
      KeepPendingPoints: boolean;
      ApplyProgramExpiration: boolean;
      ExpirationDate?: string;
      AdjustmentType: LoyaltyPointAdjustmentType;
      Points: number;
      ErrorIdentifier: string;
    }

  }

  /**
   * Get the available point policies
   */
  export interface GetLoyaltyPointPolicies {
  }

  export interface GetLoyaltyPointPoliciesResponse {
    PendingPolicies: string[];
    ExpirationPolicies: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Attach a loyalty program to an order
   */
  export interface AttachLoyaltyProgramToOrder {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * When set, the UserID will also become required so we can verify the UserIdentifier.
     */
    UserIdentifier?: string;
  }

  /**
   * Get the available loyalty program payment methods for the given order.
   */
  export interface GetOrderLoyaltyProgramPaymentTypes {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetOrderLoyaltyProgramPaymentTypesResponse {
    Options: GetOrderLoyaltyProgramPaymentTypesResponse.Option[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetOrderLoyaltyProgramPaymentTypesResponse {
    export interface Option {
      /**
       * Entity type: LoyaltyProgramPaymentType
       */
      ID: number;
      BackendID?: string;
      /**
       * Entity type: PaymentType
       */
      PaymentTypeID: number;
      PaymentTypeName: string;
      Required: boolean;
      Sequence: number;
    }

  }

  /**
   * Set the optional loyalty program payment types for the order.
   */
  export interface SetOrderLoyaltyProgramPaymentTypes {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * When left empty no optional payment types will be available. Required payment types cannot be unselected.
     * Entity type: LoyaltyProgramPaymentType
     */
    SelectedLoyaltyProgramPaymentTypes: number[];
  }

  /**
   * Detach a loyalty program from an order
   */
  export interface DetachLoyaltyProgramFromOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Get the loyalty program user usage
   */
  export interface GetLoyaltyProgramUserUsage {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProductProperties?: string[];
  }

  export interface GetLoyaltyProgramUserUsageResponse {
    ProductUsages: GetLoyaltyProgramUserUsageResponse.ProductUsage[];
    PaymentUsages: GetLoyaltyProgramUserUsageResponse.PaymentUsage[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetLoyaltyProgramUserUsageResponse {
    export interface ProductUsage {
      /**
       * Entity type: Product
       */
      ProductID: number;
      ProductBackendID: string;
      ProductName: string;
      PrimaryImage: EVA.Core.IProductSearchItemPrimaryImage;
      ConsumedQuantity: number;
    }

    export interface PaymentUsage {
      /**
       * Entity type: LoyaltyProgramPaymentType
       */
      LoyaltyProgramPaymentTypeID: number;
      AmountUsage: number;
      ProductUsage: GetLoyaltyProgramUserUsageResponse.ProductUsage[];
    }

  }

  /**
   * List the loyalty program CustomFieldRequirements
   */
  export interface ListLoyaltyProgramRequiredCustomFields {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    InitialPageConfig?: EVA.Core.PageTokenConfig<{ [key:string]: string }>;
    PageToken?: string;
  }

  export interface ListLoyaltyProgramRequiredCustomFieldsResponse {
    Results?: ListLoyaltyProgramRequiredCustomFieldsResponse.CustomField[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListLoyaltyProgramRequiredCustomFieldsResponse {
    export interface CustomField {
      /**
       * Entity type: CustomField
       */
      ID: number;
      Name: string;
      BackendID: string;
    }

  }

  /**
   * Add a custom field requirement to the loyalty program. NOTE THAT a custom field can only be set once as a requirement.
   */
  export interface AddLoyaltyProgramRequiredCustomField {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    /**
     * Entity type: CustomField
     */
    CustomFieldID: number;
  }

  /**
   * Removes a custom field requirement from a loyalty program.
   */
  export interface RemoveLoyaltyProgramRequiredCustomField {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    /**
     * Entity type: CustomField
     */
    CustomFieldID: number;
  }

  /**
   * List the LoyaltyProgramGroups
   */
  export interface ListLoyaltyProgramGroups {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListLoyaltyProgramGroupFilter>;
    PageToken?: string;
  }

  export interface ListLoyaltyProgramGroupsResponse {
    Results?: ListLoyaltyProgramGroupsResponse.Item[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListLoyaltyProgramGroupsResponse {
    export interface Item {
      /**
       * Entity type: LoyaltyProgramGroup
       */
      ID?: number;
      BackendID?: string;
      Name?: string;
      TaxExemptionCode?: string;
      /**
       * Entity type: Currency
       */
      BudgetCurrencyID?: string;
      Status?: EVA.Core.LoyaltyProgramStatus;
      StartDate?: string;
      EndDate?: string;
      DeactivationReason?: EVA.Core.LoyaltyProgramGroupDeactivationReasons;
    }

  }

  /**
   * Get a LoyaltyProgramGroup
   */
  export interface GetLoyaltyProgramGroup {
    /**
     * Entity type: LoyaltyProgramGroup
     */
    ID: number;
  }

  export interface GetLoyaltyProgramGroupResponse {
    /**
     * Entity type: LoyaltyProgramGroup
     */
    ID?: number;
    BackendID?: string;
    Name?: string;
    StartDate?: string;
    EndDate?: string;
    Status?: EVA.Core.LoyaltyProgramStatus;
    TaxExemptionCode?: string;
    /**
     * Entity type: Currency
     */
    BudgetCurrencyID?: string;
    Budget?: number;
    UsedBudget?: number;
    BudgetUsagePercentage?: number;
    BudgetRemaining?: number;
    DeactivateWhenBudgetIsReached?: boolean;
    DeactivationReason?: EVA.Core.LoyaltyProgramGroupDeactivationReasons;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new LoyaltyProgramGroup
   */
  export interface CreateLoyaltyProgramGroup {
    BackendID?: string;
    Name?: string;
    TaxExemptionCode?: string;
    /**
     * Entity type: Currency
     */
    BudgetCurrencyID?: string;
    StartDate?: string;
    EndDate?: string;
    Status?: EVA.Core.LoyaltyProgramStatus;
  }

  export interface CreateLoyaltyProgramGroupResponse {
    /**
     * Entity type: LoyaltyProgramGroup
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing LoyaltyProgramGroup
   * 
   * ATTENTION!
   * When the currency is changed, the budget usages will be reset to 0!
   * 
   * ATTENTION!
   * When a change to Status, StartDate, EndDate or Currency leads to the group being deactivated, all related loyalty programs will also be deactivated.
   * When a change to Status, StartDate, EndDate or Currency leads to the group being reactivate, all related loyalty programs will also be reactive when the option ReactivateProgramsWhenPossible is set to true. Otherwise all deactivated programs need to be manually reactivated.
   */
  export interface UpdateLoyaltyProgramGroup {
    /**
     * Entity type: LoyaltyProgramGroup
     */
    ID: number;
    BackendID?: string;
    Name?: string;
    TaxExemptionCode?: string;
    /**
     * Entity type: Currency
     */
    BudgetCurrencyID?: string;
    Status?: EVA.Core.LoyaltyProgramStatus;
    StartDate?: string;
    EndDate?: string;
    ReactivateProgramsWhenPossible?: boolean;
  }

  /**
   * Update the budget on the loyalty program group.
   * ATTENTION!
   * When the budget is lowered below the current used budget and the `DeactivateWhenBudgetIsReached` is set to true, all related programs will be deactivated.
   * When the budget is cleared or raised above the current used budget, or `DeactivateWhenBudgetIsReached` is set to false, and the `ReactivateProgramsWhenPossible` is set to true, all programs that were deactivate by the group budget will be reactivated when possible.
   */
  export interface UpdateLoyaltyProgramGroupBudget {
    /**
     * Entity type: LoyaltyProgramGroup
     */
    ID: number;
    /**
     * Min: 0
     */
    Budget?: number;
    DeactivateWhenBudgetIsReached?: boolean;
    ReactivateProgramsWhenPossible?: boolean;
  }

  /**
   * Delete the LoyaltyProgramGroup
   */
  export interface DeleteLoyaltyProgramGroup {
    /**
     * Entity type: LoyaltyProgramGroup
     */
    ID: number;
    /**
     * When set to true, all related programs are deleted. When false, the request will fail when there are related programs active.
     */
    Force?: boolean;
  }

  /**
   * List the LoyaltyProgramPaymentType
   */
  export interface ListLoyaltyProgramPaymentTypes {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    InitialPageConfig?: EVA.Core.PageTokenConfig<{ [key:string]: string }>;
    PageToken?: string;
  }

  export interface ListLoyaltyProgramPaymentTypesResponse {
    Results?: ListLoyaltyProgramPaymentTypesResponse.Item[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListLoyaltyProgramPaymentTypesResponse {
    export interface Item {
      /**
       * Entity type: LoyaltyProgramPaymentType
       */
      ID: number;
      BackendID?: string;
      Sequence: number;
      Required: boolean;
      /**
       * Entity type: PaymentType
       */
      PaymentTypeID: number;
      PaymentTypeName: string;
      ExcludeFromProgramBudget: boolean;
      Budget?: number;
      HasUserLimitations: boolean;
      AllowPartialPayment: boolean;
    }

  }

  /**
   * Get a LoyaltyProgramPaymentType
   */
  export interface GetLoyaltyProgramPaymentType {
    /**
     * Entity type: LoyaltyProgramPaymentType
     */
    ID: number;
  }

  export interface GetLoyaltyProgramPaymentTypeResponse {
    /**
     * Entity type: LoyaltyProgramPaymentType
     */
    ID?: number;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    BackendID?: string;
    Sequence?: number;
    Required?: boolean;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID?: number;
    PaymentTypeName?: string;
    TaxHandling?: EVA.Core.LoyaltyPaymentTaxHandlingType;
    ExcludeFromProgramBudget?: boolean;
    Budget?: number;
    UsedBudget?: number;
    BudgetUsagePercentage?: number;
    BudgetRemaining?: number;
    UserMaximumUsage?: number;
    UserBudget?: number;
    UserBudgetDeduction?: EVA.Core.UserBudgetDeduction;
    MaximumAmountPerOrder?: number;
    MaximumPercentageOfUserBudgetPerOrder?: number;
    ProductLimitation?: LoyaltyProgramProductLimitationData;
    AllowPartialPayment?: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface LoyaltyProgramProductLimitationData {
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchID?: number;
    Filters?: { [key: string]: EVA.Core.FilterModel };
    /**
     * The quantity limit over the entire product limitation product set per user.
     * Min: 1
     */
    OverallQuantityLimitPerUser?: number;
    /**
     * The quantity limit over the entire product limitation product set per order.
     * Min: 1
     */
    OverallQuantityLimitPerOrder?: number;
    /**
     * The quantity limit per product within the product limitation product set per user.
     * Min: 1
     */
    QuantityLimitPerUser?: number;
    /**
     * The quantity limit per product within the product limitation product set per order.
     * Min: 1
     */
    QuantityLimitPerOrder?: number;
  }

  /**
   * Create a new LoyaltyProgramPaymentType
   */
  export interface CreateLoyaltyProgramPaymentType {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    BackendID?: string;
    /**
     * Min: 0
     */
    Sequence?: number;
    AllowPartialPayment?: boolean;
    Required?: boolean;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID?: number;
    TaxHandling?: EVA.Core.LoyaltyPaymentTaxHandlingType;
    ExcludeFromProgramBudget?: boolean;
    /**
     * Min: 0
     */
    Budget?: number;
    /**
     * Min: 1
     */
    UserMaximumUsage?: number;
    /**
     * Min: 0
     */
    UserBudget?: number;
    UserBudgetDeduction?: EVA.Core.UserBudgetDeduction;
    /**
     * Min: 0
     */
    MaximumAmountPerOrder?: number;
    /**
     * Range: 0-100
     */
    MaximumPercentageOfUserBudgetPerOrder?: number;
    ProductLimitation?: LoyaltyProgramProductLimitationData;
  }

  export interface CreateLoyaltyProgramPaymentTypeResponse {
    /**
     * Entity type: LoyaltyProgramPaymentType
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing LoyaltyProgramPaymentType
   */
  export interface UpdateLoyaltyProgramPaymentType {
    /**
     * Entity type: LoyaltyProgramPaymentType
     */
    ID?: number;
    BackendID?: string;
    /**
     * Min: 0
     */
    Sequence?: number;
    AllowPartialPayment?: boolean;
    Required?: boolean;
    TaxHandling?: EVA.Core.LoyaltyPaymentTaxHandlingType;
    ExcludeFromProgramBudget?: boolean;
    /**
     * Min: 0
     */
    Budget?: number;
    /**
     * Min: 1
     */
    UserMaximumUsage?: number;
    /**
     * Min: 0
     */
    UserBudget?: number;
    UserBudgetDeduction?: EVA.Core.UserBudgetDeduction;
    /**
     * Min: 0
     */
    MaximumAmountPerOrder?: number;
    /**
     * Range: 0-100
     */
    MaximumPercentageOfUserBudgetPerOrder?: number;
    ProductLimitation?: LoyaltyProgramProductLimitationData;
  }

  /**
   * Delete a LoyaltyProgramPaymentType
   */
  export interface DeleteLoyaltyProgramPaymentType {
    /**
     * Entity type: LoyaltyProgramPaymentType
     */
    ID: number;
  }

  /**
   * Lists all payment types under the Loyalty payment method that aren't already connected to a loyalty program.
   */
  export interface ListLoyaltyPaymentMethodTypes {
  }

  export interface ListLoyaltyPaymentMethodTypesResponse {
    Types: ListLoyaltyPaymentMethodTypesResponse.LoyaltyPaymentType[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListLoyaltyPaymentMethodTypesResponse {
    export interface LoyaltyPaymentType {
      /**
       * Entity type: PaymentType
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * List the loyalty program pricelists
   */
  export interface ListLoyaltyProgramPriceLists {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    InitialPageConfig?: EVA.Core.PageTokenConfig<{ [key:string]: string }>;
    PageToken?: string;
  }

  export interface ListLoyaltyProgramPriceListsResponse {
    Results?: ListLoyaltyProgramPriceListsResponse.Item[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListLoyaltyProgramPriceListsResponse {
    export interface Item {
      /**
       * Entity type: PriceList
       */
      PriceListID: number;
      /**
       * Entity type: Currency
       */
      CurrencyID: string;
      Name: string;
    }

  }

  /**
   * Add a price list to a loyalty program. NOTE THAT you can only add one pricelist per currency to a loyalty program.
   */
  export interface AddLoyaltyProgramPriceList {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    /**
     * Entity type: PriceList
     */
    PriceListID: number;
  }

  /**
   * Removes a price list from a loyalty program.
   */
  export interface RemoveLoyaltyProgramPriceList {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    /**
     * Entity type: PriceList
     */
    PriceListID: number;
  }

  /**
   * List the loyalty program product limitations
   */
  export interface ListLoyaltyProgramProductLimitations {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    InitialPageConfig?: EVA.Core.PageTokenConfig<{ [key:string]: string }>;
    PageToken?: string;
  }

  export interface ListLoyaltyProgramProductLimitationsResponse {
    Results?: ListLoyaltyProgramProductLimitationsResponse.Item[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListLoyaltyProgramProductLimitationsResponse {
    export interface Item {
      /**
       * Entity type: LoyaltyProgramProductLimitation
       */
      ID: number;
      BackendID?: string;
      Name: string;
      /**
       * The quantity limit over the entire product limitation product set per user.
       * Min: 1
       */
      OverallQuantityLimitPerUser?: number;
      /**
       * The quantity limit over the entire product limitation product set per order.
       * Min: 1
       */
      OverallQuantityLimitPerOrder?: number;
      /**
       * The quantity limit per product within the product limitation product set per user.
       * Min: 1
       */
      QuantityLimitPerUser?: number;
      /**
       * The quantity limit per product within the product limitation product set per order.
       * Min: 1
       */
      QuantityLimitPerOrder?: number;
    }

  }

  /**
   * Get a loyalty program product limitations
   */
  export interface GetLoyaltyProgramProductLimitation {
    /**
     * Entity type: LoyaltyProgramPaymentType
     */
    ID: number;
  }

  export interface GetLoyaltyProgramProductLimitationResponse {
    /**
     * Entity type: LoyaltyProgramProductLimitation
     */
    ID: number;
    BackendID?: string;
    Name: string;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    ApplyToPriceList: boolean;
    ProductLimitation: LoyaltyProgramProductLimitationData;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a loyalty program product limitation.
   */
  export interface CreateLoyaltyProgramProductLimitation {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    BackendID?: string;
    Name: string;
    ApplyToPriceList?: boolean;
    ProductLimitation?: LoyaltyProgramProductLimitationData;
  }

  export interface CreateLoyaltyProgramProductLimitationResponse {
    /**
     * Entity type: LoyaltyProgramProductLimitation
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update a loyalty program product limitation.
   */
  export interface UpdateLoyaltyProgramProductLimitation {
    /**
     * Entity type: LoyaltyProgramProductLimitation
     */
    ID: number;
    BackendID?: string;
    Name: string;
    ApplyToPriceList?: boolean;
    ProductLimitation?: LoyaltyProgramProductLimitationData;
  }

  /**
   * Delete a loyalty program product limitation.
   */
  export interface DeleteLoyaltyProgramProductLimitation {
    /**
     * Entity type: LoyaltyProgramProductLimitation
     */
    ID: number;
  }

  /**
   * List loyalty point rules. Returns a paged response.
   */
  export interface ListPointAwardingRules {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListPointAwardingRuleFilter>;
    PageToken?: string;
  }

  export interface ListPointAwardingRulesResponse {
    Results?: ListPointAwardingRulesResponse.Rule[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPointAwardingRulesResponse {
    export interface Rule {
      /**
       * Entity type: PointAwardingRule
       */
      ID: number;
      /**
       * Entity type: LoyaltyProgram
       */
      LoyaltyProgramID: number;
      LoyaltyProgramName: string;
      /**
       * Entity type: OrganizationUnitSet
       */
      OrganizationUnitSetID: number;
      OrganizationUnitSetName: string;
      Name: string;
      Description?: string;
      Enabled: boolean;
      StartDate: string;
      EndDate?: string;
    }

  }

  /**
   * Get loyalty point rule.
   */
  export interface GetPointAwardingRule {
    /**
     * Entity type: PointAwardingRule
     */
    ID: number;
  }

  export interface GetPointAwardingRuleResponse {
    /**
     * Entity type: PointAwardingRule
     */
    ID?: number;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    LoyaltyProgramName?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    OrganizationUnitSetName?: string;
    Name?: string;
    Description?: string;
    MarketingDescription?: string;
    BackendID?: string;
    BackendSystemID?: string;
    Enabled?: boolean;
    StartDate?: string;
    EndDate?: string;
    ApplyRecursive?: boolean;
    PointsToAward?: number;
    PointPendingPolicyType?: string;
    PointPendingPolicyData?: any;
    PointExpirationPolicyType?: string;
    PointExpirationPolicyData?: any;
    Conditions?: GetPointAwardingRuleResponse.Condition[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetPointAwardingRuleResponse {
    export interface Condition {
      /**
       * Entity type: PointAwardingCondition
       */
      ID: number;
      Type: string;
      Data?: any;
    }

  }

  /**
   * Create a point awarding rule.
   */
  export interface CreatePointAwardingRule {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Name?: string;
    Description?: string;
    MarketingDescription?: string;
    BackendID?: string;
    Enabled?: boolean;
    StartDate?: string;
    EndDate?: string;
    ApplyRecursive?: boolean;
    PointsToAward?: number;
    PointPendingPolicyType?: string;
    PointPendingPolicyData?: { [key: string]: any };
    PointExpirationPolicyType?: string;
    PointExpirationPolicyData?: { [key: string]: any };
    Conditions?: CreatePointAwardingRule.Condition[];
  }

  export namespace CreatePointAwardingRule {
    export interface Condition {
      BackendID?: string;
      Type: string;
      Data?: { [key: string]: any };
    }

  }

  export interface CreatePointAwardingRuleResponse {
    /**
     * Entity type: PointAwardingRule
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update a point awarding rule
   */
  export interface UpdatePointAwardingRule {
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: PointAwardingRule
     */
    ID: number;
    Name?: string;
    Description?: string;
    MarketingDescription?: string;
    BackendID?: string;
    Enabled?: boolean;
    StartDate?: string;
    EndDate?: string;
    ApplyRecursive?: boolean;
    PointsToAward?: number;
    PointPendingPolicyType?: string;
    PointPendingPolicyData?: { [key: string]: any };
    PointExpirationPolicyType?: string;
    PointExpirationPolicyData?: { [key: string]: any };
    Conditions?: UpdatePointAwardingRule.Condition[];
  }

  export namespace UpdatePointAwardingRule {
    export interface Condition {
      /**
       * Entity type: PointAwardingCondition
       */
      ID?: number;
      BackendID?: string;
      Type: string;
      Data?: { [key: string]: any };
    }

  }

  /**
   * Enable a point awarding rule
   */
  export interface EnablePointAwardingRule {
    /**
     * Entity type: PointAwardingRule
     */
    ID: number;
  }

  /**
   * Disable a point awarding rule
   */
  export interface DisablePointAwardingRule {
    /**
     * Entity type: PointAwardingRule
     */
    ID: number;
  }

  /**
   * Archive a point awarding rule
   */
  export interface ArchivePointAwardingRule {
    /**
     * Entity type: PointAwardingRule
     */
    ID: number;
  }

  /**
   * Push a LoyaltyProgramGroup.
   * If it doesn't exist it will be created, otherwise is will be updated.
   * 
   * ATTENTION!
   * When the currency is changed, the budget usages will be reset to 0!
   * 
   * ATTENTION!
   * When a change to Status, StartDate, EndDate or Currency leads to the group being deactivated, all related loyalty programs will also be deactivated.
   * When a change to Status, StartDate, EndDate or Currency leads to the group being reactivated, all related loyalty programs will also be reactivated when the option ReactivateProgramsWhenPossible is set to true. Otherwise all deactivated programs need to be manually reactivated.
   * 
   * ATTENTION!
   * When the budget is lowered below the current used budget and the `DeactivateWhenBudgetIsReached` is set to true, all related programs will be deactivated.
   * When the budget is cleared or raised above the current used budget, or `DeactivateWhenBudgetIsReached` is set to false, and the `ReactivateProgramsWhenPossible` is set to true, all programs that were deactivate by the group budget will be reactivated when possible.
   */
  export interface PushLoyaltyProgramGroup {
    ID: string;
    Name: string;
    TaxExemptionCode?: string;
    /**
     * Entity type: Currency
     */
    BudgetCurrencyID?: string;
    /**
     * Min: 0
     */
    Budget?: number;
    DeactivateWhenBudgetIsReached?: boolean;
    StartDate?: string;
    EndDate?: string;
    Status: EVA.Core.LoyaltyProgramStatus;
  }

  export interface PushLoyaltyProgramGroupResponse {
    /**
     * Entity type: LoyaltyProgram
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get the predefined LedgerClasses, in most services it is allowed to use other classes.
   */
  export interface GetLedgerClasses {
  }

  export interface GetLedgerClassesResponse {
    LedgerClasses: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the inquiries
   */
  export interface ListInquiries {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListInquiriesFilter>;
    PageToken?: string;
  }

  export interface ListInquiriesResponse {
    Results?: InquiryData[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface InquiryData {
    /**
     * Entity type: Inquiry
     */
    ID: number;
    Name: string;
    Description?: string;
  }

  /**
   * Creates a new inquiry
   */
  export interface CreateInquiry {
    Name: string;
    Description?: string;
    PromptUser?: boolean;
    OneTimeUseOnly?: boolean;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    Items?: CreateInquiry.ItemData[];
  }

  export namespace CreateInquiry {
    export interface ItemData {
      Name: string;
      Description?: string;
      IsRequired: boolean;
      /**
       * Min: 0
       */
      Sequence: number;
      /**
       * Entity type: CustomField
       */
      CustomFieldID: number;
    }

  }

  export interface CreateInquiryResponse {
    /**
     * Entity type: Inquiry
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an inquiry
   */
  export interface UpdateInquiry {
    /**
     * Entity type: Inquiry
     */
    ID: number;
    Name?: string;
    Description?: string;
    PromptUser?: boolean;
    OneTimeUseOnly?: boolean;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
  }

  /**
   * Delete an inquiry
   */
  export interface DeleteInquiry {
    /**
     * Entity type: Inquiry
     */
    ID: number;
  }

  /**
   * Creates an inquiry item
   */
  export interface CreateInquiryItem {
    /**
     * Entity type: Inquiry
     */
    InquiryID: number;
    Name: string;
    Description?: string;
    IsRequired?: boolean;
    /**
     * Min: 0
     */
    Sequence: number;
    /**
     * Entity type: CustomField
     */
    CustomFieldID: number;
  }

  export interface CreateInquiryItemResponse {
    /**
     * Entity type: InquiryItem
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Updates an inquiry item
   */
  export interface UpdateInquiryItem {
    /**
     * Entity type: InquiryItem
     */
    ID: number;
    Name?: string;
    Description?: string;
    IsRequired?: boolean;
    /**
     * Min: 0
     */
    Sequence?: number;
  }

  /**
   * Deletes an inquiry item
   */
  export interface DeleteInquiryItem {
    /**
     * Entity type: InquiryItem
     */
    ID: number;
  }

  /**
   * Create a new device
   */
  export interface CreateDevice {
    Name?: string;
    BackendID?: string;
    /**
     * Entity type: DeviceType
     */
    TypeID?: number;
    Address?: string;
    ProxyAddress?: string;
    /**
     * Entity type: Station
     */
    StationID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    AssemblyName?: string;
    Data?: { [key: string]: any };
    /**
     * Entity type: PrinterType
     */
    PrinterTypeID?: number;
  }

  export interface CreateDeviceResponse {
    /**
     * Entity type: Device
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Updates a device
   */
  export interface UpdateDevice {
    /**
     * Entity type: Device
     */
    ID: number;
    Name?: string;
    BackendID?: string;
    /**
     * Entity type: DeviceType
     */
    TypeID?: number;
    Address?: string;
    ProxyAddress?: string;
    /**
     * Entity type: Station
     */
    StationID?: number;
    /**
     * Entity type: PrinterType
     */
    PrinterTypeID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    AssemblyName?: string;
    Data?: { [key: string]: any };
  }

  /**
   * Delete a device
   */
  export interface DeleteDevice {
    /**
     * Entity type: Device
     */
    ID: number;
  }

  /**
   * Get the configuration required to set up a CustomerFacingDisplay.
   */
  export interface GetCFDConfiguration {
    GlobalID: string;
  }

  export interface GetCFDConfigurationResponse {
    /**
     * Entity type: Device
     */
    ID: number;
    GlobalID: string;
    /**
     * Entity type: Station
     */
    StationID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    CloudEndpoint: string;
    LiveGuardEndpoint?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get a qrcode to configure/enroll a device when available.
   * 
   * At this moment the supported DeviceTypes are:
   *  - CustomerDisplay
   */
  export interface GetConfigurationQrForDevice {
    /**
     * Entity type: Device
     */
    DeviceID: number;
  }

  export interface GetConfigurationQrForDeviceResponse {
    QrData?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Creates a new OpenCashDrawerReason. Name and Description can both be localized through the LocalizeOpenCashDrawerReason service later.
   */
  export interface CreateOpenCashDrawerReason {
    Name: string;
    Description?: string;
  }

  export interface CreateOpenCashDrawerReasonResponse {
    /**
     * Entity type: OpenCashDrawerReason
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Updates an existing OpenCashDrawerReason with a new Name and Description.
   */
  export interface UpdateOpenCashDrawerReason {
    /**
     * Entity type: OpenCashDrawerReason
     */
    ID: number;
    Name: string;
    Description?: string;
  }

  /**
   * Deletes an OpenCashDrawerReason
   */
  export interface DeleteOpenCashDrawerReason {
    /**
     * Entity type: OpenCashDrawerReason
     */
    ID: number;
  }

  /**
   * Creates a localized Name and Description for the OpenCashDrawerReason.
   * Language is required, Country is optional.
   */
  export interface LocalizeOpenCashDrawerReason {
    /**
     * Entity type: OpenCashDrawerReason
     */
    ID: number;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    Name?: string;
    Description?: string;
  }

  /**
   * Print a qrcode on a thermal receipt.
   * 
   * It's required to select a Station, this can be done by providing the `EVA-StationID` header, or by setting the StationID property.
   * 
   * Also the MessageTemplate `QRCodePrintingTemplate` can be configured in Stencil.
   */
  export interface PrintQRCode {
    /**
     * Only required when not providing the Station in the header
     * Entity type: Station
     */
    StationID?: number;
    QRData: string;
  }

  /**
   * Create a new station for an OrganizationUnit.
   */
  export interface CreateStation {
    BackendID?: string;
    Name?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Special identifier for fiscalized stations, some certifications require this
     */
    FiscalSystemID?: string;
    /**
     * Used to differentiate between fiscalized stations and other (e.g. safes) devices
     */
    IsPointOfSale?: boolean;
    /**
     * Optional additional custom fields
     */
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
  }

  export namespace CreateStation {
    export interface StationToCreate {
      BackendID?: string;
      Name: string;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      /**
       * Special identifier for fiscalized stations, some certifications require this
       */
      FiscalSystemID?: string;
      /**
       * Used to differentiate between fiscalized stations and other (e.g. safes) devices
       */
      IsPointOfSale?: boolean;
      /**
       * Optional additional custom fields
       */
      CustomFields?: EVA.Core.CustomFieldKeyValue[];
    }

  }

  export interface CreateStationResponse {
    /**
     * Entity type: Station
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Updates a station.
   */
  export interface UpdateStation {
    /**
     * Entity type: Station
     */
    ID: number;
    Name?: string;
    BackendID?: string;
    /**
     * Optional additional custom fields
     */
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
  }

  /**
   * Delete a station
   */
  export interface DeleteStation {
    /**
     * Entity type: Station
     */
    ID: number;
  }

  export interface DeleteStationResponse {
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Returns available handlers for gift card configurations
   */
  export interface GetGiftCardHandlers {
  }

  export interface GetGiftCardHandlersResponse {
    Handlers: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the GiftCardConfigurations
   * 
   * `GiftCardConfiguration`: an item that describes the giftcard properties of a product with type GiftCard
   */
  export interface ListGiftCardConfigurations {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListGiftCardConfigurationsFilter>;
    PageToken?: string;
  }

  export interface ListGiftCardConfigurationsResponse {
    Results?: ListGiftCardConfigurationsResponse.GiftCardConfigurationDto[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListGiftCardConfigurationsResponse {
    export interface GiftCardConfigurationDto {
      /**
       * Entity type: GiftCardConfiguration
       */
      ID: number;
      Name: string;
      Handler: string;
      CardType?: string;
      Data?: any;
      UsageType: EVA.Core.GiftCardConfigurationUsageTypes;
      AllowRefundWithoutTransaction: boolean;
      AllowCurrencyConversion: boolean;
      AllowMultipleCardsPayment: boolean;
    }

  }

  /**
   * Get a single GiftCardConfiguration
   */
  export interface GetGiftCardConfiguration {
    /**
     * Entity type: GiftCardConfiguration
     */
    ID: number;
  }

  export interface GetGiftCardConfigurationResponse {
    Name: string;
    UsageType: EVA.Core.GiftCardConfigurationUsageTypes;
    Handler: string;
    /**
     * Some gift card handlers are able to handle multiple types of cards. With this property you can set the card the handler should work with.
     */
    CardType?: string;
    Data?: any;
    AllowRefundWithoutTransaction: boolean;
    AllowCurrencyConversion: boolean;
    AllowMultipleCardsPayment?: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new GiftCardConfiguration
   */
  export interface CreateGiftCardConfiguration {
    Name: string;
    UsageType: EVA.Core.GiftCardConfigurationUsageTypes;
    Handler: string;
    /**
     * Some gift card handlers are able to handle multiple types of cards. With this property you can set the card the handler should work with.
     */
    CardType?: string;
    Data?: any;
    AllowRefundWithoutTransaction: boolean;
    AllowCurrencyConversion: boolean;
    AllowMultipleCardsPayment?: boolean;
  }

  export interface CreateGiftCardConfigurationResponse {
    /**
     * Entity type: GiftCardConfiguration
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing GiftCardConfiguration
   */
  export interface UpdateGiftCardConfiguration {
    /**
     * Entity type: GiftCardConfiguration
     */
    ID: number;
    Name?: string;
    UsageType?: EVA.Core.GiftCardConfigurationUsageTypes;
    Handler?: string;
    /**
     * Some gift card handlers are able to handle multiple types of cards. With this property you can set the card the handler should work with.
     */
    CardType?: string;
    Data?: any;
    AllowRefundWithoutTransaction?: boolean;
    AllowCurrencyConversion?: boolean;
    AllowMultipleCardsPayment?: boolean;
  }

  /**
   * Delete a GiftCardConfiguration
   */
  export interface DeleteGiftCardConfiguration {
    /**
     * Entity type: GiftCardConfiguration
     */
    ID: number;
  }

  /**
   * List the ProductGiftCards
   * 
   * `ProductGiftCard`: an item that describes the giftcard properties of a product with type GiftCard
   */
  export interface ListProductGiftCards {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListProductGiftCardsFilter>;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProductProperties?: string[];
  }

  export interface ListProductGiftCardsResponse {
    Result?: EVA.Core.PagedResult<ListProductGiftCardsResponse.ProductGiftCardDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListProductGiftCardsResponse {
    export interface ProductGiftCardDto {
      /**
       * Entity type: ProductGiftCard
       */
      ID?: number;
      /**
       * Entity type: Product
       */
      ProductID?: number;
      ProductName?: string;
      Product?: any;
      /**
       * Entity type: GiftCardConfiguration
       */
      GiftCardConfigurationID?: number;
      GiftCardConfigurationName?: string;
      /**
       * Communication options for digital giftcards
       */
      CommunicationOptions?: EVA.Core.ProductGiftCardCommunicationOptions;
      IsDigital?: boolean;
      IsReturnable?: boolean;
    }

  }

  /**
   * Create a new ProductGiftCard
   */
  export interface CreateProductGiftCard {
    /**
     * Entity type: GiftCardConfiguration
     */
    GiftCardConfigurationID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    IsDigital?: boolean;
    /**
     * Communication options for digital giftcards
     */
    CommunicationOptions?: EVA.Core.ProductGiftCardCommunicationOptions;
    /**
     * @default true
     */
    IsReturnable?: boolean;
  }

  export interface CreateProductGiftCardResponse {
    /**
     * Entity type: ProductGiftCard
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing ProductGiftCard
   */
  export interface UpdateProductGiftCard {
    /**
     * Entity type: ProductGiftCard
     */
    ID: number;
    /**
     * Entity type: GiftCardConfiguration
     */
    GiftCardConfigurationID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    IsDigital?: boolean;
    /**
     * Communication options for digital giftcards
     */
    CommunicationOptions?: EVA.Core.ProductGiftCardCommunicationOptions;
    IsReturnable?: boolean;
  }

  /**
   * Delete a ProductGiftCard
   */
  export interface DeleteProductGiftCard {
    /**
     * Entity type: ProductGiftCard
     */
    ID: number;
  }

  /**
   * List the ExchangeRates
   */
  export interface ListExchangeRates {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListExchangeRatesFilter>;
  }

  export interface ListExchangeRatesResponse {
    Result?: EVA.Core.PagedResult<ListExchangeRatesResponse.ExchangeRateDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListExchangeRatesResponse {
    export interface ExchangeRateDto {
      /**
       * Entity type: ExchangeRate
       */
      ID: number;
      /**
       * Entity type: Currency
       */
      BaseCurrencyID: string;
      /**
       * Entity type: Currency
       */
      CurrencyID: string;
      ExchangeRate: number;
    }

  }

  /**
   * Returns a cash expense type by its ID.
   */
  export interface GetCashExpenseTypeByID {
    /**
     * Entity type: CashExpenseType
     */
    ID: number;
  }

  export interface GetCashExpenseTypeByIDResponse {
    /**
     * Entity type: CashExpenseType
     */
    ID: number;
    BackendID?: string;
    /**
     * Entity type: DeviceType
     */
    DeviceTypeID?: number;
    Name: string;
    Description?: string;
    LedgerClassID?: string;
    DeviceType?: EVA.Core.FlagsEnumDto;
    AmountType: EVA.Core.CashExpenseAmountTypes;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID?: number;
    TaxCodeName?: string;
    OrganizationUnitSet?: CashExpenseTypeOrganizationUnitSet;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface CashExpenseTypeOrganizationUnitSet {
    /**
     * Entity type: OrganizationUnitSet
     */
    ID: number;
    Name: string;
  }

  /**
   * Creates a new cash expense type.
   * It's not possible to create a cash expense type with a name that is already in use.
   * 
   * The amount type specifies whether or not this type can be used to also register positive 'expenses' (so: income).
   * An example of this might be tips left by a customer.
   */
  export interface CreateCashExpenseType {
    BackendID?: string;
    /**
     * Entity type: DeviceType
     */
    DeviceTypeID?: number;
    Name: string;
    Description?: string;
    LedgerClassID?: string;
    AmountType: EVA.Core.CashExpenseAmountTypes;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
  }

  export interface CreateCashExpenseTypeResponse {
    /**
     * Entity type: CashExpenseType
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Updates a cash expense type. All properties except for its Name can be updated.
   */
  export interface UpdateCashExpenseType {
    /**
     * Entity type: CashExpenseType
     */
    ID: number;
    Name?: string;
    Description?: string;
    LedgerClassID?: string;
    BackendID?: string;
    /**
     * Entity type: DeviceType
     */
    DeviceTypeID?: number;
    AmountType: EVA.Core.CashExpenseAmountTypes;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID?: number;
  }

  /**
   * Deletes a cash expense type.
   */
  export interface DeleteCashExpenseType {
    /**
     * Entity type: CashExpenseType
     */
    ID: number;
  }

  /**
   * Returns a paged result of all the cash expsense types.
   */
  export interface ListCashExpenseTypes {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListCashExpenseTypesFilter>;
    PageToken?: string;
  }

  export interface ListCashExpenseTypesResponse {
    Results?: ListCashExpenseTypesResponse.Model[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCashExpenseTypesResponse {
    export interface Model {
      /**
       * Entity type: CashExpenseType
       */
      ID?: number;
      BackendID?: string;
      Name?: string;
      Description?: string;
      LedgerClassID?: string;
      /**
       * Entity type: DeviceType
       */
      DeviceTypeID?: number;
      DeviceType?: EVA.Core.FlagsEnumDto;
      AmountType?: EVA.Core.CashExpenseAmountTypes;
      /**
       * Entity type: TaxCode
       */
      TaxCodeID?: number;
      TaxCodeName?: string;
      OrganizationUnitSet?: CashExpenseTypeOrganizationUnitSet;
    }

  }

  /**
   * Returns a paged result of all the cash correction reasons.
   */
  export interface ListCashCorrectionReasons {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListCashCorrectionReasonsFilter>;
    PageToken?: string;
  }

  export interface ListCashCorrectionReasonsResponse {
    Results?: ListCashCorrectionReasonsResponse.Model[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCashCorrectionReasonsResponse {
    export interface Model {
      /**
       * Entity type: CashCorrectionReason
       */
      ID: number;
      BackendID?: string;
      Name: string;
      Sequence: number;
    }

  }

  /**
   * -
   */
  export interface CorrectProductCostPriceLedgers {
    Corrections: CorrectProductCostPriceLedgers.Correction[];
  }

  export namespace CorrectProductCostPriceLedgers {
    export interface Correction {
      /**
       * Entity type: ProductCostPriceLedger
       */
      ID: number;
      UnitCost: number;
    }

  }

  /**
   * You can only export up to 100 products at a time.
   */
  export interface ExportProductCostPriceLedgerSummary {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetIDs?: number[];
    /**
     * Filters to select which products to export. Will be ignored if `ProductIDs` is set. Required if `ProductIDs` is not set.
     */
    ProductSearchFilters?: { [key: string]: EVA.Core.FilterModel };
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    EmailAddress?: string;
    SplitUnitCost?: boolean;
  }

  /**
   * This service lets you view the ProductCostPriceLedger, optionally filtered by ProductID/OrganizationUnitID and others.
   * 
   * The ProductCostPriceLedger is used to determine the cost prices of stock for OrganizationUnits that use CostPriceCalculationMethod = Fifo.
   * 
   * For those OrganizationUnits, whenever stock is received in them, a record is stored in the ProductCostPriceLedger noting the quantity and the purchase price of that stock and then whenever
   * stock is reduced this ledger is consulted in a first-in-first-out manner to determine the cost price of that stock mutation. This service gives you insight into that ledger.
   */
  export interface ListProductCostPriceLedger {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListProductCostPriceLedgerFilter>;
    PageToken?: string;
  }

  export interface ListProductCostPriceLedgerResponse {
    Results?: EVA.Core.ListProductCostPriceLedgerItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListStockMutationUnitCostSourceLedger {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListStockMutationUnitCostSourceLedgerFilter>;
    PageToken?: string;
  }

  export interface ListStockMutationUnitCostSourceLedgerResponse {
    Results?: EVA.Core.ListStockMutationUnitCostSourceLedgerItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new entity field validator
   */
  export interface CreateEntityFieldValidator {
    Entity: EVA.Core.EntityFieldValidatorEntityTypes;
    EntityFieldName: string;
    ValidatorType: EVA.Core.EntityFieldValidatorType;
    ApplyFor: EVA.Core.EntityFieldValidatorUserTypes;
    /**
     * This must be of object that inherits the class EntityFieldValidatorBase. For example StringEntityFieldValidator or DefaultEntityFieldValidator
     */
    ValidatorData: { [key: string]: any };
  }

  export interface CreateEntityFieldValidatorResponse {
    /**
     * Entity type: EntityFieldValidator
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get a entity field validator
   */
  export interface GetEntityFieldValidator {
    /**
     * Entity type: EntityFieldValidator
     */
    ID: number;
  }

  export interface GetEntityFieldValidatorResponse {
    ID: number;
    Entity: EVA.Core.EntityFieldValidatorEntityTypes;
    ValidatorType: EVA.Core.EntityFieldValidatorType;
    ApplyFor: EVA.Core.EntityFieldValidatorUserTypes;
    EntityFieldName: string;
    ValidatorData: { [key: string]: any };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update a entity field validator
   */
  export interface UpdateEntityFieldValidator {
    /**
     * Entity type: EntityFieldValidator
     */
    ID: number;
    ApplyFor?: EVA.Core.EntityFieldValidatorUserTypes;
    ValidatorData?: { [key: string]: any };
  }

  /**
   * Delete a entity field validator
   */
  export interface DeleteEntityFieldValidator {
    /**
     * Entity type: EntityFieldValidator
     */
    ID: number;
  }

  /**
   * list all entity field validators
   */
  export interface ListEntityFieldValidators {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListEntityFieldValidatorsFilter>;
    PageToken?: string;
  }

  export interface ListEntityFieldValidatorsResponse {
    Results?: ListEntityFieldValidatorsResponse.ListEntityFieldValidatorItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListEntityFieldValidatorsResponse {
    export interface ListEntityFieldValidatorItem {
      /**
       * Entity type: EntityFieldValidator
       */
      ID: number;
      Entity: EVA.Core.EntityFieldValidatorEntityTypes;
      ValidatorType: EVA.Core.EntityFieldValidatorType;
      ApplyFor: EVA.Core.EntityFieldValidatorUserTypes;
      EntityFieldName: string;
      ValidatorData: { [key: string]: any };
    }

  }

  /**
   * Get all entity field validators for given entity
   */
  export interface GetFieldValidatorsForEntity {
    EntityType: EVA.Core.EntityFieldValidatorEntityTypes;
  }

  export interface GetFieldValidatorsForEntityResponse {
    Validators?: GetFieldValidatorsForEntityResponse.Validator[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetFieldValidatorsForEntityResponse {
    export interface Validator {
      ValidatorType: EVA.Core.EntityFieldValidatorType;
      EntityFieldName: string;
      ValidatorData: { [key: string]: any };
    }

  }

  /**
   * List all entity field validator entities and entity names
   */
  export interface ListEntityFieldValidatorEntityFieldNames {
  }

  export interface ListEntityFieldValidatorEntityFieldNamesResponse {
    EntityFieldValidatorEntityFields: ListEntityFieldValidatorEntityFieldNamesResponse.EntityFieldValidatorEntityField[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListEntityFieldValidatorEntityFieldNamesResponse {
    export interface EntityFieldValidatorEntityField {
      Entity: EVA.Core.EntityFieldValidatorEntityTypes;
      EntityFieldName: string;
      Type: string;
    }

  }

  /**
   * Create endpoint configurations.
   * 
   * Endpoint Configurations allow you to configure specific endpoints taht can be used for example for EventExportConfigurations.
   * 
   * - Make sure to catch & store the `SecretKey1` and `SecretKey2`, as there will be no other way of retrieving them after this service call!
   */
  export interface CreateEndpointConfiguration {
    /**
     * A name to identify the configuration.
     */
    Name: string;
    /**
     * An identifier for the configuration.
     */
    BackendID?: string;
    /**
     * The status of the configuration.
     */
    Status: EVA.Core.EndpointConfigurationStatus;
    /**
     * The endpoint to send the events to. This must be a valid HTTPS endpoint.
     */
    Endpoint: string;
    /**
     * Authorization configuration used when calling this endpoint.
     */
    Authorization?: EndpointConfigurationAuthorizationModel;
    /**
     * Timeout after which requests are cancelled. Defaults to 5 seconds. Not recommended to change.
     */
    TimeoutSeconds?: number;
    /**
     * If true, the endpoint will use string IDs instead of long IDs.
     */
    UseStringIDs?: boolean;
    /**
     * If false, the endpoint will also send `null` values. Preferred is true.
     */
    IgnoreNullValues?: boolean;
  }

  export interface EndpointConfigurationAuthorizationModel {
    /**
     * This will result in an authorization header that looks like: `Authorization: Bearer TOKEN`
     */
    StaticBearerToken?: string;
    /**
     * This will result in an authorization header that looks like: `Authorization: TOKEN`. Use this only when the other options are not sufficient.
     */
    StaticUnschemedToken?: string;
    /**
     * Configuration for Mutual TLS (mTLS)
     */
    ClientCertificate?: EndpointConfigurationCertificateModel;
  }

  export interface EndpointConfigurationCertificateModel {
    /**
     * A client certificate that can be used for mTLS. Must be X509 in PKCS12 format. Also, it must not be expired, have a private key and have clientAuth in it's extended key usage.
     */
    Certificate: string;
    /**
     * The password that is used to encrypt the certificate.
     */
    Password?: string;
  }

  export interface CreateEndpointConfigurationResponse {
    /**
     * Entity type: EndpointConfiguration
     */
    ID: number;
    /**
     * Make sure to store this information, this is the only time EVA will expose it for you!
     */
    SecretKey1: string;
    /**
     * Make sure to store this information, this is the only time EVA will expose it for you!
     */
    SecretKey2: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Service for updating a existing `EndpointConfiguration`
   */
  export interface UpdateEndpointConfiguration {
    /**
     * Entity type: EndpointConfiguration
     */
    ID: number;
    Name?: string;
    BackendID?: string;
    Status?: EVA.Core.EndpointConfigurationStatus;
    Endpoint?: string;
    /**
     * Authorization configuration used when calling this endpoint.
     */
    Authorization?: EndpointConfigurationAuthorizationUpdateModel;
    /**
     * Timeout after which requests are cancelled. Defaults to 5 seconds. Not recommended to change.
     */
    TimeoutInSeconds?: number;
    /**
     * If true, the endpoint will use string IDs instead of long IDs.
     */
    UseStringIDs?: boolean;
    /**
     * If false, the endpoint will also send `null` values. Default and preferred is true.
     */
    IgnoreNullValues?: boolean;
  }

  export interface EndpointConfigurationAuthorizationUpdateModel {
    /**
     * This will result in an authorization header that looks like: `Authorization: Bearer TOKEN`
     */
    StaticBearerToken?: string;
    /**
     * This will result in an authorization header that looks like: `Authorization: TOKEN`. Use this only when the other options are not sufficient.
     */
    StaticUnschemedToken?: string;
    /**
     * Configuration for Mutual TLS (mTLS)
     */
    ClientCertificate?: EndpointConfigurationCertificateUpdateModel;
  }

  export interface EndpointConfigurationCertificateUpdateModel {
    /**
     * A client certificate that can be used for mTLS. Must be X509 in PKCS12 format. Also, it must not be expired, have a private key and have clientAuth in it's extended key usage.
     */
    Certificate?: string;
    /**
     * The password that is used to encrypt the certificate.
     */
    Password?: string;
  }

  /**
   * Service for deleting a existing `EndpointConfiguration`
   */
  export interface DeleteEndpointConfiguration {
    /**
     * Entity type: EndpointConfiguration
     */
    ID: number;
  }

  /**
   * Service for retrieving an existing `EndpointConfiguration`.
   */
  export interface GetEndpointConfiguration {
    /**
     * Entity type: EndpointConfiguration
     */
    ID: number;
  }

  export interface GetEndpointConfigurationResponse {
    Result: EndpointConfigurationModel;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface EndpointConfigurationModel {
    /**
     * Entity type: EndpointConfiguration
     */
    ID: number;
    Name: string;
    BackendID?: string;
    Status: EVA.Core.EndpointConfigurationStatus;
    Endpoint: string;
    SecretKey1: string;
    SecretKey2: string;
    Authorization?: EndpointConfigurationAuthorizationModel;
    TimeoutInSeconds?: number;
    UseStringIDs?: boolean;
    IgnoreNullValues?: boolean;
    ErrorReason?: string;
    LastAccessTime?: string;
  }

  /**
   * Service for retrieving a list of existing `EndpointConfiguration`'s
   */
  export interface GetEndpointConfigurations {
  }

  export interface GetEndpointConfigurationsResponse {
    Items: EndpointConfigurationModel[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Service for generating a new SecretKey for an `EndpointConfiguration`.
   * 
   * - Make sure to catch & store the `SecretKey1` or `SecretKey2`, as there will be no other way of retrieving them after this service call!
   */
  export interface RotateEndpointConfigurationKey {
    /**
     * Entity type: EndpointConfiguration
     */
    ID: number;
    KeyID: number;
  }

  export interface RotateEndpointConfigurationKeyResponse {
    SecretKey1?: string;
    SecretKey2?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the DiscountCampaigns
   */
  export interface ListDiscountCampaigns {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListDiscountCampaignsFilter>;
  }

  export interface ListDiscountCampaignsResponse {
    Result?: EVA.Core.PagedResult<ListDiscountCampaignsResponse.DiscountCampaignDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListDiscountCampaignsResponse {
    export interface DiscountCampaignDto {
      /**
       * Entity type: DiscountCampaign
       */
      ID: number;
      Name: string;
      Description: string;
      StartDate?: string;
      EndDate?: string;
      BackendSystemID: string;
      BackendID: string;
      /**
       * Entity type: Currency
       */
      CurrencyID?: string;
      Budget?: number;
      BudgetProgress?: number;
    }

  }

  /**
   * Get a DiscountCampaign by ID
   */
  export interface GetDiscountCampaignByID {
    /**
     * Entity type: DiscountCampaign
     */
    ID: number;
  }

  export interface GetDiscountCampaignByIDResponse {
    /**
     * Entity type: DiscountCampaign
     */
    ID: number;
    Name: string;
    Description: string;
    StartDate?: string;
    EndDate?: string;
    KeepDiscountsWithinCampaignTimespan: boolean;
    BackendSystemID: string;
    BackendID: string;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    Budget?: number;
    DeactivateDiscountsWhenBudgetIsReached: boolean;
    TotalDiscountGiven?: number;
    BudgetAvailable?: number;
    BudgetProgress?: number;
    BudgetReached?: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new DiscountCampaign
   */
  export interface CreateDiscountCampaign {
    Name: string;
    Description?: string;
    StartDate?: string;
    EndDate?: string;
    KeepDiscountsWithinCampaignTimespan?: boolean;
    BackendSystemID?: string;
    BackendID?: string;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
  }

  export interface CreateDiscountCampaignResponse {
    /**
     * Entity type: DiscountCampaign
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing DiscountCampaign
   */
  export interface UpdateDiscountCampaign {
    /**
     * Entity type: DiscountCampaign
     */
    ID: number;
    Name?: string;
    Description?: string;
    StartDate?: string;
    EndDate?: string;
    KeepDiscountsWithinCampaignTimespan?: boolean;
    BackendSystemID?: string;
    BackendID?: string;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
  }

  /**
   * Update the budget on the discount campaign.
   * When the budget is lowerd below the current `TotalDiscountGiven` and the `DeactivateWhenBudgetReached` is set to true, all related discounts will be deactivated.
   * When the budget is cleared or raised above the current `TotalDiscountGiven`, or `DeactivateWhenBudgetReached` is set to false, all discounts that were deactivate by the discount campaign budget will be reactivated.
   */
  export interface UpdateDiscountCampaignBudget {
    /**
     * Entity type: DiscountCampaign
     */
    ID: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    /**
     * Min: 0
     */
    Budget?: number;
    DeactivateDiscountsWhenBudgetIsReached?: boolean;
    ReactivateDeactivatedDiscounts?: boolean;
  }

  /**
   * Delete a DiscountCampaign
   */
  export interface DeleteDiscountCampaign {
    /**
     * Entity type: DiscountCampaign
     */
    ID: number;
    ArchiveAllRelatedDiscounts?: boolean;
    ReactivateAllRelatedDiscounts?: boolean;
  }

  /**
   * List the coupons
   */
  export interface ListCouponsByQuery {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListDiscountCouponsFilter>;
  }

  export interface ListCouponsByQueryResponse {
    Result?: EVA.Core.PagedResult<ListCouponsByQueryResponse.Coupon>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCouponsByQueryResponse {
    export interface Coupon {
      /**
       * Entity type: DiscountCoupon
       */
      ID: number;
      /**
       * Entity type: Discount
       */
      DiscountID: number;
      DiscountMarketingDescription: string;
      CouponCode: string;
      MaximumUsage?: number;
      UsageCount: number;
      FirstUsage?: string;
      LastUsage?: string;
      IsActive: boolean;
      IsGenerated: boolean;
      IsExternal: boolean;
    }

  }

  /**
   * Get discount coupons by discount ID
   */
  export interface GetDiscountCouponByID {
    /**
     * Entity type: DiscountCoupon
     */
    ID: number;
  }

  export interface GetDiscountCouponByIDResponse {
    /**
     * Entity type: DiscountCoupon
     */
    ID: number;
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    DiscountMarketingDescription: string;
    /**
     * Entity type: Discount
     */
    OriginatingDiscountID?: number;
    OriginatingDiscountMarketingDescription: string;
    /**
     * Entity type: Order
     */
    OriginatingOrderID?: number;
    CouponCode: string;
    IsExternal: boolean;
    Handler: string;
    IsGenerated: boolean;
    IsActive: boolean;
    MaximumUsage?: number;
    UsageCount: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    UserFullName?: string;
    FirstUsage?: string;
    LastUsage?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a DiscountCoupon
   */
  export interface CreateDiscountCoupon {
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    CouponCode: string;
    IsActive?: boolean;
    MaximumUsage?: number;
  }

  export interface CreateDiscountCouponResponse {
    /**
     * Entity type: DiscountCoupon
     */
    ID: number;
    IsDuplicateCoupon: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing DiscountCoupon
   */
  export interface UpdateDiscountCoupon {
    /**
     * Entity type: DiscountCoupon
     */
    ID: number;
    IsActive?: boolean;
    MaximumUsage?: number;
  }

  export interface UpdateDiscountCouponResponse {
    IsDuplicateCoupon: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Generate a batch DiscountCoupons, they will be emailed to the current user
   */
  export interface GenerateDiscountCoupons {
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    /**
     * Min: 1
     */
    Quantity: number;
    Prefix?: string;
    Suffix?: string;
    /**
     * Min: 1
     */
    MaximumUsage?: number;
  }

  /**
   * List the coupons that are generated on an order
   */
  export interface ListOrderGeneratedCoupons {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface ListOrderGeneratedCouponsResponse {
    Coupons: ListOrderGeneratedCouponsResponse.Coupon[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListOrderGeneratedCouponsResponse {
    export interface Coupon {
      /**
       * Entity type: DiscountCoupon
       */
      ID: number;
      Code: string;
      /**
       * Entity type: Discount
       */
      TargetDiscountID: number;
      TargetDiscountDescription: string;
      TargetDiscountMarketingDescription: string;
    }

  }

  /**
   * Get the coupons for a specific user
   */
  export interface GetUserCoupons {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * You can provide an additional `OrganizationUnitID` to filter the coupons. This only works when you are logged in as User. Employees/API's can only see coupons that are within the ClientContext CurrentOrganizationUnit
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Filter on usability. Optional values are; null = all coupons, true = usable only, false = unusable only.
     */
    IsUsable?: boolean;
  }

  export interface GetUserCouponsResponse {
    Coupons: GetUserCouponsResponse.Coupon[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetUserCouponsResponse {
    export interface Coupon {
      /**
       * Entity type: DiscountCoupon
       */
      ID: number;
      Code: string;
      /**
       * Entity type: Discount
       */
      DiscountID: number;
      DiscountDescription: string;
      DiscountMarketingDescription: string;
      ValidFrom: string;
      ValidTill?: string;
    }

  }

  /**
   * Get a coupon by it's token. When a customer calls this service, the service will only resolve tokens from coupons on which the user is registered. Employees and API's can resolve all coupon tokens.
   */
  export interface GetCouponByToken {
    CouponToken: string;
  }

  export interface GetCouponByTokenResponse {
    Code: string;
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    DiscountDescription: string;
    DiscountMarketingDescription: string;
    ValidFrom: string;
    ValidTill?: string;
    /**
     * Entity type: OrderLine
     */
    FromCancelledLines?: { [key: number]: number };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Download template to upload an excel with coupons.
   */
  export interface DownloadCouponExcelTemplate {
  }

  /**
   * Upload an excel with coupons.
   */
  export interface UploadCouponExcel {
    /**
     * Entity type: Discount
     */
    DiscountID?: number;
    /**
     * Entity type: Blob
     */
    BlobID?: string;
  }

  export interface UploadCouponExcelResponse {
    IsProcessedAsync: boolean;
    Errors: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Exports the coupons for the given discount to Excel.
   */
  export interface DownloadCouponExcel {
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    /**
     * Filter on active state. Optional values are; null = active and inactive, true = active only, false = inactive only.
     */
    IsActive?: boolean;
  }

  export interface DownloadCouponExcelResponse {
    CouponLimitReached: boolean;
    ResourceInfo: EVA.Core.ResourceInfo;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Push a DiscountCoupon
   */
  export interface PushDiscountCoupons {
    DiscountID?: string;
    Coupons?: PushDiscountCoupons.PushedCoupon[];
  }

  export namespace PushDiscountCoupons {
    export interface PushedCoupon {
      UserID?: string;
      OrderID?: string;
      CouponCode?: string;
      IsActive?: boolean;
      MaximumUsage?: number;
    }

  }

  export interface PushDiscountCouponsResponse {
    CreatedCoupons: PushDiscountCouponsResponse.CreatedCoupon[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace PushDiscountCouponsResponse {
    export interface CreatedCoupon {
      /**
       * Entity type: DiscountCoupon
       */
      ID: number;
      IsDuplicateCoupon: boolean;
    }

  }

  /**
   * Get a DiscountLayer by ID
   */
  export interface GetDiscountLayerByID {
    /**
     * Entity type: DiscountLayer
     */
    ID: number;
  }

  export interface GetDiscountLayerByIDResponse {
    ID: number;
    Name: string;
    Description: string;
    Sequence: number;
    IsExclusive: boolean;
    /**
     * This layer is managed by EVA and cannot be changed.
     */
    IsSystem: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new DiscountLayer
   */
  export interface CreateDiscountLayer {
    Name: string;
    Description?: string;
    /**
     * Min: 0
     */
    Sequence?: number;
    IsExclusive?: boolean;
  }

  export interface CreateDiscountLayerResponse {
    /**
     * Entity type: DiscountLayer
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing DiscountLayer
   */
  export interface UpdateDiscountLayer {
    /**
     * Entity type: DiscountLayer
     */
    ID: number;
    Name: string;
    Description?: string;
    /**
     * Min: 0
     */
    Sequence: number;
    IsExclusive?: boolean;
  }

  /**
   * Delete a DiscountLayer
   */
  export interface DeleteDiscountLayer {
    /**
     * Entity type: DiscountLayer
     */
    ID: number;
    /**
     * When set to `true` and there are active discounts within the layer, they will be archived. Otherwise will throw an error.
     */
    ArchiveDiscounts?: boolean;
  }

  /**
   * List the DiscountLayers
   */
  export interface ListDiscountLayers {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListDiscountLayerFilter>;
  }

  export interface ListDiscountLayersResponse {
    Result?: EVA.Core.PagedResult<ListDiscountLayersResponse.DiscountLayerDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListDiscountLayersResponse {
    export interface DiscountLayerDto {
      /**
       * Entity type: DiscountLayer
       */
      ID: number;
      Name: string;
      Description: string;
      Sequence: number;
      IsExclusive: boolean;
      /**
       * This layer is managed by EVA and cannot be changed.
       */
      IsSystem: boolean;
    }

  }

  /**
   * Move an existing DiscountLayer to a new postion.
   * 
   * The Layer will be placed after the `AfterDiscountLayerID`. If no `AfterDiscountLayerID` is given, the layer will be placed on the first position.
   */
  export interface MoveDiscountLayer {
    /**
     * Entity type: DiscountLayer
     */
    ID: number;
    /**
     * Entity type: DiscountLayer
     */
    AfterDiscountLayerID: number;
  }

  /**
   * Takes in all discount layers and sets their sequences. All layers except the system layer are required.
   */
  export interface SetDiscountLayerSequences {
    /**
     * Entity type: DiscountLayer
     */
    Layers: number[];
  }

  /**
   * Validates the given discount information
   */
  export interface ValidateDiscount {
    /**
     * Entity type: Discount
     */
    ID?: number;
    BackendID?: string;
    IsActive?: boolean;
    Description?: string;
    MarketingDescription?: string;
    NeedsReason?: boolean;
    /**
     * For a manual discount, these will indicate custom fields that need to be filled in order to apply the discount.
     * Entity type: CustomField
     */
    RequiredCustomFields?: number[];
    DiscountOrderType: EVA.Core.DiscountOrderTypes;
    StartDate: string;
    EndDate?: string;
    DaysApplicable?: EVA.Core.DaysOfWeek;
    /**
     * Entity type: LedgerClass
     */
    LedgerClassID?: string;
    /**
     * Min: 1
     */
    MaximumUsage?: number;
    /**
     * NOTE THAT Manual discounts can still be applied on multiple lines within the same order.
     * Min: 1
     */
    MaximumUsagePerOrder?: number;
    /**
     * Min: 1
     */
    MaximumUsagePerUser?: number;
    ActionType?: string;
    ActionData?: { [key: string]: any };
    Conditions?: ValidateDiscount.DiscountConditionDto[];
    ConditionType: EVA.Core.DiscountConditionTypes;
    Trigger: EVA.Core.DiscountTriggers;
    /**
     * Entity type: DiscountLayer
     */
    LayerID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    CurrencyConstraint: EVA.Core.CurrencyConstraint;
    AppliesTo?: EVA.Core.DiscountAppliesTo;
    CouponHandler?: string;
    CouponsGeneratedByOtherDiscount?: boolean;
    /**
     * Entity type: OrganizationUnit
     */
    RestitutionOrganizationUnitID?: number;
    /**
     * Entity type: CustomField
     */
    CustomUserUsageLimitFieldID?: number;
    /**
     * Min: 0
     */
    UserUsageLimit?: number;
    UserUsageReloadStrategy?: string;
    UserUsagePeriodType?: EVA.Core.DiscountUserUsagePeriodType;
    UserUsagePeriodDuration?: number;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    /**
     * Min: 1
     */
    LoyaltyPointWithdrawal?: number;
    /**
     * Entity type: ProductSubscription
     */
    ProductSubscriptionID?: number;
    CompliancyRule: EVA.Core.DiscountCompliancyRule;
    /**
     * Optional additional custom fields
     */
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
  }

  export namespace ValidateDiscount {
    export interface DiscountConditionDto {
      Type: string;
      Data: { [key: string]: any };
      UseAsActionCondition: boolean;
    }

  }

  export interface ValidateDiscountResponse {
    Messages: string[];
    ActionMessages: string[];
    /**
     * Entity type: DiscountCondition
     */
    ConditionMessages: { [key: number]: string[] };
    CustomFieldMessages?: ValidateDiscountResponse.CustomFieldMessage;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ValidateDiscountResponse {
    export interface CustomFieldMessage {
      Type: string;
      Message: string;
      Data: EVA.Core.CustomFieldValidationErrorData;
    }

  }

  /**
   * Create a new discount
   */
  export interface CreateDiscount {
    BackendID?: string;
    Enable: boolean;
    Description: string;
    MarketingDescription?: string;
    PromotionLabel?: string;
    /**
     * Entity type: DiscountCampaign
     */
    CampaignID?: number;
    NeedsReason?: boolean;
    /**
     * For a manual discount, these will indicate custom fields that need to be filled in order to apply the discount.
     * Entity type: CustomField
     */
    RequiredCustomFields?: number[];
    DiscountOrderType: EVA.Core.DiscountOrderTypes;
    StartDate?: string;
    EndDate?: string;
    DaysApplicable?: EVA.Core.DaysOfWeek;
    /**
     * Entity type: LedgerClass
     */
    LedgerClassID?: string;
    /**
     * Min: 1
     */
    MaximumUsage?: number;
    /**
     * NOTE THAT Manual discounts can still be applied on multiple lines within the same order.
     * Min: 1
     */
    MaximumUsagePerOrder?: number;
    /**
     * Min: 1
     */
    MaximumUsagePerUser?: number;
    CannotApplyToOwnOrder?: boolean;
    ActionType: string;
    ActionData?: { [key: string]: any };
    Conditions?: CreateDiscount.DiscountConditionDto[];
    ConditionType: EVA.Core.DiscountConditionTypes;
    /**
     * NOTE THAT trigger cannot be updated after creation.
     */
    Trigger: EVA.Core.DiscountTriggers;
    CouponHandler?: string;
    /**
     * Entity type: DiscountLayer
     */
    LayerID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    CurrencyConstraint: EVA.Core.CurrencyConstraint;
    /**
     * Min: 0
     */
    Budget?: number;
    DeactivateWhenBudgetReached?: boolean;
    /**
     * Entity type: CustomField
     */
    CustomUserUsageLimitFieldID?: number;
    /**
     * Min: 0
     */
    UserUsageLimit?: number;
    UserUsageReloadStrategy?: string;
    UserUsagePeriodType?: EVA.Core.DiscountUserUsagePeriodType;
    UserUsagePeriodDuration?: number;
    ApplyTo?: EVA.Core.DiscountAppliesTo;
    /**
     * Entity type: Role
     */
    RoleIDs?: number[];
    /**
     * Entity type: Blob
     */
    ImageBlobID?: string;
    ImageBlobUrl?: string;
    CouponsGeneratedByOtherDiscount?: boolean;
    /**
     * Entity type: OrganizationUnit
     */
    RestitutionOrganizationUnitID?: number;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    /**
     * Min: 1
     */
    LoyaltyPointWithdrawal?: number;
    /**
     * Entity type: ProductSubscription
     */
    ProductSubscriptionID?: number;
    CompliancyRule: EVA.Core.DiscountCompliancyRule;
    /**
     * Optional additional custom fields
     */
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
  }

  export namespace CreateDiscount {
    export interface DiscountConditionDto {
      Type: string;
      Data: { [key: string]: any };
    }

  }

  export interface CreateDiscountResponse {
    /**
     * Entity type: Discount
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing discount
   */
  export interface UpdateDiscount {
    /**
     * Entity type: Discount
     */
    ID: number;
    BackendID?: string;
    Enable: boolean;
    Description: string;
    MarketingDescription?: string;
    PromotionLabel?: string;
    /**
     * Entity type: DiscountCampaign
     */
    CampaignID?: number;
    NeedsReason?: boolean;
    /**
     * For a manual discount, these will indicate custom fields that need to be filled in order to apply the discount.
     * Entity type: CustomField
     */
    RequiredCustomFields?: number[];
    DiscountOrderType: EVA.Core.DiscountOrderTypes;
    StartDate?: string;
    EndDate?: string;
    DaysApplicable?: EVA.Core.DaysOfWeek;
    /**
     * Entity type: LedgerClass
     */
    LedgerClassID?: string;
    /**
     * Min: 1
     */
    MaximumUsage?: number;
    /**
     * NOTE THAT Manual discounts can still be applied on multiple lines within the same order.
     * Min: 1
     */
    MaximumUsagePerOrder?: number;
    /**
     * Min: 1
     */
    MaximumUsagePerUser?: number;
    CannotApplyToOwnOrder?: boolean;
    ActionType: string;
    ActionData?: { [key: string]: any };
    Conditions?: UpdateDiscount.DiscountConditionDto[];
    ConditionType: EVA.Core.DiscountConditionTypes;
    /**
     * @deprecated Trigger cannot be updated after creation
     */
    Trigger: EVA.Core.DiscountTriggers;
    CouponHandler?: string;
    /**
     * Entity type: DiscountLayer
     */
    LayerID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    CurrencyConstraint: EVA.Core.CurrencyConstraint;
    /**
     * Min: 0
     */
    Budget?: number;
    DeactivateWhenBudgetReached?: boolean;
    /**
     * Entity type: CustomField
     */
    CustomUserUsageLimitFieldID?: number;
    /**
     * Min: 0
     */
    UserUsageLimit?: number;
    UserUsageReloadStrategy?: string;
    UserUsagePeriodType?: EVA.Core.DiscountUserUsagePeriodType;
    UserUsagePeriodDuration?: number;
    ApplyTo?: EVA.Core.DiscountAppliesTo;
    /**
     * Entity type: Role
     */
    RoleIDs?: number[];
    /**
     * Entity type: Blob
     */
    ImageBlobID?: string;
    ImageBlobUrl?: string;
    CouponsGeneratedByOtherDiscount?: boolean;
    /**
     * Entity type: OrganizationUnit
     */
    RestitutionOrganizationUnitID?: number;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    /**
     * Min: 1
     */
    LoyaltyPointWithdrawal?: number;
    /**
     * Entity type: ProductSubscription
     */
    ProductSubscriptionID?: number;
    CompliancyRule: EVA.Core.DiscountCompliancyRule;
    /**
     * Optional additional custom fields
     */
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
  }

  export namespace UpdateDiscount {
    export interface DiscountConditionDto {
      /**
       * Entity type: DiscountCondition
       */
      ID?: number;
      Type: string;
      Data: { [key: string]: any };
    }

  }

  /**
   * Marks the Discount with the given Discount ID as verified.
   * 
   * Service will return an error when de discount is already verified.
   * 
   * Discount cannot be verified by the same user as the one who created / modified the discount, unless they have the right 'DiscountSelfVerification'.
   * The service will return an error if the same user without the right 'DiscountSelfVerification' tries to verify the discount.
   */
  export interface VerifyDiscount {
    /**
     * Entity type: Discount
     */
    DiscountID: number;
  }

  /**
   * Enable discounts
   */
  export interface EnableDiscounts {
    /**
     * Entity type: Discount
     */
    DiscountIDs: number[];
  }

  /**
   * Disable discounts
   */
  export interface DisableDiscounts {
    /**
     * Entity type: Discount
     */
    DiscountIDs: number[];
  }

  /**
   * Archive an existing discount
   */
  export interface ArchiveDiscount {
    /**
     * Entity type: Discount
     */
    DiscountIDs?: number[];
  }

  /**
   * Duplicates the requested discount x times with it's conditions and action.
   * A duplicated discount will not be Active and Verified.
   */
  export interface DuplicateDiscount {
    /**
     * The ID of the discount to create a copy of.
     * Entity type: Discount
     */
    DiscountID: number;
    /**
     * Indicate how many duplicates need to be made. When left empty, only 1 duplicate will be made.
     * Range: 1-500
     */
    NumberOfDuplicates?: number;
  }

  export interface DuplicateDiscountResponse {
    /**
     * Entity type: Discount
     */
    IDs: number[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Searches the Discounts with the given filter and returns a paged response.
   */
  export interface SearchDiscountsByQuery {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.SearchDiscountsByQueryFilter>;
  }

  export interface SearchDiscountsByQueryResponse {
    Result?: EVA.Core.PagedResult<SearchDiscountsByQueryResponse.DiscountDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace SearchDiscountsByQueryResponse {
    export interface DiscountDto {
      /**
       * Entity type: Discount
       */
      ID: number;
      BackendID: string;
      /**
       * Entity type: DiscountCampaign
       */
      CampaignID?: number;
      Description?: string;
      IsUsed: boolean;
      Enabled: boolean;
      DeactivationReasons: EVA.Core.DiscountDeactivationReasons;
      MaximumUsage?: number;
      CurrencyID: string;
      CurrencyConstraint: EVA.Core.CurrencyConstraint;
      Budget?: number;
      DeactivateWhenBudgetReached: boolean;
      BudgetAvailable?: number;
      BudgetProgress?: number;
      TotalDiscountGiven: number;
      UsageCount: number;
      /**
       * Entity type: User
       */
      CreatedByID: number;
      CreatedByFullName: string;
      DiscountOrderType: EVA.Core.DiscountOrderTypes;
      /**
       * Entity type: DiscountLayer
       */
      LayerID: number;
      LayerName: string;
      /**
       * Entity type: OrganizationUnitSet
       */
      OrganizationUnitSetID: number;
      OrganizationUnitSetName: string;
      OrganizationUnitSetDescription: string;
      OrganizationUnitSetType?: EVA.Core.OrganizationUnitSetTypes;
      StartDate: string;
      EndDate?: string;
      /**
       * Entity type: CustomField
       */
      CustomUserUsageLimitFieldID?: number;
      UserUsageLimit?: number;
      UserUsageReloadStrategy: string;
      UserUsagePeriodType?: EVA.Core.DiscountUserUsagePeriodType;
      UserUsagePeriodDuration?: number;
      GeneratedFromTemplate: boolean;
      /**
       * Entity type: Blob
       */
      ImageBlobID?: string;
      ImageBlobUrl?: string;
      CouponsGeneratedByOtherDiscount: boolean;
      /**
       * Entity type: OrganizationUnit
       */
      RestitutionOrganizationUnitID?: number;
      /**
       * Entity type: LoyaltyProgram
       */
      LoyaltyProgramID?: number;
      LoyaltyProgramName?: string;
      /**
       * Entity type: ProductSubscription
       */
      ProductSubscriptionID?: number;
      ProductSubscriptionName?: string;
    }

  }

  /**
   * Searches the Discounts with the given filter and returns a tree structure based on discount layer and discount.
   */
  export interface GetLayerGroupedDiscountsByQuery {
    Query?: EVA.Core.SearchDiscountsByQueryFilter;
  }

  export interface GetLayerGroupedDiscountsByQueryResponse {
    Layers: GetLayerGroupedDiscountsByQueryResponse.LayerModel[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetLayerGroupedDiscountsByQueryResponse {
    export interface LayerModel {
      LayerID: number;
      LayerName: string;
      Sequence: number;
      IsExclusive: boolean;
      IsSystem: boolean;
      Discounts: GetLayerGroupedDiscountsByQueryResponse.DiscountModel[];
    }

    export interface DiscountModel {
      /**
       * Entity type: Discount
       */
      ID: number;
      BackendID: string;
      /**
       * Entity type: DiscountCampaign
       */
      CampaignID?: number;
      Description?: string;
      IsUsed: boolean;
      Enabled: boolean;
      DeactivationReasons: EVA.Core.DiscountDeactivationReasons;
      MaximumUsage?: number;
      CurrencyID: string;
      CurrencyConstraint: EVA.Core.CurrencyConstraint;
      Budget?: number;
      DeactivateWhenBudgetReached: boolean;
      BudgetAvailable?: number;
      BudgetProgress?: number;
      TotalDiscountGiven: number;
      UsageCount: number;
      /**
       * Entity type: User
       */
      CreatedByID: number;
      CreatedByFullName: string;
      DiscountOrderType: EVA.Core.DiscountOrderTypes;
      /**
       * Entity type: DiscountLayer
       */
      LayerID: number;
      LayerName: string;
      /**
       * Entity type: OrganizationUnitSet
       */
      OrganizationUnitSetID: number;
      OrganizationUnitSetName: string;
      OrganizationUnitSetDescription: string;
      OrganizationUnitSetType?: EVA.Core.OrganizationUnitSetTypes;
      StartDate: string;
      EndDate?: string;
      /**
       * Entity type: CustomField
       */
      CustomUserUsageLimitFieldID?: number;
      UserUsageLimit?: number;
      UserUsageReloadStrategy: string;
      UserUsagePeriodType?: EVA.Core.DiscountUserUsagePeriodType;
      UserUsagePeriodDuration?: number;
      GeneratedFromTemplate: boolean;
      /**
       * Entity type: Blob
       */
      ImageBlobID?: string;
      ImageBlobUrl?: string;
      CouponsGeneratedByOtherDiscount: boolean;
      /**
       * Entity type: OrganizationUnit
       */
      RestitutionOrganizationUnitID?: number;
      /**
       * Entity type: LoyaltyProgram
       */
      LoyaltyProgramID?: number;
      LoyaltyProgramName: string;
      LoyaltyPointWithdrawal?: number;
      /**
       * Entity type: ProductSubscription
       */
      ProductSubscriptionID?: number;
      ProductSubscriptionName: string;
    }

  }

  /**
   * Get Discount by the given Discount ID
   */
  export interface GetDiscountByID {
    /**
     * Entity type: Discount
     */
    ID: number;
  }

  export interface GetDiscountByIDResponse {
    /**
     * Entity type: Discount
     */
    ID: number;
    BackendID: string;
    Enabled: boolean;
    IsEditAllowed: boolean;
    IsUsed: boolean;
    DeactivationReasons: EVA.Core.DiscountDeactivationReasons;
    Description: string;
    MarketingDescription: string;
    PromotionLabel?: string;
    /**
     * Entity type: DiscountCampaign
     */
    CampaignID?: number;
    NeedsReason: boolean;
    /**
     * Entity type: CustomField
     */
    RequiredCustomFields: number[];
    DiscountOrderType: EVA.Core.DiscountOrderTypes;
    StartDate: string;
    EndDate?: string;
    DaysApplicable?: EVA.Core.DaysOfWeek;
    /**
     * Entity type: LedgerClass
     */
    LedgerClassID: string;
    MaximumUsage?: number;
    UsageCount: number;
    MaximumUsagePerOrder?: number;
    MaximumUsagePerUser?: number;
    ActionType: string;
    ActionData: any;
    Conditions: GetDiscountByIDResponse.DiscountCondition[];
    ConditionType: EVA.Core.DiscountConditionTypes;
    Trigger: EVA.Core.DiscountTriggers;
    CouponHandler: string;
    /**
     * @deprecated No longer supported.
     */
    TotalCouponCount?: number;
    /**
     * @deprecated No longer supported.
     */
    UsableCouponCount?: number;
    /**
     * @deprecated No longer supported.
     */
    UsedCouponCount?: number;
    /**
     * Entity type: DiscountLayer
     */
    LayerID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    OrganizationUnitSetName: string;
    /**
     * This could be the backend id of the OU if this is the system generated OU set of the OU
     */
    OrganizationUnitSetBackendID: string;
    OrganizationUnitSetType?: EVA.Core.OrganizationUnitSetTypes;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    CurrencyConstraint: EVA.Core.CurrencyConstraint;
    Budget?: number;
    DeactivateWhenBudgetReached: boolean;
    BudgetAvailable?: number;
    BudgetProgress?: number;
    TotalDiscountGiven: number;
    /**
     * Entity type: CustomField
     */
    CustomUserUsageLimitFieldID?: number;
    UserUsageLimit?: number;
    UserUsageReloadStrategy: string;
    UserUsagePeriodType?: EVA.Core.DiscountUserUsagePeriodType;
    UserUsagePeriodDuration?: number;
    CreatedByFullName: string;
    CreationTime: string;
    LastModifiedByFullName: string;
    LastModificationTime?: string;
    VerifiedByFullName: string;
    VerificationTime?: string;
    ApplyTo?: EVA.Core.DiscountAppliesTo;
    GeneratedFromTemplate: boolean;
    /**
     * Entity type: Blob
     */
    ImageBlobID?: string;
    ImageBlobUrl?: string;
    CouponsGeneratedByOtherDiscount: boolean;
    Roles: GetDiscountByIDResponse.Role[];
    /**
     * Entity type: OrganizationUnit
     */
    RestitutionOrganizationUnitID?: number;
    RestitutionOrganizationUnitName?: string;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    LoyaltyProgramName?: string;
    LoyaltyPointWithdrawal?: number;
    /**
     * Entity type: ProductSubscription
     */
    ProductSubscriptionID?: number;
    ProductSubscriptionName?: string;
    CompliancyRule: EVA.Core.DiscountCompliancyRule;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: EVA.Core.CustomFieldValueWithOptions };
    CannotApplyToOwnOrder: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetDiscountByIDResponse {
    export interface DiscountCondition {
      /**
       * Entity type: DiscountCondition
       */
      ID: number;
      Type: string;
      Data: any;
      UseAsActionCondition: boolean;
    }

    export interface Role {
      /**
       * Entity type: Role
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Add security roles to ManualDiscount
   */
  export interface AddRolesToManualDiscount {
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    /**
     * Entity type: Role
     */
    RoleIDs: number[];
  }

  /**
   * Remove security roles from ManualDiscount
   */
  export interface RemoveRolesFromManualDiscount {
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    /**
     * Entity type: Role
     */
    RoleIDs?: number[];
    RemoveAllRoles?: boolean;
  }

  /**
   * Add required custom fields to ManualDiscount
   */
  export interface AddRequiredCustomFieldsToManualDiscount {
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    /**
     * Entity type: CustomField
     */
    CustomFieldIDs: number[];
  }

  /**
   * Remove required custom fields from ManualDiscount
   */
  export interface RemoveRequiredCustomFieldsFromManualDiscount {
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    /**
     * Entity type: CustomField
     */
    CustomFieldIDs?: number[];
    RemoveAllRequiredCustomFields?: boolean;
  }

  /**
   * Lists the available discount conditions and actions.
   */
  export interface ListAvailableDiscountActionsAndConditions {
    DiscountTriggers?: EVA.Core.DiscountTriggers;
    CurrencyConstraint?: EVA.Core.CurrencyConstraint;
  }

  export interface ListAvailableDiscountActionsAndConditionsResponse {
    Conditions: string[];
    Actions: string[];
    /**
     * @deprecated Not supported
     */
    TriggerAvailability?: ListAvailableDiscountActionsAndConditionsResponse.TriggerItem[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListAvailableDiscountActionsAndConditionsResponse {
    export interface TriggerItem {
      Trigger: EVA.Core.DiscountTriggers;
      Conditions: string[];
      Actions: string[];
    }

  }

  /**
   * Lists the available discount user usage reload strategies.
   */
  export interface ListDiscountUserUsageReloadStrategies {
  }

  export interface ListDiscountUserUsageReloadStrategiesResponse {
    Strategies: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Validates the given discount template information
   */
  export interface ValidateDiscountTemplate {
    Description: string;
    Trigger: EVA.Core.DiscountTriggers;
    CouponsGeneratedByOtherDiscount?: boolean;
    CouponHandler?: string;
    DiscountOrderType: EVA.Core.DiscountOrderTypes;
    AppliesTo: EVA.Core.DiscountAppliesTo;
    ActionType: string;
    ActionData: { [key: string]: any };
    ConditionType: EVA.Core.DiscountConditionTypes;
    Conditions?: ValidateDiscountTemplate.Condition[];
    NeedsReason?: boolean;
    IsExclusive?: boolean;
    /**
     * Min: 1
     */
    MaximumUsage?: number;
    /**
     * Min: 1
     */
    MaximumUsagePerUser?: number;
    /**
     * NOTE THAT Manual discounts can still be applied on multiple lines within the same order.
     * Min: 1
     */
    MaximumUsagePerOrder?: number;
    CannotApplyToOwnOrder?: boolean;
    DaysApplicable?: EVA.Core.DaysOfWeek;
    /**
     * Min: 0
     */
    UserUsageLimit?: number;
    UserUsageReloadStrategy?: string;
    BackendID?: string;
    /**
     * Entity type: LedgerClass
     */
    LedgerClassID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    RestitutionOrganizationUnitID?: number;
  }

  export namespace ValidateDiscountTemplate {
    export interface Condition {
      Type: string;
      Data: { [key: string]: any };
    }

  }

  export interface ValidateDiscountTemplateResponse {
    GeneralErrors: string[];
    ActionErrors: string[];
    ConditionErrors: ValidateDiscountTemplateResponse.ConditionError[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ValidateDiscountTemplateResponse {
    export interface ConditionError {
      ConditionID: number;
      Messages: string[];
    }

  }

  /**
   * Create a new discount template
   */
  export interface CreateDiscountTemplate {
    Description: string;
    BackendID?: string;
    /**
     * Entity type: LedgerClass
     */
    LedgerClassID?: string;
    Trigger: EVA.Core.DiscountTriggers;
    CouponsGeneratedByOtherDiscount?: boolean;
    CouponHandler?: string;
    DiscountOrderType: EVA.Core.DiscountOrderTypes;
    AppliesTo: EVA.Core.DiscountAppliesTo;
    ActionType: string;
    ActionData: { [key: string]: any };
    ConditionType: EVA.Core.DiscountConditionTypes;
    Conditions?: CreateDiscountTemplate.Condition[];
    NeedsReason?: boolean;
    IsExclusive?: boolean;
    /**
     * Min: 1
     */
    MaximumUsage?: number;
    /**
     * Min: 1
     */
    MaximumUsagePerUser?: number;
    CannotApplyToOwnOrder?: boolean;
    DaysApplicable?: EVA.Core.DaysOfWeek;
    /**
     * NOTE THAT Manual discounts can still be applied on multiple lines within the same order.
     * Min: 1
     */
    MaximumUsagePerOrder?: number;
    /**
     * Min: 0
     */
    UserUsageLimit?: number;
    UserUsageReloadStrategy?: string;
    ImageBlobID?: string;
    /**
     * Entity type: DiscountCampaign
     */
    CampaignID?: number;
    IsActive?: boolean;
    /**
     * Entity type: OrganizationUnit
     */
    RestitutionOrganizationUnitID?: number;
  }

  export namespace CreateDiscountTemplate {
    export interface Condition {
      Type: string;
      Data: { [key: string]: any };
    }

  }

  export interface CreateDiscountTemplateResponse {
    /**
     * Entity type: DiscountTemplate
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing discount template
   */
  export interface UpdateDiscountTemplate {
    /**
     * Entity type: DiscountTemplate
     */
    ID: number;
    Description: string;
    BackendID?: string;
    /**
     * Entity type: LedgerClass
     */
    LedgerClassID?: string;
    Trigger: EVA.Core.DiscountTriggers;
    CouponsGeneratedByOtherDiscount?: boolean;
    CouponHandler?: string;
    DiscountOrderType: EVA.Core.DiscountOrderTypes;
    AppliesTo: EVA.Core.DiscountAppliesTo;
    ActionType: string;
    ActionData: { [key: string]: any };
    ConditionType: EVA.Core.DiscountConditionTypes;
    Conditions?: UpdateDiscountTemplate.Condition[];
    NeedsReason?: boolean;
    IsExclusive?: boolean;
    /**
     * Min: 1
     */
    MaximumUsage?: number;
    /**
     * Min: 1
     */
    MaximumUsagePerUser?: number;
    /**
     * NOTE THAT Manual discounts can still be applied on multiple lines within the same order.
     * Min: 1
     */
    MaximumUsagePerOrder?: number;
    CannotApplyToOwnOrder?: boolean;
    DaysApplicable?: EVA.Core.DaysOfWeek;
    /**
     * Min: 0
     */
    UserUsageLimit?: number;
    UserUsageReloadStrategy?: string;
    ImageBlobID?: string;
    /**
     * Entity type: DiscountCampaign
     */
    CampaignID?: number;
    IsActive?: boolean;
    /**
     * Entity type: OrganizationUnit
     */
    RestitutionOrganizationUnitID?: number;
  }

  export namespace UpdateDiscountTemplate {
    export interface Condition {
      /**
       * Entity type: DiscountTemplateCondition
       */
      ID?: number;
      Type: string;
      Data: { [key: string]: any };
    }

  }

  /**
   * Delete an existing discount template
   */
  export interface DeleteDiscountTemplate {
    /**
     * Entity type: DiscountTemplate
     */
    ID: number;
    ArchiveAllRelatedDiscounts?: boolean;
  }

  /**
   * Duplicates the given discount template.
   */
  export interface DuplicateDiscountTemplate {
    /**
     * Entity type: DiscountTemplate
     */
    ID: number;
  }

  /**
   * Searches the DiscountTemplates with the given filter and returns a paged response.
   */
  export interface ListDiscountTemplates {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListDiscountTemplatesFilter>;
  }

  export interface ListDiscountTemplatesResponse {
    Result?: EVA.Core.PagedResult<ListDiscountTemplatesResponse.Data>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListDiscountTemplatesResponse {
    export interface Data {
      /**
       * Entity type: DiscountTemplate
       */
      ID: number;
      Description: string;
      Trigger: EVA.Core.DiscountTriggers;
      DiscountOrderType: EVA.Core.DiscountOrderTypes;
      AppliesTo: EVA.Core.DiscountAppliesTo;
      ActionType: string;
      CreatedByFullName: string;
      CreationTime: string;
      LastModifiedByFullName: string;
      LastModificationTime?: string;
      ImageBlobID?: string;
      IsActive: boolean;
      /**
       * Entity type: OrganizationUnit
       */
      RestitutionOrganizationUnitID?: number;
    }

  }

  /**
   * Get DiscountTemplate by the given ID
   */
  export interface GetDiscountTemplateByID {
    /**
     * Entity type: DiscountTemplate
     */
    ID: number;
  }

  export interface GetDiscountTemplateByIDResponse {
    /**
     * Entity type: DiscountTemplate
     */
    ID: number;
    Description: string;
    BackendID?: string;
    LedgerClassID?: string;
    Trigger: EVA.Core.DiscountTriggers;
    CouponsGeneratedByOtherDiscount: boolean;
    CouponHandler: string;
    DiscountOrderType: EVA.Core.DiscountOrderTypes;
    AppliesTo: EVA.Core.DiscountAppliesTo;
    ActionType: string;
    ActionData: any;
    ConditionType: EVA.Core.DiscountConditionTypes;
    Conditions: GetDiscountTemplateByIDResponse.Condition[];
    NeedsReason: boolean;
    IsExclusive: boolean;
    MaximumUsage?: number;
    MaximumUsagePerUser?: number;
    MaximumUsagePerOrder?: number;
    CannotApplyToOwnOrder: boolean;
    DaysApplicable?: EVA.Core.DaysOfWeek;
    UserUsageLimit?: number;
    UserUsageReloadStrategy: string;
    ImageBlobID?: string;
    /**
     * Entity type: DiscountCampaign
     */
    CampaignID?: number;
    IsActive: boolean;
    /**
     * Entity type: OrganizationUnit
     */
    RestitutionOrganizationUnitID?: number;
    RestitutionOrganizationUnitName?: string;
    CreatedByID: number;
    CreatedByFullName: string;
    CreationTime: string;
    ModifiedByID?: number;
    LastModifiedByFullName: string;
    LastModificationTime?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetDiscountTemplateByIDResponse {
    export interface Condition {
      /**
       * Entity type: DiscountTemplateCondition
       */
      ID: number;
      Type: string;
      Data: any;
    }

  }

  /**
   * Create a discount from the given template with the overwrites with the values given in the request.
   */
  export interface CreateDiscountFromTemplate {
    /**
     * Entity type: DiscountTemplate
     */
    ID: number;
    /**
     * Entity type: DiscountLayer
     */
    LayerID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    Description: string;
    MarketingDescription?: string;
    PromotionLabel?: string;
    /**
     * Entity type: DiscountCampaign
     */
    CampaignID?: number;
    /**
     * Entity type: LedgerClass
     */
    LedgerClassID?: string;
    FinancialDispersion?: EVA.Core.FinancialDespersionType;
    BackendID?: string;
    NeedsReason?: boolean;
    IsExclusive?: boolean;
    /**
     * Min: 1
     */
    MaximumUsage?: number;
    /**
     * Min: 1
     */
    MaximumUsagePerUser?: number;
    /**
     * NOTE THAT Manual discounts can still be applied on multiple lines within the same order.
     * Min: 1
     */
    MaximumUsagePerOrder?: number;
    CannotApplyToOwnOrder?: boolean;
    DaysApplicable?: EVA.Core.DaysOfWeek;
    UserUsageLimit?: number;
    UserUsageReloadStrategy?: string;
    ImageBlobID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    RestitutionOrganizationUnitID?: number;
    CreateAsActive?: boolean;
    StartDate?: string;
    EndDate?: string;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    /**
     * Min: 1
     */
    LoyaltyPointWithdrawal?: number;
    CompliancyRule: EVA.Core.DiscountCompliancyRule;
    /**
     * Entity type: Role
     */
    RoleIDs?: number[];
    /**
     * For a manual discount, these will indicate custom fields that need to be filled in order to apply the discount.
     * Entity type: CustomField
     */
    RequiredCustomFields?: number[];
    /**
     * Optional additional custom fields
     */
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
    /**
     * Entity type: ProductSubscription
     */
    ProductSubscriptionID?: number;
  }

  /**
   * Gets an custom field by its ID and returns the basic information.
   */
  export interface GetCustomFieldByID {
    /**
     * Entity type: CustomField
     */
    ID: number;
  }

  export interface GetCustomFieldByIDResponse {
    /**
     * Entity type: CustomField
     */
    ID: number;
    /**
     * Entity type: CustomFieldType
     */
    TypeID: number;
    TypeName: string;
    TypeKey?: string;
    Name: string;
    DisplayName?: string;
    DataType: EVA.Core.CustomFieldDataTypes;
    Order: number;
    BackendID?: string;
    IsArray?: boolean;
    EnumValues?: { [key: string]: string };
    InputHint?: string;
    VisibleByUserTypes?: EVA.Core.UserTypes;
    EditableByUserTypes?: EVA.Core.UserTypes;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new custom field.
   */
  export interface CreateCustomField {
    /**
     * Entity type: CustomFieldType
     */
    TypeID?: number;
    TypeKey?: string;
    BackendID?: string;
    Name?: string;
    DisplayName?: string;
    DataType?: EVA.Core.CustomFieldDataTypes;
    Order?: number;
    IsArray?: boolean;
    EnumValues?: { [key: string]: string };
    InputHint?: string;
  }

  export interface CreateCustomFieldResponse {
    /**
     * Entity type: CustomField
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing custom CustomField.
   */
  export interface UpdateCustomField {
    /**
     * Entity type: CustomField
     */
    ID: number;
    TypeKey?: string;
    Name?: string;
    DisplayName?: string;
    Order?: number;
    BackendID?: string;
    EnumValues?: { [key: string]: string };
    InputHint?: string;
  }

  /**
   * Delete a CustomField
   */
  export interface DeleteCustomField {
    /**
     * Entity type: CustomField
     */
    ID: number;
  }

  /**
   * List CustomFields. Returns a paged response.
   */
  export interface ListCustomFields {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListCustomFieldsFilter>;
  }

  export interface ListCustomFieldsResponse {
    Result?: EVA.Core.PagedResult<ListCustomFieldsResponse.CustomFieldDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCustomFieldsResponse {
    export interface CustomFieldDto {
      /**
       * Entity type: CustomField
       */
      ID: number;
      /**
       * Entity type: CustomFieldType
       */
      TypeID: number;
      TypeName: string;
      TypeKey?: string;
      Name: string;
      DisplayName?: string;
      DataType: EVA.Core.CustomFieldDataTypes;
      Order: number;
      BackendID?: string;
      EnumValues?: { [key: string]: string };
      IsArray: boolean;
      InputHint?: string;
    }

  }

  /**
   * Lists all filter operators for every customfield datatype.
   */
  export interface ListCustomFieldDataTypesOperators {
  }

  export interface ListCustomFieldDataTypeOperatorsResponse {
    DataTypeOperators: ListCustomFieldDataTypeOperatorsResponse.DataTypeOperator[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCustomFieldDataTypeOperatorsResponse {
    export interface DataTypeOperator {
      DataType: EVA.Core.CustomFieldDataTypes;
      Operators: EVA.Core.CustomFieldValueOperator[];
    }

  }

  /**
   * Get all the custom fields for the given organization unit and type.
   */
  export interface GetCustomFields {
    /**
     * Entity type: CustomFieldType
     */
    TypeID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    DataTypes?: EVA.Core.CustomFieldDataTypes[];
  }

  export interface GetCustomFieldsResponse {
    /**
     * Entity type: CustomField
     */
    CustomFieldOptions: { [key: number]: EVA.Core.CustomFieldOptions };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GetCustomFieldMetadata {
  }

  export interface GetCustomFieldMetadataResponse {
    CustomFieldsMetadata: { [key: string]: EVA.Core.CustomFieldMetadata[] };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get the CustomFieldTypes
   */
  export interface GetCustomFieldTypes {
  }

  export interface GetCustomFieldTypesResponse {
    CustomFieldTypes: EVA.Core.EnumDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get all eligibility fields for the given custom field type.
   */
  export interface ListCustomFieldEligibilityScripts {
    /**
     * Entity type: CustomFieldType
     */
    TypeID: number;
  }

  export interface ListCustomFieldEligibilityScriptsResponse {
    Scripts: ListCustomFieldEligibilityScriptsResponse.Script[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCustomFieldEligibilityScriptsResponse {
    export interface Script {
      /**
       * Entity type: Script
       */
      ID: number;
      Name: string;
      Dialect: string;
      Type?: string;
    }

  }

  /**
   * List options for custom fields
   */
  export interface ListCustomFieldOptions {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListCustomFieldOptionsFilter>;
    PageToken?: string;
  }

  export interface ListCustomFieldOptionsResponse {
    Results?: ListCustomFieldOptionsResponse.CustomFieldOptionsDto[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCustomFieldOptionsResponse {
    export interface CustomFieldOptionsDto {
      IsRequired?: boolean;
      MinimumValue?: number;
      MaximumValue?: number;
      MinimumLength?: number;
      MaximumLength?: number;
      Regex?: string;
      MinimumDate?: string;
      MaximumDate?: string;
      CustomFieldDefaultValue?: EVA.Core.CustomFieldValue;
      OrganizationUnitSet?: CustomFieldOptionsDto.OrganizationUnitSetData;
      VisibleByUserTypes?: EVA.Core.UserTypes;
      EditableByUserTypes?: EVA.Core.UserTypes;
      /**
       * Entity type: Script
       */
      SecurityScriptID?: number;
      /**
       * Entity type: Script
       */
      EligibilityScriptID?: number;
    }

    export namespace CustomFieldOptionsDto {
      export interface OrganizationUnitSetData {
        /**
         * Entity type: OrganizationUnitSet
         */
        ID: number;
        Name: string;
      }

    }

  }

  /**
   * Set options for custom fields
   */
  export interface SetCustomFieldOptions {
    /**
     * Entity type: CustomField
     */
    CustomFieldID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    MinimumValue?: number;
    MaximumValue?: number;
    MinimumLength?: number;
    MaximumLength?: number;
    Regex?: string;
    MinimumDate?: string;
    MaximumDate?: string;
    CustomFieldDefaultValue?: EVA.Core.CustomFieldValue;
    IsRequired?: boolean;
    VisibleByUserTypes?: EVA.Core.UserTypes;
    EditableByUserTypes?: EVA.Core.UserTypes;
    /**
     * Entity type: Script
     */
    SecurityScriptID?: number;
    /**
     * Entity type: Script
     */
    EligibilityScriptID?: number;
  }

  export interface UnsetCustomFieldOptions {
    /**
     * Entity type: CustomField
     */
    CustomFieldID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
  }

  /**
   * List the available Cultures
   */
  export interface ListCultures {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.CultureFilter>;
  }

  export interface ListCulturesResponse {
    Result?: EVA.Core.PagedResult<ListCulturesResponse.CultureDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCulturesResponse {
    export interface CultureDto {
      ID: string;
      /**
       * Entity type: Language
       */
      LanguageID: string;
      /**
       * Entity type: Country
       */
      CountryID: string;
    }

  }

  /**
   * Create a new Culture
   */
  export interface CreateCulture {
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
  }

  export interface CreateCultureResponse {
    ID: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Delete a Culture
   */
  export interface DeleteCulture {
    ID?: string;
  }

  /**
   * Get all available languages
   */
  export interface GetLanguages {
  }

  export interface GetLanguagesResponse {
    Languages: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the organization unit countries.
   */
  export interface ListOrganizationUnitCountries {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.OrganizationUnitCountryFilter>;
  }

  export interface ListOrganizationUnitCountriesResponse {
    Result?: EVA.Core.PagedResult<ListOrganizationUnitCountriesResponse.OrganizationUnitCountryDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListOrganizationUnitCountriesResponse {
    export interface OrganizationUnitCountryDto {
      /**
       * Entity type: OrganizationUnitCountry
       */
      ID?: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      OrganizationUnitName: string;
      /**
       * Entity type: Country
       */
      CountryID: string;
      /**
       * Entity type: OrganizationUnit
       */
      InheritedFromOrganizationUnitID?: number;
      InheritedFromOrganizationUnitName: string;
    }

  }

  /**
   * Create an organization unit country
   */
  export interface CreateOrganizationUnitCountry {
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface CreateOrganizationUnitCountryResponse {
    /**
     * Entity type: OrganizationUnitCountry
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Delete an organization unit country
   */
  export interface DeleteOrganizationUnitCountry {
    /**
     * Entity type: OrganizationUnitCountry
     */
    ID: number;
  }

  /**
   * Retrieve a list of OrganizationUnit languages
   */
  export interface ListOrganizationUnitLanguages {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.OrganizationUnitLanguageFilter>;
  }

  export interface ListOrganizationUnitLanguagesResponse {
    Result?: EVA.Core.PagedResult<ListOrganizationUnitLanguagesResponse.OrganizationUnitLanguageDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListOrganizationUnitLanguagesResponse {
    export interface OrganizationUnitLanguageDto {
      /**
       * Entity type: OrganizationUnitLanguage
       */
      ID?: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      OrganizationUnitName: string;
      /**
       * Entity type: Language
       */
      LanguageID: string;
      /**
       * Entity type: OrganizationUnit
       */
      InheritedFromOrganizationUnitID?: number;
      InheritedFromOrganizationUnitName: string;
    }

  }

  /**
   * Attach a language directly to an organization unit.
   */
  export interface CreateOrganizationUnitLanguage {
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface CreateOrganizationUnitLanguageResponse {
    /**
     * Entity type: OrganizationUnitLanguage
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Detach a language that is directly attached to an organization unit.
   */
  export interface DeleteOrganizationUnitLanguage {
    /**
     * Entity type: OrganizationUnitLanguage
     */
    ID: number;
  }

  export interface CreateCostPriceCalculation {
    BackendID?: string;
    Name: string;
    Factor: number;
  }

  export interface CreateCostPriceCalculationResponse {
    /**
     * Entity type: CostPriceCalculation
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface DeleteCostPriceCalculation {
    /**
     * Entity type: CostPriceCalculation
     */
    ID: number;
  }

  export interface GetCostPriceCalculation {
    /**
     * Entity type: CostPriceCalculation
     */
    ID: number;
  }

  export interface GetCostPriceCalculationResponse {
    /**
     * Entity type: CostPriceCalculation
     */
    ID: number;
    BackendID?: string;
    Name: string;
    Factor: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GetCostPriceCalculations {
  }

  export interface GetCostPriceCalculationsResponse {
    Items: GetCostPriceCalculationsResponse.Item[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetCostPriceCalculationsResponse {
    export interface Item {
      /**
       * Entity type: CostPriceCalculation
       */
      ID: number;
      BackendID?: string;
      Name: string;
      Factor: number;
    }

  }

  export interface UpdateCostPriceCalculation {
    /**
     * Entity type: CostPriceCalculation
     */
    ID: number;
    BackendID?: string;
    Name?: string;
    Factor?: number;
  }

  /**
   * Set the value for an AppSetting
   * 
   * - OrganizationUnitID defaults to the root OrganizationUnit
   * - Name is required
   * 
   * Values for a specific App wil only be returned in the ApplicationConfiguration if the requesting UserAgent matches {App}/*
   */
  export interface SetAppSetting {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Setting are not stored on sets, the set is evaluated when this service is called, and the setting is applied to all OrganizationUnits in the set.
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Name?: string;
    Value?: string;
    App?: string;
  }

  /**
   * Set multiple AppSettings at once
   * 
   * - OrganizationUnitID defaults to the root OrganizationUnit
   * - Name is required
   * 
   * Values for a specific App wil only be returned in the ApplicationConfiguration if the requesting UserAgent matches {App}/*
   */
  export interface SetAppSettings {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Setting are not stored on sets, the set is evaluated when this service is called, and the setting is applied to all OrganizationUnits in the set.
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Settings: SetAppSettings.Setting[];
  }

  export namespace SetAppSettings {
    export interface Setting {
      Name?: string;
      Value?: string;
      App?: string;
    }

  }

  /**
   * Removes the value for an AppSetting
   * 
   * - OrganizationUnitID is required
   * - Name is required
   */
  export interface UnsetAppSetting {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    Name: string;
    App?: string;
  }

  /**
   * List all configured AppSettings
   * 
   * Available filters
   * - OrganizationUnitID
   * - Name (partial match)
   * - App (exact match)
   */
  export interface ListAppSettings {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListAppSettingsFilter>;
  }

  export interface ListAppSettingsResponse {
    Result?: EVA.Core.PagedResult<AppSettingModel>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface AppSettingModel {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OrganizationUnitName?: string;
    Name?: string;
    Value?: string;
    App?: string;
    /**
     * Entity type: User
     */
    LastModifiedByID?: number;
    LastModifiedByFullName?: string;
    LastModificationTime?: string;
    Description?: string;
  }

  /**
   * Removes all unused settings.
   */
  export interface CleanupSettings {
    /**
     * @default true
     */
    ReportOnly?: boolean;
    Reasons?: EVA.Core.SettingRemovalReason[];
  }

  export interface CleanupSettingsResponse {
    Settings: EVA.Core.SettingModel[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Removes all untyped settings.
   */
  export interface CleanupUntypedSettings {
    /**
     * @default true
     */
    ReportOnly?: boolean;
  }

  export interface CleanupUntypedSettingsResponse {
    RemovedSettings: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Returns an Excel file containing all settings
   */
  export interface ExportSettings {
  }

  /**
   * Get the available info about appsettings that are defined in the templates repo.
   * 
   * This can be used to support some sort of autocompletion while editing appsettings.
   */
  export interface GetAppSettingsAutocompleteInfo {
  }

  export interface GetAppSettingsAutocompleteInfoResponse {
    Settings: EVA.Core.AppSettingAutocompleteInfo[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Gets the appsettings related to given `OrganizationUnitID`, optionally only those starting with `NamePrefix`
   */
  export interface GetAppSettingsForOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    Name?: string;
    SortProperty?: string;
    /**
     * @default Ascending
     */
    SortDirection?: EVA.Core.SortDirection;
  }

  export interface GetAppSettingsForOrganizationUnitResponse {
    Result: AppSettingDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface AppSettingDto {
    Name: string;
    App?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitParentID?: number;
    OrganizationUnitName: string;
    Value: string;
    Description?: string;
    /**
     * Entity type: User
     */
    LastModifiedByID: number;
    LastModifiedByFullName?: string;
    LastModificationTime: string;
  }

  /**
   * Get all available typed settings
   * 
   * If available a Description and/or DefaultValue will be returned
   */
  export interface GetAvailableSettings {
    Functionality?: string;
  }

  export interface GetAvailableSettingsResponse {
    Settings: GetAvailableSettingsResponse.Setting[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAvailableSettingsResponse {
    export interface Setting {
      Key: string;
      Description: string;
      DefaultValue: any;
      Sensitivity: EVA.Core.SettingSensitivityTypes;
      Type: string;
      Deprecation?: string;
      EntityType?: EVA.Core.SettingValueEntityTypes;
      AllowMultipleValues: boolean;
      RootLevelOnly: boolean;
      Functionality: string;
    }

  }

  /**
   * Yields the history of given setting.
   */
  export interface GetSettingHistory {
    Key: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export interface GetSettingHistoryResponse {
    Key: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    History: GetSettingHistoryResponse.Setting[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetSettingHistoryResponse {
    export interface Setting {
      Value: string;
      SensitivityType: EVA.Core.SettingSensitivityTypes;
      ModifiedBy: string;
      Timestamp?: EVA.Core.DateTimeOffset;
    }

  }

  /**
   * Service for retrieving the value of a specific setting.
   */
  export interface GetSetting {
    Key: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * @default false
     */
    IncludeChildValues?: boolean;
    /**
     * @default false
     */
    FlattenChildValues?: boolean;
  }

  export interface GetSettingResponse {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    InheritedFromOrganizationUnitID?: number;
    Description?: string;
    DefaultValue?: any;
    Value?: string;
    OrganizationUnitName?: string;
    SensitivityType?: EVA.Core.SettingSensitivityTypes;
    Deprecation?: string;
    IsTypedSetting?: boolean;
    ChildValues?: GetSettingResponse.SettingChild[];
    EntityType?: EVA.Core.SettingValueEntityTypes;
    AllowMultipleValues?: boolean;
    RootLevelOnly?: boolean;
    ViewFunctionality?: GetSettingResponse.FunctionalityInfo;
    EditFunctionality?: GetSettingResponse.FunctionalityInfo;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetSettingResponse {
    export interface SettingChild {
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID?: number;
      /**
       * Entity type: OrganizationUnit
       */
      InheritedFromOrganizationUnitID?: number;
      Value?: string;
      OrganizationUnitName?: string;
      SensitivityType?: EVA.Core.SettingSensitivityTypes;
      ChildValues?: GetSettingResponse.SettingChild[];
      Error?: EVA.Core.ServiceError;
      Metadata?: EVA.Core.ResponseMessageMetadata;
    }

    export interface FunctionalityInfo {
      Categories?: string[];
      Functionality: string;
      Scope: EVA.Core.FunctionalityScope;
    }

  }

  /**
   * Batch update/create settings through an Excel file (file can be retrieved by calling ExportSettings)
   */
  export interface ImportSettings {
    Data: string;
  }

  export interface ImportSettingsResponse {
    Count: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Yields the history of given app setting.
   */
  export interface ListAppSettingHistory {
    Name: string;
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListAppSettingsHistoryFilter>;
    PageToken?: string;
  }

  export interface ListAppSettingHistoryResponse {
    Results?: ListAppSettingHistoryResponse.Setting[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListAppSettingHistoryResponse {
    export interface Setting {
      Value?: string;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID?: number;
      OrganizationUnitBackendID?: string;
      OrganizationUnitName?: string;
      StartTime?: string;
      EndTime?: string;
      /**
       * Entity type: User
       */
      UserID?: number;
      UserFullName?: string;
    }

  }

  /**
   * Yields the history of given setting.
   */
  export interface ListSettingHistory {
    Key: string;
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListSettingsHistoryFilter>;
    PageToken?: string;
  }

  export interface ListSettingHistoryResponse {
    Results?: ListSettingHistoryResponse.Setting[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListSettingHistoryResponse {
    export interface Setting {
      Value?: string;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID?: number;
      OrganizationUnitBackendID?: string;
      OrganizationUnitName?: string;
      SensitivityType?: EVA.Core.SettingSensitivityTypes;
      StartTime?: string;
      EndTime?: string;
      /**
       * Entity type: User
       */
      UserID?: number;
      UserFullName?: string;
    }

  }

  /**
   * List the settings related to given `OrganizationUnitID`.
   */
  export interface ListSettings {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    Key?: string;
    TypedFilter?: ListSettingsTypedFilters;
    ShowDeprecationsOnly?: boolean;
    FunctionalityCategory?: string;
    Functionality?: string;
    SortProperty?: string;
    /**
     * @default Ascending
     */
    SortDirection?: EVA.Core.SortDirection;
  }

  export const enum ListSettingsTypedFilters {
    ShowAll = 0,
    ShowTyped = 1,
    ShowUntyped = 2
  }

  export interface ListSettingsResponse {
    Result: { [key: string]: SettingDto };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface SettingDto {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitParentID?: number;
    OrganizationUnitName: string;
    Value?: string;
    SensitivityType: EVA.Core.SettingSensitivityTypes;
    Description?: string;
    Deprecation?: string;
    IsTypedSetting: boolean;
    CanView: boolean;
    CanEdit: boolean;
    ViewFunctionality: SettingDto.FunctionalityInfo;
    EditFunctionality: SettingDto.FunctionalityInfo;
    RootLevelOnly: boolean;
    /**
     * Entity type: User
     */
    LastModifiedByID: number;
    LastModifiedByFullName: string;
    LastModificationTime: string;
  }

  export namespace SettingDto {
    export interface FunctionalityInfo {
      Categories?: string[];
      Functionality: string;
      Scope: EVA.Core.FunctionalityScope;
    }

  }

  /**
   * List all settings of the user's current organization unit and its 'children', per organization unit.
   */
  export interface ListSettingsPerOrganizationUnit {
    Key?: string;
    TypedFilter?: ListSettingsTypedFilters;
    ShowDeprecationsOnly?: boolean;
    FunctionalityCategory?: string;
    Functionality?: string;
    SortProperty?: string;
    /**
     * @default Ascending
     */
    SortDirection?: EVA.Core.SortDirection;
  }

  export interface ListSettingsPerOrganizationUnitResponse {
    /**
     * Entity type: OrganizationUnit
     */
    Result: { [key: number]: { [key: string]: SettingDto } };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Set a new value for a setting within an OrganizationUnit or apply it to all OrganizationUnits in the selected set
   */
  export interface SetSetting {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Setting are not stored on sets, the set is evaluated when this service is called, and the setting is applied to all OrganizationUnits in the set.
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Key: string;
    Value: string;
  }

  /**
   * Service for setting multiple settings at once
   * 
   * Will apply all changes or no changes in case of an error
   */
  export interface SetSettings {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Setting are not stored on sets, the set is evaluated when this service is called, and the settings are applied to all OrganizationUnits in the set.
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Settings: SetSettings.Setting[];
  }

  export namespace SetSettings {
    export interface Setting {
      Key: string;
      Value: string;
    }

  }

  /**
   * Service for unsetting a setting
   */
  export interface UnsetSetting {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Setting are not stored on sets, the set is evaluated when this service is called, and the unsetting is applied to all OrganizationUnits in the set.
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Key: string;
    /**
     * When a Value is given, the setting will only be removed when the Value matches.
     */
    Value?: string;
  }

  /**
   * Creates a new Company, which represents a legal entity in EVA. Both Users and OrganizationUnits can have a Company that they are a part of.
   */
  export interface CreateCompany {
    Name?: string;
    RegistrationNumber?: string;
    RegistrationCity?: string;
    /**
     * Entity type: Country
     */
    RegistrationCountryID?: string;
    /**
     * Entity type: CountrySubdivision
     */
    RegistrationCountrySubdivisionID?: string;
    VatNumber?: string;
    FiscalID?: string;
    EstablishedDate?: string;
    VisitorsAddress?: EVA.Core.AddressDataDto;
    InvoiceAddress?: EVA.Core.AddressDataDto;
    InvoiceEmailAddress?: string;
    ContactEmailAddress?: string;
    ContactPhoneNumber?: string;
    AccountHolderName?: string;
    IBAN?: string;
    BIC?: string;
    LogoID?: string;
    WasteDisposalNumber?: string;
    TaxOfficeNumber?: string;
    BackendID?: string;
    EntityType?: string;
    SocialCapital?: number;
    IndustryCode?: string;
    /**
     * Optional additional custom fields
     */
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
  }

  export interface CreateCompanyResponse {
    /**
     * Entity type: Company
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Updates a Company. Fields not provided in the request are ignored.
   */
  export interface UpdateCompany {
    /**
     * Entity type: Company
     */
    ID: number;
    Name?: string;
    RegistrationNumber?: string;
    RegistrationCity?: string;
    RegistrationCountryID?: string;
    RegistrationCountrySubdivisionID?: string;
    VatNumber?: string;
    FiscalID?: string;
    EstablishedDate?: string;
    VisitorsAddress?: EVA.Core.AddressDataDto;
    InvoiceAddress?: EVA.Core.AddressDataDto;
    InvoiceEmailAddress?: string;
    ContactEmailAddress?: string;
    ContactPhoneNumber?: string;
    AccountHolderName?: string;
    IBAN?: string;
    BIC?: string;
    LogoID?: string;
    WasteDisposalNumber?: string;
    TaxOfficeNumber?: string;
    Type?: EVA.Core.CompanyType;
    BackendID?: string;
    EntityType?: string;
    SocialCapital?: number;
    IndustryCode?: string;
    /**
     * Optional additional custom fields.
     */
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
  }

  /**
   * Deletes a Company. If a Company is still in use by Users or OrganizationUnits this service will return an error.
   */
  export interface DeleteCompany {
    /**
     * Entity type: Company
     */
    ID: number;
  }

  /**
   * List Companies, optionally filtered.
   */
  export interface ListCompanies {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListCompaniesFilter>;
    PageToken?: string;
  }

  export interface ListCompaniesResponse {
    Results?: EVA.Core.ListCompaniesItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get the details of a specific Company.
   */
  export interface GetCompany {
    /**
     * Entity type: Company
     */
    ID: number;
  }

  export interface GetCompanyResponse {
    /**
     * Entity type: Company
     */
    ID?: number;
    Name?: string;
    RegistrationNumber?: string;
    BackendID?: string;
    RegistrationCity?: string;
    /**
     * Entity type: Country
     */
    RegistrationCountryID?: string;
    /**
     * Entity type: CountrySubdivision
     */
    RegistrationCountrySubdivisionID?: string;
    VatNumber?: string;
    FiscalID?: string;
    EstablishedDate?: string;
    VisitorsAddress?: EVA.Core.AddressDto;
    InvoiceAddress?: EVA.Core.AddressDto;
    InvoiceEmailAddress?: string;
    ContactEmailAddress?: string;
    ContactPhoneNumber?: string;
    AccountHolderName?: string;
    IBAN?: string;
    BIC?: string;
    LogoID?: string;
    WasteDisposalNumber?: string;
    TaxOfficeNumber?: string;
    Type?: EVA.Core.CompanyType;
    VatValidationResult?: EVA.Core.AuditingVatNumberValidationResult;
    EntityType?: string;
    SocialCapital?: number;
    IndustryCode?: string;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: EVA.Core.CustomFieldValueWithOptions };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the company requirements.
   */
  export interface ListCompanyRequirements {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListCompanyRequirementFilter>;
    PageToken?: string;
  }

  export interface ListCompanyRequirementsResponse {
    Results?: ListCompanyRequirementsResponse.CompanyRequirementDto[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCompanyRequirementsResponse {
    export interface CompanyRequirementDto {
      /**
       * Entity type: CompanyRequirement
       */
      ID: number;
      /**
       * Entity type: Country
       */
      CountryID: string;
      ApplyToCompanyType?: EVA.Core.ApplyToCompanyType;
      Property: EVA.Core.CompanyRequirementPropertyType;
      VisibilityType: EVA.Core.CompanyRequirementVisibilityType;
      MinLength?: number;
      MaxLength?: number;
      RegexPattern?: string;
    }

  }

  /**
   * Creates a new compant requirement and returns the ID of the new record.
   */
  export interface CreateCompanyRequirement {
    /**
     * Entity type: Country
     */
    CountryID: string;
    Property: EVA.Core.CompanyRequirementPropertyType;
    VisibilityType: EVA.Core.CompanyRequirementVisibilityType;
    ApplyToCompanyType?: EVA.Core.ApplyToCompanyType;
    MinLength?: number;
    MaxLength?: number;
    RegexPattern?: string;
  }

  export interface CreateCompanyRequirementResponse {
    /**
     * Entity type: CompanyRequirement
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Updates an existing company requirement.
   */
  export interface UpdateCompanyRequirement {
    /**
     * Entity type: CompanyRequirement
     */
    ID: number;
    Property?: EVA.Core.CompanyRequirementPropertyType;
    VisibilityType?: EVA.Core.CompanyRequirementVisibilityType;
    ApplyToCompanyType?: EVA.Core.ApplyToCompanyType;
    MinLength?: number;
    MaxLength?: number;
    RegexPattern?: string;
  }

  /**
   * Deletes a company requirement by its ID.
   */
  export interface DeleteCompanyRequirement {
    /**
     * Entity type: CompanyRequirement
     */
    ID: number;
  }

  /**
   * Get all company requirements of the given type for the given country.
   */
  export interface GetCompanyRequirements {
    /**
     * Entity type: Country
     */
    CountryID: string;
    ApplyToCompanyType: EVA.Core.ApplyToCompanyType;
  }

  export interface GetCompanyRequirementsResponse {
    Requirements: Record<'BackendID' | 'TaxRegistrationNumber' | 'FiscalID' | 'EmailAddress' | 'PhoneNumber' | 'TaxRecipientCode' | 'TaxRecipientEmail' | 'RegistrationNumber' | 'RegistrationCountryID' | 'RegistrationCountrySubdivisionID' | 'TaxOfficeNumber', GetCompanyRequirementsResponse.CompanyRequirementDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetCompanyRequirementsResponse {
    export interface CompanyRequirementDto {
      /**
       * Entity type: CompanyRequirement
       */
      ID: number;
      /**
       * Entity type: Country
       */
      CountryID: string;
      ApplyToCompanyType?: EVA.Core.ApplyToCompanyType;
      Property: EVA.Core.CompanyRequirementPropertyType;
      VisibilityType: EVA.Core.CompanyRequirementVisibilityType;
      MinLength?: number;
      MaxLength?: number;
      RegexPattern?: string;
    }

  }

  /**
   * Creates a new company associated with the organization unit type
   */
  export interface CreateOrganizationUnitCompany {
    BackendID?: string;
    Name?: string;
    RegistrationNumber?: string;
    RegistrationCountryID?: string;
    RegistrationCountrySubdivisionID?: string;
    TaxRegistrationNumber?: string;
    FiscalID?: string;
    TaxOfficeNumber?: string;
    SocialCapital?: number;
    EntityType?: string;
    IndustryCode?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    BillingAddress?: EVA.Core.AddressDataDto;
    ShippingAddress?: EVA.Core.AddressDataDto;
    RegistrationAddress?: EVA.Core.AddressDataDto;
    /**
     * Optional additional custom fields
     */
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
  }

  export interface CreateOrganizationUnitCompanyResponse {
    /**
     * Entity type: Company
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Retrieves the details of the organization unit company corresponding to the specified ID.
   */
  export interface GetOrganizationUnitCompany {
    /**
     * Entity type: Company
     */
    ID: number;
  }

  export interface GetOrganizationUnitCompanyResponse {
    /**
     * Entity type: Company
     */
    ID?: number;
    BackendID?: string;
    Name?: string;
    RegistrationNumber?: string;
    RegistrationCountryID?: string;
    RegistrationCountrySubdivisionID?: string;
    TaxRegistrationNumber?: string;
    FiscalID?: string;
    TaxOfficeNumber?: string;
    SocialCapital?: number;
    EntityType?: string;
    IndustryCode?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    BillingAddress?: EVA.Core.AddressDto;
    ShippingAddress?: EVA.Core.AddressDto;
    RegistrationAddress?: EVA.Core.AddressDto;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: EVA.Core.CustomFieldValueWithOptions };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Push a company. If it doesn't exist it will be created, otherwise is will be updated.
   */
  export interface PushCompany {
    BackendID: string;
    Name?: string;
    RegistrationNumber?: string;
    RegistrationCity?: string;
    /**
     * Entity type: Country
     */
    RegistrationCountryID?: string;
    /**
     * Entity type: CountrySubdivision
     */
    RegistrationCountrySubdivisionID?: string;
    VatNumber?: string;
    FiscalID?: string;
    EstablishedDate?: string;
    VisitorsAddress?: EVA.Core.AddressDataDto;
    InvoiceAddress?: EVA.Core.AddressDataDto;
    RegistrationAddress?: EVA.Core.AddressDataDto;
    InvoiceEmailAddress?: string;
    ContactEmailAddress?: string;
    ContactPhoneNumber?: string;
    AccountHolderName?: string;
    IBAN?: string;
    BIC?: string;
    LogoID?: string;
    WasteDisposalNumber?: string;
    TaxOfficeNumber?: string;
    EntityType?: string;
    SocialCapital?: number;
    IndustryCode?: string;
    CompanyType?: EVA.Core.CompanyType;
  }

  export interface PushCompanyResponse {
    /**
     * Entity type: Company
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Push multiple companies at once.
   * If a company doesn't exist it will be created, otherwise is will be updated.
   * There is a limit (1000) of companies that can be pushed a once.
   */
  export interface PushCompanies {
    Companies: PushCompany[];
    /**
     * Enabling this will try to suppress as many event exports as possible that might result from this call.
     */
    DisableEventExports?: boolean;
  }

  export interface PushCompaniesResponse {
    SuccessfullyAdjustedCompanies: PushCompaniesResponse.SuccessfullyAdjustedCompany[];
    FailedToAdjustCompanies: PushCompaniesResponse.FailedToAdjustCompany[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace PushCompaniesResponse {
    export interface SuccessfullyAdjustedCompany {
      /**
       * Entity type: Company
       */
      ID: number;
    }

    export interface FailedToAdjustCompany {
      BackendID: string;
      ErrorIdentifier: string;
    }

  }

  /**
   * Searches for organization unit companies based on the provided query and filter criteria.
   */
  export interface SearchOrganizationUnitCompany {
    Query?: string;
    PageConfig?: EVA.Core.ScrollablePageConfig<EVA.Core.SearchCompanyFilter>;
  }

  export interface SearchOrganizationUnitCompanyResponse {
    Result: EVA.Core.ScrollablePagedResult<EVA.Core.SearchCompanyResult>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Updates the details of companies associated with the organization unit type.
   */
  export interface UpdateOrganizationUnitCompany {
    /**
     * Entity type: Company
     */
    ID: number;
    Name?: string;
    RegistrationNumber?: string;
    RegistrationCountryID?: string;
    RegistrationCountrySubdivisionID?: string;
    TaxRegistrationNumber?: string;
    FiscalID?: string;
    TaxOfficeNumber?: string;
    SocialCapital?: number;
    EntityType?: string;
    IndustryCode?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    BillingAddress?: EVA.Core.AddressDataDto;
    ShippingAddress?: EVA.Core.AddressDataDto;
    RegistrationAddress?: EVA.Core.AddressDataDto;
    /**
     * Optional additional custom fields
     */
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
  }

  export interface ValidateCompany {
    /**
     * Entity type: Company
     */
    CompanyID?: number;
    BackendID?: string;
    Name?: string;
    RegistrationNumber?: string;
    RegistrationCity?: string;
    /**
     * Entity type: Country
     */
    RegistrationCountryID?: string;
    /**
     * Entity type: CountrySubdivision
     */
    RegistrationCountrySubdivisionID?: string;
    VatNumber?: string;
    FiscalID?: string;
    EstablishedDate?: string;
    VisitorsAddress?: EVA.Core.AddressDataDto;
    RegistrationAddress?: EVA.Core.AddressDataDto;
    InvoiceEmailAddress?: string;
    ContactEmailAddress?: string;
    ContactPhoneNumber?: string;
    AccountHolderName?: string;
    IBAN?: string;
    BIC?: string;
    LogoID?: string;
    WasteDisposalNumber?: string;
    TaxOfficeNumber?: string;
    TaxRecipientCode?: string;
    TaxRecipientEmail?: string;
    /**
     * The type of the company. If not set, defaults to OrganizationUnit.
     */
    Type?: EVA.Core.CompanyType;
    ShowValidDetails?: boolean;
    /**
     * When set, validation will also apply company requirements.
     */
    ApplyRequirements?: boolean;
    EntityType?: string;
    SocialCapital?: number;
    IndustryCode?: string;
  }

  export interface ValidateCompanyResponse {
    IsValid: boolean;
    ValidationDetails: ValidateCompanyResponse.ValidationDetail[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ValidateCompanyResponse {
    export interface ValidationDetail {
      Field: string;
      Constraint: string;
      Message: string;
      IsValid: boolean;
    }

  }

  /**
   * List cases. Returns a paged response.
   */
  export interface ListCases {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListCasesFilter>;
    PageToken?: string;
  }

  export interface ListCasesResponse {
    Results?: ListCasesResponse.Case[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCasesResponse {
    export interface Case {
      /**
       * Entity type: Case
       */
      ID?: number;
      BackendID?: string;
      /**
       * Entity type: CaseTopic
       */
      TopicID?: number;
      TopicName?: string;
      /**
       * Entity type: CaseStatus
       */
      StatusID?: number;
      StatusName?: string;
      StatusColor?: string;
      Priority?: EVA.Core.CasePriority;
      Title?: string;
      /**
       * Entity type: Order
       */
      OrderID?: number;
      OrderDisplayID?: string;
      ExternalOrderIdentifier?: string;
      /**
       * Entity type: User
       */
      AssigneeID?: number;
      AssigneeName?: string;
      ReportingTime?: string;
      LastInteractionTime?: string;
      /**
       * Entity type: User
       */
      CustomerID?: number;
      Customer?: ListCasesResponse.Customer;
      /**
       * Entity type: OrganizationUnit
       */
      OriginatingOrganizationUnitID?: number;
      OriginatingOrganizationUnitName?: string;
      CreationTime?: string;
      LastModificationTime?: string;
      CreatedBy?: ListCasesResponse.User;
      LastModifiedBy?: ListCasesResponse.User;
      /**
       * Entity type: OrganizationUnit
       */
      AssignedOrganizationUnitID?: number;
      AssignedOrganizationUnitName?: string;
    }

    export interface Customer {
      FirstName: string;
      LastName: string;
      EmailAddress: string;
      FullName: string;
    }

    export interface User {
      /**
       * Entity type: User
       */
      ID?: number;
      FirstName: string;
      LastName: string;
      FullName: string;
    }

  }

  /**
   * Gets a case by its ID.
   */
  export interface GetCaseByID {
    /**
     * Entity type: Case
     */
    ID: number;
  }

  export interface GetCaseByIDResponse {
    /**
     * Entity type: Case
     */
    ID: number;
    BackendID: string;
    /**
     * Entity type: CaseStatus
     */
    StatusID: number;
    StatusName: string;
    StatusColor: string;
    Priority: EVA.Core.CasePriority;
    Title: string;
    IsTitleEditable: boolean;
    Description: string;
    IsDescriptionEditable: boolean;
    Summary: string;
    SummaryLastModificationDate?: string;
    /**
     * Entity type: User
     */
    SummaryLastModifiedByID?: number;
    Solution: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    OrderDisplayID?: string;
    OrderCreationTime?: string;
    ExternalOrderIdentifier?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OriginatingOrganizationUnitID?: number;
    OriginatingOrganizationUnitName?: string;
    /**
     * Entity type: User
     */
    AssigneeID?: number;
    AssigneeName: string;
    AssigneeEmail: string;
    AssignedOn?: string;
    ReportingTime: string;
    LastInteractionTime?: string;
    ClosingTime?: string;
    /**
     * Entity type: Blob
     */
    BlobIDs: string[];
    Blobs: GetCaseByIDResponse.CaseBlobModel[];
    RelatedItems: GetCaseByIDResponse.RelatedItem[];
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: EVA.Core.CustomFieldValueWithOptions };
    Customer?: GetCaseByIDResponse.UserInfo;
    CreationTime: string;
    LastModificationTime?: string;
    CreatedBy?: GetCaseByIDResponse.User;
    LastModifiedBy?: GetCaseByIDResponse.User;
    Repairs: GetCaseByIDResponse.CaseRepair[];
    CaseTopic: GetCaseByIDResponse.CaseTopicData;
    /**
     * Entity type: OrganizationUnit
     */
    AssignedOrganizationUnitID?: number;
    AssignedOrganizationUnitName?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetCaseByIDResponse {
    export interface CaseTopicData {
      /**
       * Entity type: CaseTopic
       */
      TopicID?: number;
      TopicName?: string;
      TopicDisplayName?: string;
      TopicBackendID?: string;
      IsDeleted?: boolean;
      CaseTopic?: GetCaseByIDResponse.CaseTopicData;
    }

    export interface RelatedItem {
      /**
       * Entity type: CaseRelatedItem
       */
      ID?: number;
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      /**
       * Entity type: Product
       */
      ProductID?: number;
      Product?: any;
      SerialNumber?: string;
      IsWarranty?: boolean;
      WarrantyExpiration?: string;
      WarrantyAdditionalInformation?: string;
    }

    export interface UserInfo {
      /**
       * Entity type: User
       */
      ID: number;
      BackendID: string;
      FirstName: string;
      LastName: string;
      EmailAddress: string;
      FullName: string;
      PhoneNumber: string;
    }

    export interface CaseRepair {
      /**
       * Entity type: Repair
       */
      ID?: number;
      CreationTime?: string;
      CompletionTime?: string;
      Status?: EVA.Core.RepairStatus;
      SerialNumber?: string;
      RepairTask?: GetCaseByIDResponse.CaseRepairTask;
      RepairAssignee?: GetCaseByIDResponse.UserInfo;
    }

    export interface CaseRepairTask {
      /**
       * Entity type: RepairTask
       */
      ID: number;
      UserTaskSubType: EVA.Core.EnumDto;
    }

    export interface User {
      /**
       * Entity type: User
       */
      ID?: number;
      FirstName: string;
      LastName: string;
      FullName: string;
    }

    export interface CaseBlobModel {
      /**
       * Entity type: Blob
       */
      ID: string;
      Url: string;
    }

  }

  /**
   * Create a new case.
   */
  export interface CreateCase {
    BackendID?: string;
    /**
     * Entity type: CaseTopic
     */
    TopicID: number;
    Title: string;
    Description: string;
    /**
     * Entity type: User
     */
    CustomerID?: number;
    ExternalOrderIdentifier?: string;
    /**
     * Can only be set once. Can be updated when not set on create.
     * Entity type: OrganizationUnit
     */
    OriginatingOrganizationUnitID?: number;
    /**
     * OU the case is assigned to. When set this will influence visibility.
     * Entity type: OrganizationUnit
     */
    AssignedOrganizationUnitID?: number;
    /**
     * Entity type: User
     */
    AssigneeID?: number;
    Priority?: EVA.Core.CasePriority;
    /**
     * Optional additional custom fields
     */
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
  }

  export interface CreateCaseResponse {
    /**
     * Entity type: Case
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing case.
   */
  export interface UpdateCase {
    /**
     * Entity type: Case
     */
    ID: number;
    BackendID?: string;
    /**
     * Entity type: CaseTopic
     */
    TopicID?: number;
    Title?: string;
    Description?: string;
    /**
     * Entity type: User
     */
    CustomerID?: number;
    ExternalOrderIdentifier?: string;
    /**
     * Can only be set once. Can be updated when not set on create.
     * Entity type: OrganizationUnit
     */
    OriginatingOrganizationUnitID?: number;
    /**
     * OU the case is assigned to. When set this will influence visibility.
     * Entity type: OrganizationUnit
     */
    AssignedOrganizationUnitID?: number;
    /**
     * Optional additional custom fields
     */
    CustomFields?: EVA.Core.CustomFieldKeyValue[];
  }

  /**
   * Update an existing case state.
   */
  export interface UpdateCaseState {
    /**
     * Entity type: Case
     */
    ID: number;
    /**
     * Entity type: CaseStatus
     */
    StatusID: number;
    /**
     * Entity type: User
     */
    AssigneeID?: number;
    Priority?: EVA.Core.CasePriority;
    /**
     * The solution for the case
     */
    Solution?: string;
  }

  export interface UpdateCaseStateResponse {
    StatusAction: EVA.Core.CaseStatusAction;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing case summary.
   */
  export interface UpdateCaseSummary {
    /**
     * Entity type: Case
     */
    ID: number;
    /**
     * A summary of the current state of the case
     */
    Summary: string;
  }

  /**
   * Archive a case.
   */
  export interface ArchiveCase {
    /**
     * Entity type: Case
     */
    ID: number;
  }

  /**
   * Attach blob to case.
   */
  export interface AttachBlobToCase {
    /**
     * Entity type: Case
     */
    CaseID?: number;
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     * @deprecated Use `BlobUrls` instead.
     */
    BlobUrl?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrls?: string[];
  }

  /**
   * Detaches and deletes a blob from a case.
   */
  export interface DeleteCaseBlob {
    /**
     * Entity type: Case
     */
    CaseID?: number;
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrl?: string;
  }

  /**
   * List all the blobs that are attached to the case.
   */
  export interface ListBlobsForCase {
    /**
     * Entity type: Case
     */
    CaseID: number;
  }

  export interface ListBlobsForCaseResponse {
    Result: ListBlobsForCaseResponse.Blob[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListBlobsForCaseResponse {
    export interface Blob {
      Name: string;
      MimeType: string;
      BlobID: string;
      Url: string;
      CreationTime: string;
    }

  }

  /**
   * Set case related data.
   * You can provide an OrderID (optional)
   * You can provide an ExternalOrderID (optional)
   * You can provide further details by setting RelatedItems. These can either
   * - contain a OrderLineID (can only be provided if OrderID is also provided. The ProductID of the orderline will copied to the ProductID of the RelatedItem)
   * - contain a ProductID
   * - a SerialNumber (is settable whether you provided a OrderLineID or ProductID)
   * - a IsWarranty indicator (is settable when there's an associated ProductID or the orderline contains a product)
   */
  export interface SetCaseRelatedData {
    /**
     * Entity type: Case
     */
    CaseID: number;
    ExternalOrderIdentifier?: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Overwrite case customer with the customer bound to the order.
     */
    OverwriteCaseCustomerWithCustomerOfOrder?: boolean;
    RelatedItems?: SetCaseRelatedData.RelatedItem[];
  }

  export namespace SetCaseRelatedData {
    export interface RelatedItem {
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      /**
       * Entity type: Product
       */
      ProductID?: number;
      SerialNumber?: string;
      IsWarranty?: boolean;
      WarrantyExpiration?: string;
      WarrantyAdditionalInformation: string;
    }

  }

  /**
   * Remove case related items.
   */
  export interface RemoveCaseRelatedItems {
    /**
     * Entity type: Case
     */
    CaseID?: number;
    /**
     * Entity type: CaseRelatedItem
     */
    ItemIDs?: number[];
    RemoveAll?: boolean;
  }

  /**
   * List the case interactions
   */
  export interface ListCaseInteractions {
    /**
     * Entity type: Case
     */
    CaseID: number;
    IncludeRepairInteractions?: boolean;
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListCaseInteractionsFilter>;
    PageToken?: string;
  }

  export interface ListCaseInteractionsResponse {
    Results?: ListCaseInteractionsResponse.CaseInteraction[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCaseInteractionsResponse {
    export interface CaseInteraction {
      /**
       * Entity type: Interaction
       */
      ID?: number;
      BackendID?: string;
      /**
       * Entity type: Repair
       */
      RepairID?: number;
      InteractionType?: EVA.Core.InteractionType;
      CanBeMutated?: boolean;
      Text?: string;
      CreationTime?: string;
      LastModificationTime?: string;
      CreatedBy?: ListCaseInteractionsResponse.User;
    }

    export interface User {
      /**
       * Entity type: User
       */
      CreatedByID?: number;
      FirstName: string;
      LastName: string;
      FullName: string;
    }

  }

  /**
   * Get case interaction
   */
  export interface GetCaseInteraction {
    /**
     * Entity type: Interaction
     */
    ID: number;
  }

  export interface GetCaseInteractionResponse {
    /**
     * Entity type: Interaction
     */
    ID: number;
    BackendID?: string;
    /**
     * Entity type: Case
     */
    CaseID: number;
    InteractionType: EVA.Core.InteractionType;
    CanBeMutated: boolean;
    Text: string;
    CreationTime: string;
    LastModificationTime?: string;
    BlobIDs: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Creates a new case interaction
   */
  export interface CreateCaseInteraction {
    /**
     * Entity type: Case
     */
    CaseID: number;
    InteractionType: EVA.Core.InteractionType;
    Text: string;
    BackendID?: string;
  }

  export interface CreateCaseInteractionResponse {
    /**
     * Entity type: Interaction
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update a case interaction
   */
  export interface UpdateCaseInteraction {
    /**
     * Entity type: Interaction
     */
    ID: number;
    BackendID?: string;
    Text: string;
  }

  /**
   * Delete a case interaction
   */
  export interface DeleteCaseInteraction {
    /**
     * Entity type: Interaction
     */
    ID: number;
  }

  /**
   * Add a blob to a case interacion.
   */
  export interface AddBlobToCaseInteraction {
    /**
     * Entity type: Interaction
     */
    InteractionID?: number;
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     * @deprecated Use `BlobUrls` instead.
     */
    BlobUrl?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrls?: string[];
  }

  /**
   * Remove a blob from a case interaction.
   */
  export interface RemoveCaseInteractionBlob {
    /**
     * Entity type: Interaction
     */
    InteractionID?: number;
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrl?: string;
  }

  /**
   * List the case statuses
   */
  export interface ListCaseStatuses {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListCaseStatusesFilter>;
    PageToken?: string;
  }

  export interface ListCaseStatusesResponse {
    Results?: ListCaseStatusesResponse.CaseStatus[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCaseStatusesResponse {
    export interface CaseStatus {
      /**
       * Entity type: CaseStatus
       */
      ID: number;
      BackendID?: string;
      Name: string;
      Description: string;
      Action: EVA.Core.CaseStatusAction;
      IsClosed: boolean;
      Color?: string;
    }

  }

  /**
   * Get case status
   */
  export interface GetCaseStatus {
    /**
     * Entity type: CaseStatus
     */
    ID: number;
  }

  export interface GetCaseStatusResponse {
    /**
     * Entity type: CaseStatus
     */
    ID: number;
    BackendID?: string;
    Name: string;
    Description: string;
    IsClosed: boolean;
    Action: EVA.Core.CaseStatusAction;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    IsSystem: boolean;
    Color?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Creates a new case status
   */
  export interface CreateCaseStatus {
    Name?: string;
    BackendID?: string;
    Description?: string;
    IsClosed?: boolean;
    Action?: EVA.Core.CaseStatusAction;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    Color?: string;
  }

  export interface CreateCaseStatusResponse {
    /**
     * Entity type: CaseStatus
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update a case status
   */
  export interface UpdateCaseStatus {
    /**
     * Entity type: CaseStatus
     */
    ID: number;
    Name?: string;
    BackendID?: string;
    Description?: string;
    IsClosed?: boolean;
    Action?: EVA.Core.CaseStatusAction;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    Color?: string;
  }

  /**
   * Delete a case status
   */
  export interface DeleteCaseStatus {
    /**
     * Entity type: CaseStatus
     */
    ID: number;
  }

  /**
   * List the case topics
   */
  export interface ListCaseTopics {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListCaseTopicsFilter>;
    PageToken?: string;
  }

  export interface ListCaseTopicsResponse {
    Results?: ListCaseTopicsResponse.CaseTopic[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListCaseTopicsResponse {
    export interface CaseTopic {
      /**
       * Entity type: CaseTopic
       */
      ID: number;
      /**
       * Entity type: CaseTopic
       */
      ParentID?: number;
      BackendID?: string;
      Name: string;
      DisplayName: string;
      Description: string;
    }

  }

  /**
   * Get case topic
   */
  export interface GetCaseTopic {
    /**
     * Entity type: CaseTopic
     */
    ID: number;
  }

  export interface GetCaseTopicResponse {
    /**
     * Entity type: CaseTopic
     */
    ID: number;
    /**
     * Entity type: CaseTopic
     */
    ParentID?: number;
    BackendID?: string;
    Name: string;
    DisplayName: string;
    Description: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Creates a new case topic
   */
  export interface CreateCaseTopic {
    /**
     * Can only be set on creation
     * Entity type: CaseTopic
     */
    ParentID?: number;
    Name?: string;
    BackendID?: string;
    Description?: string;
  }

  export interface CreateCaseTopicResponse {
    /**
     * Entity type: CaseTopic
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update a case topic
   */
  export interface UpdateCaseTopic {
    /**
     * Entity type: CaseTopic
     */
    ID: number;
    Name?: string;
    BackendID?: string;
    Description?: string;
  }

  /**
   * Delete a case topic. NOTE THAT sub topics will also be deleted.
   */
  export interface DeleteCaseTopic {
    /**
     * Entity type: CaseTopic
     */
    ID: number;
  }

  /**
   * Push and import a case.
   */
  export interface PushCase {
    /**
     * The ID field can be used to update an existing Case (specifically to be able to update the backend ID). If the ID is provided, the Update field does not need to be set.
     * Entity type: Case
     */
    ID?: number;
    /**
     * Setting this to true will try to suppress as many event exports as possible that might result from this call.
     */
    DisableEventExports?: boolean;
    /**
     * Setting this to true will update the case information if it already exists instead of throwing an error.
     */
    Update?: boolean;
    BackendID: string;
    /**
     * The topic that this case is a part of. If a BackendID is provided and a CaseTopic exists with that ID, that CaseTopic is used, no matter what Name or ParentBackendID are passed and if they match.
     *   If no CaseTopic exists with the given BackendID, but one does exist with the given Name and ParentBackendID, that CaseTopic is used instead, disregarding what BackendID was passed in the request.
     *   If none of these conditions are met, a new CaseTopic is created.
     */
    CaseTopic: PushCase.PushCaseTopic;
    Title: string;
    Description: string;
    Summary?: string;
    Solution?: string;
    Customer?: PushCase.PushCaseCustomer;
    OriginatingOrganizationUnitBackendID?: string;
    /**
     * OU the case is assigned to. When set this will influence visibility.
     */
    AssignedOrganizationUnitBackendID?: string;
    Assignee?: PushCase.PushCaseAssignee;
    AssignedOn?: string;
    Priority?: EVA.Core.CasePriority;
    Status?: string;
    ReportingTime?: string;
    LastInteractionTime?: string;
    ClosingTime?: string;
    CustomFields?: { [key: string]: any };
    Interactions?: PushCase.PushCaseInteraction[];
    CaseRelatedItems?: PushCase.PushCaseRelatedItems;
  }

  export namespace PushCase {
    export interface PushCaseRelatedItems {
      OrderID?: string;
      Items?: PushCase.PushCaseRelatedItem[];
    }

    export interface PushCaseRelatedItem {
      OrderLineID?: string;
      ProductID?: string;
      SerialNumber?: string;
      IsWarranty?: boolean;
      WarrantyExpiration?: string;
      WarrantyAdditionalInformation?: string;
      /**
       * If specified as true, the item will be deleted.
       */
      Delete?: boolean;
    }

    export interface PushCaseCustomer {
      BackendID?: string;
      EmailAddress?: string;
      /**
       * Possible values are: M, F, O
       */
      Gender?: string;
      Initials?: string;
      FirstName?: string;
      LastName?: string;
      PhoneNumber?: string;
      DateOfBirth?: string;
      PlaceOfBirth?: string;
      BankAccount?: string;
      Nickname?: string;
      ShippingAddress?: PushCase.PushCaseAddress;
      BillingAddress?: PushCase.PushCaseAddress;
      /**
       * ISO 639-1
       * Entity type: Language
       */
      LanguageID?: string;
      /**
       * ISO 3166-1
       * Entity type: Country
       */
      CountryID?: string;
      FiscalID?: string;
      SocialSecurityNumber?: string;
      Title?: string;
      Salutation?: string;
      /**
       * Is this a Standard/Basic/Incognito account?
       * @default Standard
       */
      AccountType?: EVA.Core.UserAccountType;
      Company?: PushCase.PushCaseCustomerCompany;
      BackendRelationID?: string;
    }

    export interface PushCaseCustomerCompany {
      Name?: string;
      RegistrationNumber?: string;
      VatNumber?: string;
      FiscalID?: string;
    }

    export interface PushCaseAddress {
      Address1?: string;
      Address2?: string;
      /**
       * House number, including possible extensions
       */
      HouseNumber?: string;
      FirstName?: string;
      LastName?: string;
      ZipCode?: string;
      City?: string;
      Region?: string;
      District?: string;
      Subdistrict?: string;
      EmailAddress?: string;
      PhoneNumber?: string;
      /**
       * ISO 3166-2
       */
      State?: string;
      /**
       * ISO 3166-1
       */
      CountryID?: string;
    }

    export interface PushCaseAssignee {
      /**
       * If specified as true, the assignee will be removed from the case.
       */
      Remove?: boolean;
      /**
       * Entity type: User
       */
      ID?: number;
      CustomID?: string;
      EmailAddress?: string;
    }

    export interface PushCaseInteraction {
      BackendID: string;
      /**
       * If specified as true, the interaction will be deleted.
       */
      Delete: boolean;
      Type: EVA.Core.InteractionType;
      Text: string;
    }

    export interface PushCaseTopic {
      /**
       * Required if pushing and creating a previously non-existent CaseTopic
       */
      Name?: string;
      BackendID?: string;
      /**
       * Provide a ParentID, or nothing if the CaseTopic should be root-level.
       */
      ParentBackendID?: string;
    }

  }

  export interface PushCaseResponse {
    /**
     * Entity type: Case
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Validates the current settings and properties of an auditing provider.
   */
  export interface AuditingValidateConfiguration {
    AuditingProvider: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface AuditingConfigurationResponse {
    Success: boolean;
    Errors: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Resets the Financial Periods for given OU and all children to which the auditing provider applies. **Use with care!**
   */
  export interface AuditingResetFinancialPeriods {
    AuditingProvider: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    MarkAsProcessed: boolean;
  }

  /**
   * Update the private key version and reset the auditing chain.
   */
  export interface AuditingSetPrivateKey {
    PrivateKeyFile?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  /**
   * Retrieves the required auditing settings for the specified organization unit, including their value, if set.
   */
  export interface GetAuditingSettings {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetAuditingSettingsResponse {
    AuditingSettings: AuditingSetting[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface AuditingSetting {
    Key: string;
    Name: string;
    Value: string;
    Group: string;
    Type: EVA.Core.AuditingSettingType;
  }

  /**
   * Sets the required auditing settings for the specific organization unit
   */
  export interface SetAuditingSettings {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    AuditingSettings: { [key: string]: string };
  }

  /**
   * Auditing service for uploading your public and private key configuration
   */
  export interface AuditingUploadKeySet {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    PrivateKey: string;
    PublicKey: string;
  }

  /**
   * Set the AML rules for a specific country. When no rules are provided, the configuration will be deleted.
   */
  export interface CreateOrUpdateAMLConfiguration {
    /**
     * Entity type: Country
     */
    CountryID: string;
    Rules: AMLRuleDto[];
  }

  export interface AMLRuleDto {
    TriggerType: EVA.Core.AMLTriggerType;
    Threshold?: number;
    SlidingWindowDays?: number;
    Blocked: boolean;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    RequireIdentification: boolean;
    RequireIdentificationBlob: boolean;
    RequireCustomer: boolean;
    RequireCustomerVerification: boolean;
    RequireSurvey: boolean;
    /**
     * Entity type: Survey
     */
    SurveyID?: number;
    SystemSurvey?: EVA.Core.AMLSystemSurveys;
    RequireCustomerSignature: boolean;
    RequireEmployeeSignature: boolean;
    Foreigner: boolean;
    Business: boolean;
  }

  /**
   * List all AML configurations.
   */
  export interface ListAMLConfigurations {
    InitialPageConfig?: EVA.Core.PageTokenConfig<EVA.Core.ListConfigurationsFilter>;
    PageToken?: string;
  }

  export interface ListAMLConfigurationsResponse {
    Results?: AMLConfigurationDto[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface AMLConfigurationDto {
    /**
     * Entity type: Country
     */
    CountryID: string;
    Rules: AMLRuleDto[];
  }

  /**
   * Create a new Account to be used in Cookbook. Name and ObjectAccount are required.
   */
  export interface CreateAccount {
    Name: string;
    ObjectAccount: string;
    Subsidiary?: string;
    BookingFlags?: EVA.Core.BookingFlags;
    BackendCode?: string;
    Type?: EVA.Core.AccountType;
  }

  export interface CreateAccountResponse {
    /**
     * Entity type: Account
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update an existing Account. Make sure all properties are filled.
   */
  export interface UpdateAccount {
    /**
     * Entity type: Account
     */
    ID: number;
    Name?: string;
    ObjectAccount?: string;
    Subsidiary?: string;
    BookingFlags?: EVA.Core.BookingFlags;
    BackendCode?: string;
    Type?: EVA.Core.AccountType;
  }

  /**
   * Delete an existing Account
   */
  export interface DeleteAccount {
    /**
     * Entity type: Account
     */
    ID: number;
  }

  /**
   * Get all the properties of an existing Account
   */
  export interface GetAccount {
    /**
     * Entity type: Account
     */
    ID: number;
  }

  export interface GetAccountResponse {
    /**
     * Entity type: Account
     */
    ID: number;
    Name: string;
    ObjectAccount: string;
    Subsidiary?: string;
    BookingFlags: EVA.Core.BookingFlags;
    BackendCode?: string;
    Type: EVA.Core.AccountType;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the active accounts
   * 
   * Available filters:
   * - Name
   * - ObjectAccount
   */
  export interface ListAccounts {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListAccountsFilter>;
  }

  export interface ListAccountsResponse {
    Result?: EVA.Core.PagedResult<EVA.Core.ListAccountsItem>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Push a LoyaltyProgram.
   * If it doesn't exist it will be created, otherwise is will be updated.
   * Sub entities will also be created or updated, but will not be removed.
   */
  export interface PushLoyaltyProgram {
    ID: string;
    LoyaltyProgramGroupID?: string;
    /**
     * Attaches the loyalty program to a consumer company.
     */
    CompanyID?: string;
    Name?: string;
    Description?: string;
    Options?: EVA.Core.LoyaltyProgramOptions;
    /**
     * Entity type: Currency
     */
    BudgetCurrencyID?: string;
    Budget?: number;
    DeactivateWhenBudgetIsReached?: boolean;
    ReactivateProgramWhenPossible?: boolean;
    StartDate?: string;
    EndDate?: string;
    Status?: EVA.Core.LoyaltyProgramStatus;
    Handler?: string;
    Data?: any;
    ReloadPolicy?: string;
    LoyaltyPointUsageOptions?: EVA.Core.LoyaltyPointUsageOptions;
    PointPendingPolicyType?: string;
    PointPendingPolicyData?: { [key: string]: any };
    PointExpirationPolicyType?: string;
    PointExpirationPolicyData?: { [key: string]: any };
    /**
     * When true, the loyalty program will only be applied when a customer is attached to the order.
     * 
     * When false, the loyalty program can be attached to the order even if there is no customer attached.
     */
    RequireCustomer?: boolean;
    /**
     * When true, the loyalty program will only be applied when a customer is attached to the order that is already subscribed to the loyalty program.
     * Also, this will make the `RequireCustomer` automatically true and `AutoSubscribeCustomer` false.
     * 
     * When false, the loyalty program can be attached to the order if a customer is attached that isn't already subscribed to the loyalty program.
     */
    RequiresSubscribedCustomer?: boolean;
    /**
     * When true, if a non anonymous customer is attached to the order they will be automatically subscribed on finishing the order.
     * When false, the customer will not be subscribed.
     * 
     * This is ignore when`RequiresSubscribedCustomer` or `RequiresSubscriptionValidation` is set to true.
     */
    AutoSubscribeCustomer?: boolean;
    /**
     * When true, the order will require that the attached customer on the order will be validated by providing the UserIdentifier in the `AttachBenefitProgramToOrder` service.
     * Also, this will make the `RequireCustomer` and `RequiresSubscribedCustomer` automatically true and `AutoSubscribeCustomer` false.
     * 
     * When false, this validation isn't required.
     */
    RequiresSubscriptionValidation?: boolean;
    UserMaximumUsage?: number;
    UserBudget?: number;
    /**
     * When set to true, subscribing the user will require a UserIdentifier to be given.
     * Attention!
     * This value will be used to create a subscription when either `RequiredCustomer` or `AutoSubscribeCustomer` is set to true.
     * When this is not the case on create, this can be introduced on update. This value cannot be changed after it is set in either the create or update.
     */
    RequireManualUserIdentifier?: boolean;
    /**
     * Attention!
     * This value will be used to create a subscription when either `RequiredCustomer` or `AutoSubscribeCustomer` is set to true.
     * When this is not the case on create, this can be introduced on update. This value cannot be changed after it is set in either the create or update.
     */
    UserIdentifierPrefix?: string;
    /**
     * Attention!
     * This value will be used to create a subscription when either `RequiredCustomer` or `AutoSubscribeCustomer` is set to true.
     * When this is not the case on create, this can be introduced on update. This value cannot be changed after it is set in either the create or update.
     * Min: 0
     */
    UserIdentifierStartNumber?: number;
    /**
     * Attention!
     * This value will be used to create a subscription when either `RequiredCustomer` or `AutoSubscribeCustomer` is set to true.
     * When this is not the case on create, this can be introduced on update. This value cannot be changed after it is set in either the create or update.
     */
    UserIdentifierSuffix?: string;
    /**
     * Handling when a user is unsubscribed and re-subscribes.
     */
    ResubscribeHandling?: EVA.Core.ResubscribeHandlingType;
    /**
     * Indicates if the subscription can be unsubscribed and if so, who can do the unsubscribe.
     */
    AllowUnsubscribeBy?: EVA.Core.AllowUnsubscribeByType;
    OrganizationUnitSets?: PushLoyaltyProgram.PushLoyaltyProgramOrganizationUnitSet[];
    PriceLists?: string[];
    Conditions?: PushLoyaltyProgram.PushLoyaltyProgramCondition[];
    PaymentTypes?: PushLoyaltyProgram.PushLoyaltyProgramPaymentType[];
    ProductLimitations?: PushLoyaltyProgram.PushLoyaltyProgramProductLimitation[];
    PointAwardingRules?: PushLoyaltyProgram.PushPointAwardingRule[];
    RequiredCustomFields?: string[];
  }

  export namespace PushLoyaltyProgram {
    export interface PushLoyaltyProgramOrganizationUnitSet {
      OrganizationUnitSetID: string;
      SubscriptionConfirmation?: EVA.Core.SubscriptionConfirmation;
      Enabled: boolean;
      Hidden: boolean;
    }

    export interface PushLoyaltyProgramCondition {
      ID: string;
      Type: string;
      Data: { [key: string]: any };
    }

    export interface PushLoyaltyProgramPaymentType {
      ID: string;
      /**
       * Min: 0
       */
      Sequence?: number;
      Required: boolean;
      AllowPartialPayment: boolean;
      PaymentTypeID: string;
      TaxHandling: EVA.Core.LoyaltyPaymentTaxHandlingType;
      Budget?: number;
      ExcludeFromProgramBudget?: boolean;
      /**
       * Min: 0
       */
      UserMaximumUsage?: number;
      UserBudgetDeduction?: EVA.Core.UserBudgetDeduction;
      /**
       * Min: 0
       */
      UserBudget?: number;
      /**
       * Min: 0
       */
      MaximumAmountPerOrder?: number;
      /**
       * Range: 0-100
       */
      MaximumPercentageOfUserBudgetPerOrder?: number;
      ProductLimitation?: PushLoyaltyProgramPaymentType.ProductLimitationData;
    }

    export namespace PushLoyaltyProgramPaymentType {
      export interface ProductLimitationData {
        ProductIDs?: string[];
        ProductSearchID?: string;
        Filters?: { [key: string]: EVA.Core.FilterModel };
        /**
         * The quantity limit over the entire product limitation product set per user.
         * Min: 1
         */
        OverallQuantityLimitPerUser?: number;
        /**
         * The quantity limit over the entire product limitation product set per order.
         * Min: 1
         */
        OverallQuantityLimitPerOrder?: number;
        /**
         * The quantity limit per product within the product limitation product set per user.
         * Min: 1
         */
        QuantityLimitPerUser?: number;
        /**
         * The quantity limit per product within the product limitation product set per order.
         * Min: 1
         */
        QuantityLimitPerOrder?: number;
      }

    }

    export interface PushLoyaltyProgramProductLimitation {
      ID: string;
      Name: string;
      ApplyToPriceList: boolean;
      ProductIDs?: string[];
      ProductSearchID?: string;
      Filters?: { [key: string]: EVA.Core.FilterModel };
      /**
       * Min: 0
       */
      QuantityLimitPerUser?: number;
      /**
       * Min: 0
       */
      OverallQuantityLimitPerUser?: number;
      /**
       * Min: 0
       */
      QuantityLimitPerOrder?: number;
      /**
       * Min: 0
       */
      OverallQuantityLimitPerOrder?: number;
    }

    export interface PushPointAwardingRule {
      ID?: string;
      OrganizationUnitSetID?: string;
      Name?: string;
      Description?: string;
      MarketingDescription?: string;
      Enabled?: boolean;
      StartDate?: string;
      EndDate?: string;
      ApplyRecursive?: boolean;
      PointsToAward?: number;
      PointPendingPolicyType?: string;
      PointPendingPolicyData?: any;
      PointExpirationPolicyType?: string;
      PointExpirationPolicyData?: any;
      Conditions?: PushLoyaltyProgram.PushPointAwardingRuleCondition[];
    }

    export interface PushPointAwardingRuleCondition {
      ID: string;
      Type: string;
      Data?: any;
    }

  }

  export interface PushLoyaltyProgramResponse {
    /**
     * Entity type: LoyaltyProgram
     */
    ID: number;
    /**
     * Entity type: Subscription
     */
    SubscriptionID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Push multiple loyalty programs at once.
   * If a loyalty program doesn't exist it will be created, otherwise it will be updated.
   * Sub entities will also be created or updated, but will not be removed.
   * There is a limit (1000) of loyalty programs that can be pushed a once.
   */
  export interface PushLoyaltyPrograms {
    LoyaltyPrograms: PushLoyaltyProgram[];
    /**
     * Enabling this will try to suppress as many event exports as possible that might result from this call.
     */
    DisableEventExports?: boolean;
  }

  export interface PushLoyaltyProgramsResponse {
    SuccessfullyAdjustedLoyaltyPrograms: PushLoyaltyProgramsResponse.SuccessfullyAdjustedLoyaltyProgram[];
    FailedToAdjustLoyaltyPrograms: PushLoyaltyProgramsResponse.FailedToAdjustLoyaltyProgram[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace PushLoyaltyProgramsResponse {
    export interface SuccessfullyAdjustedLoyaltyProgram {
      /**
       * Entity type: LoyaltyProgram
       */
      ID: number;
    }

    export interface FailedToAdjustLoyaltyProgram {
      BackendID: string;
      ErrorIdentifier: string;
    }

    export interface PushLoyaltyProgramService {
    }

  }

}declare module EVA.Core {

  export namespace Errors {
    export const enum AsyncResult {
      /**
       * JobID cannot be null
       */
      JobIDRequired = 'AsyncResult:JobIDRequired'
    }

    export const enum MessageMiddleware {
      /**
       * Service call was locked
       */
      ServiceLocked = 'MessageMiddleware:ServiceLocked'
    }

    export const enum Wishlist {
      /**
       * Name must be unique. '{0:string}' already exists.
       */
      NameMustBeUnique = 'Wishlist:NameMustBeUnique',
      /**
       * Cannot attach wishlist to employee or api.
       */
      CannotAttachWishlistToEmployeeOrApi = 'Wishlist:CannotAttachWishlistToEmployeeOrApi',
      /**
       * Cannot add more than {0:number} products to a wishlist.
       */
      CannotAddMoreThanXProductsToWishlist = 'Wishlist:CannotAddMoreThanXProductsToWishlist',
      /**
       * Cannot provide more then {0:number} email addresses to share to.
       */
      CannotProvideMoreThenXEmailAddressesToShareTo = 'Wishlist:CannotProvideMoreThenXEmailAddressesToShareTo',
      /**
       * You are already linked to this wishlist.
       */
      AlreadyLinkedToWishlist = 'Wishlist:AlreadyLinkedToWishlist'
    }

    export const enum VisibilityGroups {
      /**
       * The default visibility group cannot be mutated.
       */
      DefaultIsImmutable = 'VisibilityGroups:DefaultIsImmutable',
      /**
       * Name '{0}' already exists.
       */
      NameAlreadyExists = 'VisibilityGroups:NameAlreadyExists',
      /**
       * The selected visibility group is not visible for the current user.
       */
      SelectedVisibilityGroupIsNotVisibleForUser = 'VisibilityGroups:SelectedVisibilityGroupIsNotVisibleForUser',
      /**
       * There is already a User with the same EmailAddress in the selected visibility group.
       */
      EmailAddressAlreadyInUse = 'VisibilityGroups:EmailAddressAlreadyInUse',
      /**
       * There is already a User with the same Nickname in the selected visibility group.
       */
      NicknameAlreadyInUse = 'VisibilityGroups:NicknameAlreadyInUse'
    }

    export const enum FullStockCount {
      /**
       * There is currently a Full Stock Count in progress.
       */
      CountInProgress = 'FullStockCount:CountInProgress',
      /**
       * An active/uncompleted (External) FullStockCount already exists.
       */
      FullStockCountAlreadyExists = 'FullStockCount:FullStockCountAlreadyExists',
      /**
       * Full Stock Count is not available for this action.
       */
      CountNotAvailable = 'FullStockCount:CountNotAvailable',
      /**
       * Full Stock Count label is not available for this action.
       */
      LabelNotAvailable = 'FullStockCount:LabelNotAvailable',
      /**
       * Specify a FullStockCountID or FullStockCountLabelID.
       */
      SpecifyCountOrLabel = 'FullStockCount:SpecifyCountOrLabel',
      /**
       * Please recount the specific product and that product only.
       */
      IncorrectProduct = 'FullStockCount:IncorrectProduct',
      /**
       * Recount must be performed by another user.
       */
      RecountMustBePerformedByAnotherUser = 'FullStockCount:RecountMustBePerformedByAnotherUser',
      /**
       * The is no shelf planning present.
       */
      NoShelfPlanningPresent = 'FullStockCount:NoShelfPlanningPresent',
      /**
       * Full stock count hasn't started yet.
       */
      FullStockCountHasntStartedYet = 'FullStockCount:FullStockCountHasntStartedYet',
      /**
       * Label {0:string} cannot be used for full stock count.
       */
      LabelCannotBeUsedForFullStockCount = 'FullStockCount:LabelCannotBeUsedForFullStockCount',
      /**
       * Cannot recount products when there are still labels open.
       */
      CannotRecountProductsWhenThereAreUncompletedLabels = 'FullStockCount:CannotRecountProductsWhenThereAreUncompletedLabels',
      /**
       * Cannot recount StockLabels {0:string} because there a no FullStockCountLabels present for these StockLabels.
       */
      CannotRecountStockLabelsWithoutFullStockCountLabels = 'FullStockCount:CannotRecountStockLabelsWithoutFullStockCountLabels',
      /**
       * Cannot recount uncompleted label
       */
      CannotRecountUncompletedLabel = 'FullStockCount:CannotRecountUncompletedLabel',
      /**
       * Cannot recount label with uncompleted recounts
       */
      CannotRecountLabelWithUncompletedRecounts = 'FullStockCount:CannotRecountLabelWithUncompletedRecounts',
      /**
       * Recount label {labelID:number} refers to non exisisting origin label {originLabelID:number}
       */
      RecountLabelRefersToANonExisistingOriginLabel = 'FullStockCount:RecountLabelRefersToANonExisistingOriginLabel',
      /**
       * Label only accepts counts from predefined products within the label.
       */
      LabelOnlyAcceptsPredefinedProducts = 'FullStockCount:LabelOnlyAcceptsPredefinedProducts',
      /**
       * Cannot add label to an external full stock count. Use either the 'SetExternalFullStockCountResult' or 'UploadExternalFullStockCountResult' service to set the results of the external full stock count.
       */
      CannotAddLabelToExternalFullStockCount = 'FullStockCount:CannotAddLabelToExternalFullStockCount',
      /**
       * External full stock counts cannot be recounted. Use either the 'SetExternalFullStockCountResult' or 'UploadExternalFullStockCountResult' service to set the results of the external full stock count.
       */
      ExternalFullStockCountsCannotBeRecounted = 'FullStockCount:ExternalFullStockCountsCannotBeRecounted',
      /**
       * The external full stock count reached the completion threshold. Result will no longer be accepted and task can only be cancelled.
       */
      FullStockCountCompletionThresholdReached = 'FullStockCount:FullStockCountCompletionThresholdReached',
      /**
       * External full stock counts cannot be started.
       */
      ExternalFullStockCountsCannotBeStarted = 'FullStockCount:ExternalFullStockCountsCannotBeStarted',
      /**
       * Can only upload results to external full stock counts.
       */
      CannotUploadResultToANonExternalFullStockCount = 'FullStockCount:CannotUploadResultToANonExternalFullStockCount',
      /**
       * External full stock count already completed.
       */
      ExternalFullStockCountAlreadyCompleted = 'FullStockCount:ExternalFullStockCountAlreadyCompleted',
      /**
       * External full stock count cancelled.
       */
      ExternalFullStockCountCancelled = 'FullStockCount:ExternalFullStockCountCancelled',
      /**
       * External full stock count results still processing.
       */
      ExternalFullStockCountDataStillProcessing = 'FullStockCount:ExternalFullStockCountDataStillProcessing',
      /**
       * Cannot complete FullStockCount with active FullStockCountLabel tasks.
       */
      CannotCompleteFullStockCountWithActiveFullStockCountLabelTasks = 'FullStockCount:CannotCompleteFullStockCountWithActiveFullStockCountLabelTasks',
      /**
       * Either `RecountItems` or `ProductIDs` is required.
       */
      EitherRecountItemsOrProductIDsIsRequired = 'FullStockCount:EitherRecountItemsOrProductIDsIsRequired',
      /**
       * Full stock count {fullStockCountID:number} stock snapshot blob '{blobID:string}' was no longer present. Could not process the full stock count.
       */
      StockSnapshotExpired = 'FullStockCount:StockSnapshotExpired',
      /**
       * Negative quantity is forbidden
       */
      NegativeQuantityForbidden = 'FullStockCount:NegativeQuantityForbidden',
      /**
       * Cannot provide multiple serial number products in a single AddProductToFullStockCountLabel call.
       */
      CannotProvideMultipleSerialNumberProducts = 'FullStockCount:CannotProvideMultipleSerialNumberProducts',
      /**
       * Cannot mutate more than a single serial number in a single call.
       */
      CannotMutateMoreThanSingleSerialNumber = 'FullStockCount:CannotMutateMoreThanSingleSerialNumber',
      /**
       * Serial number {0:string} has already been counted as part of this full stock count.
       */
      SerialNumberAlreadyCounted = 'FullStockCount:SerialNumberAlreadyCounted',
      /**
       * Cannot count stock aggregates.
       */
      CannotCountStockAggregates = 'FullStockCount:CannotCountStockAggregates'
    }

    export const enum ConsolidatedPickTask {
      /**
       * There are no valid ship from store tasks to consolidate
       */
      NoShipFromStoreTasks = 'ConsolidatedPickTask:NoShipFromStoreTasks',
      /**
       * The provided organization unit could not be found
       */
      OrganizationUnitNotFound = 'ConsolidatedPickTask:OrganizationUnitNotFound',
      /**
       * A ConsolidatedPickTask is already in progress for OU '{0:number}' with user task ID '{1:number}'. Only one task can be active at a time.
       */
      ConsolidatedPickTaskInProgress = 'ConsolidatedPickTask:ConsolidatedPickTaskInProgress',
      /**
       * Picked quantity cannot be negative for product {0:number}.
       */
      QuantityCannotBeNegative = 'ConsolidatedPickTask:QuantityCannotBeNegative'
    }

    export const enum UserFieldRequirements {
      /**
       * Requirements for field are not met.
       */
      RequirementsNotMet = 'UserFieldRequirements:RequirementsNotMet'
    }

    export const enum Subscriptions {
      /**
       * A subscription with this name already exists
       */
      DuplicateName = 'Subscriptions:DuplicateName',
      /**
       * A subscription with this BackendID already exists
       */
      DuplicateBackendID = 'Subscriptions:DuplicateBackendID',
      /**
       * User '{0:number}' is not or no longer subscribed to subscription {1:number}
       */
      UserIsNotSubscribed = 'Subscriptions:UserIsNotSubscribed',
      /**
       * Cannot delete subscription because there are active subscriptions on it.
       */
      CannotDeleteBecauseOfActiveSubscriptions = 'Subscriptions:CannotDeleteBecauseOfActiveSubscriptions',
      /**
       * Loyalty program is required for loyalty subscription
       */
      LoyaltyProgramIsRequiredForLoyaltySubscription = 'Subscriptions:LoyaltyProgramIsRequiredForLoyaltySubscription',
      /**
       * Loyalty program is invalid
       */
      InvalidLoyaltyProgramProvidedForSubscription = 'Subscriptions:InvalidLoyaltyProgramProvidedForSubscription',
      /**
       * Can only set loyalty program when handler is loyalty handler
       */
      CanOnlySetLoyaltyProgramWhenHandlerIsLoyaltyHandler = 'Subscriptions:CanOnlySetLoyaltyProgramWhenHandlerIsLoyaltyHandler',
      /**
       * Subscription handler does not allow user identifier input
       */
      SubscriptionHandlerDoesNotAllowUserIdentifierInput = 'Subscriptions:SubscriptionHandlerDoesNotAllowUserIdentifierInput',
      /**
       * Subscription does not allow user identifier input
       */
      SubscriptionDoesNotAllowUserIdentifierInput = 'Subscriptions:SubscriptionDoesNotAllowUserIdentifierInput',
      /**
       * Loyalty handler does not allow user identifier input
       */
      LoyaltyHandlerDoesNotAllowUserIdentifierInput = 'Subscriptions:LoyaltyHandlerDoesNotAllowUserIdentifierInput',
      /**
       * Unknown loyalty program
       */
      UnknownLoyaltyProgram = 'Subscriptions:UnknownLoyaltyProgram',
      /**
       * Subscription requires either a manual user identifier or a policy to generate one
       */
      SubscriptionRequiresEitherAManualUserIdentifierOrAPolicyToGenerateOne = 'Subscriptions:SubscriptionRequiresEitherAManualUserIdentifierOrAPolicyToGenerateOne',
      /**
       * Cannot combine manual user identifier and user identifier generation
       */
      CannotCombineManualUserIdentifierAndUserIdentifierGeneration = 'Subscriptions:CannotCombineManualUserIdentifierAndUserIdentifierGeneration',
      /**
       * Start number is required for user identifier generation
       */
      StartNumberIsRequiredForUserIdentifierGeneration = 'Subscriptions:StartNumberIsRequiredForUserIdentifierGeneration',
      /**
       * The user should have an EmailAddress to subscribe to a newsletter.
       */
      EmailAddressRequired = 'Subscriptions:EmailAddressRequired',
      /**
       * Subscription handler does not allow confirmation
       */
      SubscriptionHandlerDoesNotAllowConfirmation = 'Subscriptions:SubscriptionHandlerDoesNotAllowConfirmation',
      /**
       * Subscription is already connected to organization unit set '{0:string}'.
       */
      SubscriptionAlreadyConnectedToOrganizationUnitSet = 'Subscriptions:SubscriptionAlreadyConnectedToOrganizationUnitSet',
      /**
       * {0:string} is not a supported confirmation method.
       */
      UnsupportedSubscriptionConfirmationMethod = 'Subscriptions:UnsupportedSubscriptionConfirmationMethod',
      /**
       * A loyalty program cannot be attached to multiple subscriptions
       */
      ALoyaltyProgramCannotBeAttachedToMultipleSubscriptions = 'Subscriptions:ALoyaltyProgramCannotBeAttachedToMultipleSubscriptions'
    }

    export const enum LoyaltyPrograms {
      /**
       * Handler for subscription {0:number} is unknown.
       */
      UnknownSubscriptionHandler = 'LoyaltyPrograms:UnknownSubscriptionHandler',
      /**
       * Subscription is fully external and cannot be pushed.
       */
      ExternalSubscriptionsCannotBePushed = 'LoyaltyPrograms:ExternalSubscriptionsCannotBePushed',
      /**
       * Subscription is not a loyalty subscription so it cannot accept Balance.
       */
      SubscriptionIsNotALoyaltySubscription = 'LoyaltyPrograms:SubscriptionIsNotALoyaltySubscription',
      /**
       * Unable to unsubscribe user.
       */
      UnableToUnsubscribeUser = 'LoyaltyPrograms:UnableToUnsubscribeUser',
      /**
       * Only loyalty programs with the `EVALOYALTY` handler can be provided with a balance.
       */
      OnlyEVALoyaltyHandlerAcceptsBalance = 'LoyaltyPrograms:OnlyEVALoyaltyHandlerAcceptsBalance',
      /**
       * Cannot deposit negative balance.
       */
      CannotDepositNegativeBalance = 'LoyaltyPrograms:CannotDepositNegativeBalance',
      /**
       * Handler is required
       */
      MissingHandler = 'LoyaltyPrograms:MissingHandler',
      /**
       * The given handler doesn't exist
       */
      UnknownHandler = 'LoyaltyPrograms:UnknownHandler',
      /**
       * The data is not in a valid format for the selected handler
       */
      InvalidHandlerData = 'LoyaltyPrograms:InvalidHandlerData',
      /**
       * Loyalty program is not set to 'Awarding'.
       */
      UsageTypeIsNotSetToAwarding = 'LoyaltyPrograms:UsageTypeIsNotSetToAwarding',
      /**
       * Handler does not allow deposits.
       */
      HandlerDoesNotAllowDeposits = 'LoyaltyPrograms:HandlerDoesNotAllowDeposits',
      /**
       * Handler does not allow withdrawals.
       */
      HandlerDoesNotAllowWithdrawals = 'LoyaltyPrograms:HandlerDoesNotAllowWithdrawals',
      /**
       * Point deposit failed.
       */
      PointDepositFailed = 'LoyaltyPrograms:PointDepositFailed',
      /**
       * Point withdraw failed.
       */
      PointWithdrawFailed = 'LoyaltyPrograms:PointWithdrawFailed',
      /**
       * Cannot delete loyalty program because it still has active subscriptions and the deletion isn't forced.
       */
      CannotDeleteLoyaltyProgramBecauseOfActiveSubscriptions = 'LoyaltyPrograms:CannotDeleteLoyaltyProgramBecauseOfActiveSubscriptions',
      /**
       * Cannot change budget currency.
       */
      CannotChangeBudgetCurrency = 'LoyaltyPrograms:CannotChangeBudgetCurrency',
      /**
       * Cannot have multiple price list of the same currency.
       */
      CannotHaveMultiplePriceListOfTheSameCurrency = 'LoyaltyPrograms:CannotHaveMultiplePriceListOfTheSameCurrency',
      /**
       * Can only connect a payment type once.
       */
      CanOnlyConnectAPaymentTypeOnce = 'LoyaltyPrograms:CanOnlyConnectAPaymentTypeOnce',
      /**
       * Only payment types bound to the loyalty program payment method are allowed.
       */
      OnlyPaymentTypesBoundToTheLoyaltyProgramPaymentMethodAreAllowed = 'LoyaltyPrograms:OnlyPaymentTypesBoundToTheLoyaltyProgramPaymentMethodAreAllowed',
      /**
       * Condition {0:string} already present. Can only add a condition once.
       */
      LoyaltyProgramConditionAlreadyPresent = 'LoyaltyPrograms:LoyaltyProgramConditionAlreadyPresent',
      /**
       * Condition {ConditionID:number} (type '{Name:string}') for loyalty program {ProgramID:number} was malformed or its build-up resulted in an exception.
       */
      InvalidLoyaltyProgramCondition = 'LoyaltyPrograms:InvalidLoyaltyProgramCondition',
      /**
       * Data for condition {ConditionID:number} (type '{Name:string}') for loyalty program {ProgramID:number} was not initialized.
       */
      LoyaltyProgramConditionDataNotInitialized = 'LoyaltyPrograms:LoyaltyProgramConditionDataNotInitialized',
      /**
       * Condition {conditionID:number} for loyalty point awarding rule {ruleID:number} was malformed or its build-up resulted in an exception.
       */
      InvalidPointAwardingCondition = 'LoyaltyPrograms:InvalidPointAwardingCondition',
      /**
       * No products are provided
       */
      NoProductsGiven = 'LoyaltyPrograms:NoProductsGiven',
      /**
       * Value of property `{0:string}` must be higher than or equal to 0.
       */
      ValueMustBePositive = 'LoyaltyPrograms:ValueMustBePositive',
      /**
       * Value of property {PropertyNameX:string} must be equal to or larger than property {PropertyNameY:string}
       */
      ValueOfXMustBeLargerThanOrEqualToValueOfY = 'LoyaltyPrograms:ValueOfXMustBeLargerThanOrEqualToValueOfY',
      /**
       * Value of property {PropertyNameX:string} must be larger than property {PropertyNameY:string}
       */
      ValueOfXMustBeLargerThanValueOfY = 'LoyaltyPrograms:ValueOfXMustBeLargerThanValueOfY',
      /**
       * Can only set one product condition on a rule.
       */
      CanOnlySetOnePointAwardingProductCondition = 'LoyaltyPrograms:CanOnlySetOnePointAwardingProductCondition',
      /**
       * The requested BackendID is already in use
       */
      DuplicateBackendID = 'LoyaltyPrograms:DuplicateBackendID',
      /**
       * Attached company is required to be a consumer company.
       */
      ConsumerCompanyRequired = 'LoyaltyPrograms:ConsumerCompanyRequired',
      /**
       * Either property ApplyToPriceList, ProductIDs, ProductSearchID, or Filters is required.
       */
      RequireAtLeaseOneProductLimitationProperty = 'LoyaltyPrograms:RequireAtLeaseOneProductLimitationProperty',
      /**
       * Properties ApplyToPriceList, ProductIDs, ProductSearchID, and Filters cannot be combined.
       */
      ProductLimitationPropertiesAreMutuallyExclusive = 'LoyaltyPrograms:ProductLimitationPropertiesAreMutuallyExclusive',
      /**
       * Can only create one product limitation for now.
       */
      CanOnlyCreateOneProductLimitationForNow = 'LoyaltyPrograms:CanOnlyCreateOneProductLimitationForNow',
      /**
       * Cannot create a limitless limitation when pricelists are applied.
       */
      CannotCreateALimitlessLimitationWhenPriceListsAreApplied = 'LoyaltyPrograms:CannotCreateALimitlessLimitationWhenPriceListsAreApplied',
      /**
       * Can only use cached product search templates (static or periodically refreshed).
       */
      CanOnlyUseCachedProductSearchTemplates = 'LoyaltyPrograms:CanOnlyUseCachedProductSearchTemplates',
      /**
       * `UserID` is required when providing the `UserIdentifier`.
       */
      UserIDIsRequiredWhenProvidingTheUserIdentifier = 'LoyaltyPrograms:UserIDIsRequiredWhenProvidingTheUserIdentifier',
      /**
       * Can only attach this loyalty program to an order when either the order already has a customer or the customer is provided in the request.
       */
      LoyaltyProgramRequiresCustomerToBeAttachedToTheOrder = 'LoyaltyPrograms:LoyaltyProgramRequiresCustomerToBeAttachedToTheOrder',
      /**
       * Cannot attach loyalty program to (partially) paid or completed order.
       */
      CannotAttachLoyaltyProgramToPartiallyPaidOrCompletedOrder = 'LoyaltyPrograms:CannotAttachLoyaltyProgramToPartiallyPaidOrCompletedOrder',
      /**
       * Cannot detach loyalty program from (partially) paid or completed order.
       */
      CannotDetachLoyaltyProgramFromPartiallyPaidOrCompletedOrder = 'LoyaltyPrograms:CannotDetachLoyaltyProgramFromPartiallyPaidOrCompletedOrder',
      /**
       * Can only attach this loyalty program to an order when that has a customer that is subscribed to the loyalty program.
       */
      LoyaltyProgramsRequiresSubscribedCustomerToBeAttachedToTheOrder = 'LoyaltyPrograms:LoyaltyProgramsRequiresSubscribedCustomerToBeAttachedToTheOrder',
      /**
       * Order does not meet the condition `{0:string}` of the loyalty program.
       */
      OrderDoesNotMeetConditionOfTheLoyaltyProgram = 'LoyaltyPrograms:OrderDoesNotMeetConditionOfTheLoyaltyProgram',
      /**
       * Either LoyaltyProgramID or SubscriptionID is required
       */
      EitherLoyaltyProgramIDOrSubscriptionIDIsRequired = 'LoyaltyPrograms:EitherLoyaltyProgramIDOrSubscriptionIDIsRequired',
      /**
       * LoyaltyProgram does not match given SubscriptionID
       */
      LoyaltyProgramDoesNotMatchGivenSubscriptionID = 'LoyaltyPrograms:LoyaltyProgramDoesNotMatchGivenSubscriptionID',
      /**
       * LoyaltyProgram has required payment types that need to be selected/used.
       */
      LoyaltyProgramHasRequiredPaymentTypes = 'LoyaltyPrograms:LoyaltyProgramHasRequiredPaymentTypes',
      /**
       * Cannot update the type of a loyalty program condition.
       */
      CannotUpdateConditionType = 'LoyaltyPrograms:CannotUpdateConditionType',
      /**
       * Can only require order custom fields.
       */
      CanOnlyRequireOrderCustomFields = 'LoyaltyPrograms:CanOnlyRequireOrderCustomFields',
      /**
       * Push loyalty programs limit exceeded.
       */
      PushLoyaltyProgramsLimitExceeded = 'LoyaltyPrograms:PushLoyaltyProgramsLimitExceeded',
      /**
       * Unknown error while pushing loyalty program with BackendID `{0:string}`
       */
      UnknownPushLoyaltyProgramError = 'LoyaltyPrograms:UnknownPushLoyaltyProgramError'
    }

    export const enum UserSubscriptions {
      /**
       * User identifier required.
       */
      UserIdentifierRequired = 'UserSubscriptions:UserIdentifierRequired',
      /**
       * Cannot provide user identifier when user identifier generation is enabled.
       */
      CannotProvideUserIdentifierWhenUserIdentifierGenerationIsEnabled = 'UserSubscriptions:CannotProvideUserIdentifierWhenUserIdentifierGenerationIsEnabled',
      /**
       * UserIdentifier already exists.
       */
      UserIdentifierAlreadyExists = 'UserSubscriptions:UserIdentifierAlreadyExists',
      /**
       * User already subscribed.
       */
      UserAlreadySubscribed = 'UserSubscriptions:UserAlreadySubscribed',
      /**
       * User has pending subscription awaiting confirmation
       */
      UserHasPendingSubscriptionAwaitingConfirmation = 'UserSubscriptions:UserHasPendingSubscriptionAwaitingConfirmation',
      /**
       * Cannot resubscribe to this subscription.
       */
      CannotResubscribeToThisSubscription = 'UserSubscriptions:CannotResubscribeToThisSubscription',
      /**
       * Can only resubscribe with original user identifier.
       */
      CanOnlyResubscribeWithOriginalUserIdentifier = 'UserSubscriptions:CanOnlyResubscribeWithOriginalUserIdentifier',
      /**
       * Can only resubscribe with new user identifier.
       */
      CanOnlyResubscribeWithNewUserIdentifier = 'UserSubscriptions:CanOnlyResubscribeWithNewUserIdentifier',
      /**
       * Subscription does not allow unsubscribing.
       */
      SubscriptionDoesNotAllowUnsubscribing = 'UserSubscriptions:SubscriptionDoesNotAllowUnsubscribing',
      /**
       * Unsubscribe can only be done by subscribed user.
       */
      UnsubscribeCanOnlyBeDoneBySubscribedUser = 'UserSubscriptions:UnsubscribeCanOnlyBeDoneBySubscribedUser',
      /**
       * Unsubscribe can only be done by employee or api user.
       */
      UnsubscribeCanOnlyBeDoneByEmployeeOrAPIUser = 'UserSubscriptions:UnsubscribeCanOnlyBeDoneByEmployeeOrAPIUser',
      /**
       * Unsubscribe from handler '{0:string}' failed.
       */
      UnsubscribeFromHandlerFailed = 'UserSubscriptions:UnsubscribeFromHandlerFailed',
      /**
       * Subscribe to handler '{0:string}' failed.
       */
      SubscribeToHandlerFailed = 'UserSubscriptions:SubscribeToHandlerFailed'
    }

    export const enum ExternalUserProvider {
      /**
       * Failed to execute the call to the external user provider
       */
      CallFailed = 'ExternalUserProvider:CallFailed',
      /**
       * The user could not be found in the external user provider
       */
      UnknownUser = 'ExternalUserProvider:UnknownUser'
    }

    export const enum UserCards {
      /**
       * UserCards with Type Discount can only be created internally by the Discount engine.
       */
      DiscountTypeNotAllowed = 'UserCards:DiscountTypeNotAllowed',
      /**
       * UserCards with Type Loyalty can only be managed internally.
       */
      LoyaltyTypeNotAllowed = 'UserCards:LoyaltyTypeNotAllowed',
      /**
       * UserCards with Type Loyalty can only be mutated internally.
       */
      LoyaltyTypeMutationsNotAllowed = 'UserCards:LoyaltyTypeMutationsNotAllowed',
      /**
       * CurrencyID is required when creating Currency UserCards.
       */
      CurrencyRequired = 'UserCards:CurrencyRequired',
      /**
       * UserCards with Type Discount can't create paymenttransactions.
       */
      DiscountTypePayment = 'UserCards:DiscountTypePayment'
    }

    export const enum UserBoughtProduct {
      /**
       * Product is already registered.
       */
      AlreadyRegistered = 'UserBoughtProduct:AlreadyRegistered',
      /**
       * Unknown user bought product.
       */
      UnknownUserBoughtProduct = 'UserBoughtProduct:UnknownUserBoughtProduct',
      /**
       * Unknown user bought product detail.
       */
      UnknownUserBoughtProductDetail = 'UserBoughtProduct:UnknownUserBoughtProductDetail',
      /**
       * The given OrderID/OrderLineID is an invalid combination.
       */
      InvalidOrderAndLineCombination = 'UserBoughtProduct:InvalidOrderAndLineCombination',
      /**
       * User limit of {0:number} exceeded.
       */
      PushBoughtProductForUsersLimitExceeded = 'UserBoughtProduct:PushBoughtProductForUsersLimitExceeded'
    }

    export const enum UserBorrowedProducts {
      /**
       * User cannot register borrowed products on it's own account.
       */
      UserCannotBorrowProductsForHimSelf = 'UserBorrowedProducts:UserCannotBorrowProductsForHimSelf',
      /**
       * User cannot return register borrowed products from it's own account.
       */
      UserCannotReturnBorrowedProductsForHimSelf = 'UserBorrowedProducts:UserCannotReturnBorrowedProductsForHimSelf',
      /**
       * User cannot return purchase borrowed products from it's own account.
       */
      UserCannotPurchaseBorrowedProductsForHimSelf = 'UserBorrowedProducts:UserCannotPurchaseBorrowedProductsForHimSelf',
      /**
       * User doesn't have this product registerd as borrowed.
       */
      UserDoesNotHaveThisProductRegisterdAsBorrowed = 'UserBorrowedProducts:UserDoesNotHaveThisProductRegisterdAsBorrowed',
      /**
       * Cannot purchase more products then that are still borrowed
       */
      CannotReturnMoreProductsThenBorrowed = 'UserBorrowedProducts:CannotReturnMoreProductsThenBorrowed',
      /**
       * Cannot purchase more products then that are still borrowed
       */
      CannotPurchaseMoreProductsThenBorrowed = 'UserBorrowedProducts:CannotPurchaseMoreProductsThenBorrowed',
      /**
       * Cannot purchase borrowed products for multiple users on the same order.
       */
      CannotPurchaseBorrowedItemsForMultipleUsersOnTheSameOrder = 'UserBorrowedProducts:CannotPurchaseBorrowedItemsForMultipleUsersOnTheSameOrder',
      /**
       * Cannot register borrowed products that require a serial number on stock movement.
       */
      CannotBorrowProductRequiringSerialNumberWithStockMovement = 'UserBorrowedProducts:CannotBorrowProductRequiringSerialNumberWithStockMovement'
    }

    export const enum TaxCodeMapping {
      /**
       * An entry for the given tax code and tax provider already exists.
       */
      InvalidMapping = 'TaxCodeMapping:InvalidMapping'
    }

    export const enum TaxProvider {
      /**
       * The configuration data is invalid. 
       * {0:string}
       */
      InvalidConfigurationData = 'TaxProvider:InvalidConfigurationData',
      /**
       * The provided Type is invalid.
       */
      InvalidType = 'TaxProvider:InvalidType',
      /**
       * Name already exists.
       */
      InvalidName = 'TaxProvider:InvalidName',
      /**
       * No tax provider configuration exists for {0:number}.
       */
      NoConfiguration = 'TaxProvider:NoConfiguration',
      /**
       * Name and Type cannot be null.
       */
      InvalidRequiredFields = 'TaxProvider:InvalidRequiredFields'
    }

    export const enum GenerateCouponSurveyAfterEffect {
      /**
       * The value of property {0:string} is missing
       */
      MissingValue = 'GenerateCouponSurveyAfterEffect:MissingValue',
      /**
       * The discount is invalid. It should be a valid coupon triggered discount.
       */
      InvalidDiscount = 'GenerateCouponSurveyAfterEffect:InvalidDiscount'
    }

    export const enum ShippingMethod {
      /**
       * Either Code or Handler should have a value.
       */
      CodeOrHandlerShouldBeSet = 'ShippingMethod:CodeOrHandlerShouldBeSet',
      /**
       * An invalid handler has been provided.
       */
      InvalidShippingMethodHandler = 'ShippingMethod:InvalidShippingMethodHandler'
    }

    export const enum ModifyQuantityShipped {
      /**
       * Order {0:number} is not a PurchaseOrder
       */
      NoPurchaseOrder = 'ModifyQuantityShipped:NoPurchaseOrder',
      /**
       * Shipment {0:number} is already completed
       */
      ShipmentIsCompleted = 'ModifyQuantityShipped:ShipmentIsCompleted',
      /**
       * Shipment {0:number} is already exported
       */
      ShipmentIsExported = 'ModifyQuantityShipped:ShipmentIsExported',
      /**
       * ShipmentLine {0:number} is already completed
       */
      ShipmentLineIsCompleted = 'ModifyQuantityShipped:ShipmentLineIsCompleted',
      /**
       * ShipmentLine {0:number} is already fully delivered
       */
      ShipmentLineIsFullyDelivered = 'ModifyQuantityShipped:ShipmentLineIsFullyDelivered',
      /**
       * OrderLine {OrderLineID:number} of ShipmentLine {ShipmentLineID:number} is already invoiced
       */
      OrderLineIsInvoiced = 'ModifyQuantityShipped:OrderLineIsInvoiced',
      /**
       * ShipmentLine {0:number} has already more Delivered
       */
      ShipmentLineHasMoreDeliveredThanRequested = 'ModifyQuantityShipped:ShipmentLineHasMoreDeliveredThanRequested'
    }

    export const enum SerialNumbers {
      /**
       * Serial number is required
       */
      SerialNumberRequired = 'SerialNumbers:SerialNumberRequired',
      /**
       * Product is required when setting a serial number
       */
      ProductRequired = 'SerialNumbers:ProductRequired',
      /**
       * Quantity does not match serial number count
       */
      InvalidQuantity = 'SerialNumbers:InvalidQuantity',
      /**
       * Serial number {0:string} is invalid
       */
      SerialNumberInvalid = 'SerialNumbers:SerialNumberInvalid',
      /**
       * The usage of serial number {0:string} is denied.
       */
      SerialNumberUsageDenied = 'SerialNumbers:SerialNumberUsageDenied',
      /**
       * Duplicate serial number {0:string}
       */
      DuplicateSerialNumber = 'SerialNumbers:DuplicateSerialNumber',
      /**
       * Serial number {0:string} cannot be received because it was never shipped.
       */
      SerialNumberNotShipped = 'SerialNumbers:SerialNumberNotShipped',
      /**
       * Serial Number Configuration cannot be deleted because it is still used by existing Serial Number Products.
       */
      CannotDeleteUsedConfiguration = 'SerialNumbers:CannotDeleteUsedConfiguration',
      /**
       * It is not possible to sell to the stock location of serial number {0:string}.
       */
      StockLabelMismatch = 'SerialNumbers:StockLabelMismatch',
      /**
       * The serial number {0:string} is owned by a different organization unit.
       */
      InvalidOrganizationUnit = 'SerialNumbers:InvalidOrganizationUnit',
      /**
       * The serial number {0:string} is owned by customer.
       */
      OwnedByCustomer = 'SerialNumbers:OwnedByCustomer',
      /**
       * The serial number {0:string} belongs to a different product.
       */
      DifferentProduct = 'SerialNumbers:DifferentProduct',
      /**
       * Request contains duplicate serial numbers
       */
      SerialNumberDuplicates = 'SerialNumbers:SerialNumberDuplicates',
      /**
       * The provided Serial Number does not match with the existing one.
       */
      SerialNumberDoesNotMatch = 'SerialNumbers:SerialNumberDoesNotMatch'
    }

    export const enum Sellability {
      /**
       * Product {0:number} is not sellable.
       */
      ProductNotSellable = 'Sellability:ProductNotSellable'
    }

    export const enum ElevationManager {
      /**
       * You have insufficient rights to request this elevation.
       */
      InsufficientRightsToRequestElevation = 'ElevationManager:InsufficientRightsToRequestElevation',
      /**
       * Elevation type not supported.
       */
      ElevationTypeNotSupported = 'ElevationManager:ElevationTypeNotSupported'
    }

    export const enum SecurityPolicy {
      /**
       * New password is required.
       */
      NewPasswordIsRequired = 'SecurityPolicy:NewPasswordIsRequired',
      /**
       * User or password is not valid.
       */
      UserOrPasswordInvalid = 'SecurityPolicy:UserOrPasswordInvalid',
      /**
       * Password is too short - it must be at least 8 characters.
       */
      TooShort = 'SecurityPolicy:TooShort',
      /**
       * Password authentication is disabled for this user.
       */
      PasswordAuthenticationDisabled = 'SecurityPolicy:PasswordAuthenticationDisabled',
      /**
       * Password is too long - 1024 seems like a decent enough length for a strong password, no?
       */
      TooLong = 'SecurityPolicy:TooLong',
      /**
       * This password has been found in one or more breaches and should not be used (see https://haveibeenpwned.com/Passwords).
       */
      Pwned = 'SecurityPolicy:Pwned',
      /**
       * Password safety check could not be performed.
       */
      PwnedUnavailable = 'SecurityPolicy:PwnedUnavailable'
    }

    export const enum Url {
      /**
       * Url is empty.
       */
      UrlEmpty = 'Url:UrlEmpty',
      /**
       * Url is not valid.
       */
      UrlInvalid = 'Url:UrlInvalid',
      /**
       * Url does not match expectation.
       */
      UrlDoesNotMatch = 'Url:UrlDoesNotMatch'
    }

    export const enum Passkey {
      /**
       * Passkeys are disabled
       */
      PasskeysDisabled = 'Passkey:PasskeysDisabled',
      /**
       * Invalid challenge
       */
      InvalidChallenge = 'Passkey:InvalidChallenge',
      /**
       * Invalid client data
       */
      InvalidClientData = 'Passkey:InvalidClientData',
      /**
       * Invalid authenticator data
       */
      InvalidAuthenticatorData = 'Passkey:InvalidAuthenticatorData',
      /**
       * Invalid user
       */
      InvalidUser = 'Passkey:InvalidUser',
      /**
       * Invalid signature
       */
      InvalidSignature = 'Passkey:InvalidSignature',
      /**
       * Invalid key
       */
      InvalidKey = 'Passkey:InvalidKey'
    }

    export const enum MagicLink {
      /**
       * Magic links are disabled by your administrator.
       */
      Disabled = 'MagicLink:Disabled',
      /**
       * The redirect URL was not configured as supported domain.
       */
      NotConfiguredDomain = 'MagicLink:NotConfiguredDomain',
      /**
       * The provided combination of Email Address and OrderID yielded no results.
       */
      EmailOrderMismatch = 'MagicLink:EmailOrderMismatch',
      /**
       * Manual codes through magic links are disabled by your administrator.
       */
      ManualCodeDisabled = 'MagicLink:ManualCodeDisabled'
    }

    export const enum SchedulingConfig {
      /**
       * Invalid scheduling config
       */
      InvalidConfig = 'SchedulingConfig:InvalidConfig'
    }

    export const enum ReceiveShipment {
      /**
       * Shipment {0:number} cannot be found.
       */
      ShipmentNotFound = 'ReceiveShipment:ShipmentNotFound',
      /**
       * Shipment {0:number} has already been completed, can no longer receive it.
       */
      ShipmentCompleted = 'ReceiveShipment:ShipmentCompleted',
      /**
       * Shipment {0:number} is still pending, delete the shipment instead of cancelling it..
       */
      ShipmentPending = 'ReceiveShipment:ShipmentPending',
      /**
       * Shipment {0:number} has already been (partly) received, can no longer cancel it.
       */
      ShipmentReceived = 'ReceiveShipment:ShipmentReceived',
      /**
       * Cannot receive product {0:number} without reference because it is already in the shipment
       */
      CannotReceiveProductWithoutReference = 'ReceiveShipment:CannotReceiveProductWithoutReference'
    }

    export const enum ProductSubscriptions {
      /**
       * Manual is only allowed for test purposes
       */
      InvalidInterval = 'ProductSubscriptions:InvalidInterval',
      /**
       * Cannot create a ProductSubscription for Product {0:number} because it's not a SubscriptionProduct
       */
      SubscriptionProductRequired = 'ProductSubscriptions:SubscriptionProductRequired',
      /**
       * Subscription can't be renewed
       */
      SubscriptionCantBeRenewed = 'ProductSubscriptions:SubscriptionCantBeRenewed',
      /**
       * Cannot create a ProductSubscription for Product {0:number}, it already has a ProductSubscription
       */
      SubscriptionProductAlreadyExists = 'ProductSubscriptions:SubscriptionProductAlreadyExists',
      /**
       * Cannot find a suitable PaymentMethod for this subscription.
       */
      PaymentMethodNotFound = 'ProductSubscriptions:PaymentMethodNotFound',
      /**
       * No valid recurring payment has been done on this order, can't activate the subscription.
       */
      SubscriptionNeedsTokenizedPayment = 'ProductSubscriptions:SubscriptionNeedsTokenizedPayment'
    }

    export const enum StockAggregate {
      /**
       * Product {0:number} is not a valid replacement for product {1:number}
       */
      InvalidReplacement = 'StockAggregate:InvalidReplacement',
      /**
       * Invalid serialnumber {0:string} for product {1:number}
       */
      InvalidSerialNumber = 'StockAggregate:InvalidSerialNumber'
    }

    export const enum StockAggregateProducts {
      /**
       * No stock product for stock aggregate product ID {0:number} in assortment {1:number} for organization unit ID {2:number}
       */
      NoStockProductForStockAggregateProduct = 'StockAggregateProducts:NoStockProductForStockAggregateProduct'
    }

    export const enum SetStockProduct {
      /**
       * The StockProduct of OrderLine {0:number} can no longer be changed as it has been cancelled or shipped.
       */
      OrderLineCompleted = 'SetStockProduct:OrderLineCompleted',
      /**
       * The StockProduct of OrderLine {0:number} cannot be changed as Product {1:number} is not a StockAggregate product.
       */
      MustBeStockAggregateProduct = 'SetStockProduct:MustBeStockAggregateProduct',
      /**
       * The StockProduct {0:number} is not a valid StockProduct for Product {1:number}.
       */
      InvalidStockProduct = 'SetStockProduct:InvalidStockProduct'
    }

    export const enum ProductRequirements {
      /**
       * The given productrequirement doesn't match the product on this orderline.
       */
      InvalidProductRequirement = 'ProductRequirements:InvalidProductRequirement',
      /**
       * ProductRequirement '{0:string}' is an array, but the given value is not.
       */
      IsArray = 'ProductRequirements:IsArray',
      /**
       * ProductRequirement '{ProductRequirementName:string}' is an {ValueType:string}, but the given value is not.
       */
      InvalidType = 'ProductRequirements:InvalidType',
      /**
       * ProductRequirement '{0:string}' is an enum, but the given value is not a valid enum value.
       */
      InvalidArrayValue = 'ProductRequirements:InvalidArrayValue',
      /**
       * ProductRequirement '{0:string}' is required.
       */
      IsRequired = 'ProductRequirements:IsRequired'
    }

    export const enum ProductBundles {
      /**
       * Cannot create a ProductBundle for Product {0:number} because it's not a BundleProduct
       */
      BundleProductRequired = 'ProductBundles:BundleProductRequired',
      /**
       * A ProductBundleLine requires at least one ProductBundleLineOption.
       */
      OptionsRequired = 'ProductBundles:OptionsRequired',
      /**
       * Creating a ProductBundleLine when there are multiple Options requires selecting a DefaultProductID.
       */
      DefaultProductRequired = 'ProductBundles:DefaultProductRequired',
      /**
       * Product {0:number} cannot be found.
       */
      UnknownProduct = 'ProductBundles:UnknownProduct',
      /**
       * Creating a ProductBundleLine where one of the options is a Configurable product requires a DefaultProductID.
       */
      DefaultProductRequiredForConfigurable = 'ProductBundles:DefaultProductRequiredForConfigurable',
      /**
       * Product {0:number} is not one of the options nor part of the hierarchy of the options.
       */
      InvalidDefaultProduct = 'ProductBundles:InvalidDefaultProduct',
      /**
       * When creating/updating a ProductBundle a ProductBundleID or a BundleProductID is required
       */
      ProductBundleIDOrBundleProductIDRequired = 'ProductBundles:ProductBundleIDOrBundleProductIDRequired',
      /**
       * Product {0:number} can not be used as default product for bundle line {1:string} because it can be excluded by an option on bundle line {2:string}.
       */
      DefaultProductCouldBeExcluded = 'ProductBundles:DefaultProductCouldBeExcluded',
      /**
       * The ProductBundleLine contains the same product ({0:number}) multiple times.
       */
      DuplicateOption = 'ProductBundles:DuplicateOption',
      /**
       * Only ProductBundleLines of type Optional allow selecting multiple options.
       */
      MultiSelectOnlyPossibleOnOptionalLines = 'ProductBundles:MultiSelectOnlyPossibleOnOptionalLines',
      /**
       * An option refers to the same product as the root bundle product, causing an infinite recursion!
       */
      InfiniteRecursion = 'ProductBundles:InfiniteRecursion',
      /**
       * ProductBundleLine {0:number} cannot be found on this bundle.
       */
      UnknownProductBundleLine = 'ProductBundles:UnknownProductBundleLine',
      /**
       * Product {selectedProductID:number} is not a valid option for ProductBundleLineID {productBundleLineID:number}
       */
      InvalidProductSelection = 'ProductBundles:InvalidProductSelection',
      /**
       * It's no longer possible to switch products for ProductBundleLineID {productBundleLineID:number} on Order {orderID:number}
       */
      CannotChangeProductID = 'ProductBundles:CannotChangeProductID',
      /**
       * The selection contains multiple lines for ProductBundleLineID {0:number}
       */
      DuplicateProductBundleLines = 'ProductBundles:DuplicateProductBundleLines',
      /**
       * The selection contains {SelectedCount:number} for ProductBundleLineID {ProductBundleLineID:number}, while only a maximum of {MaximumCount:number} is allowed.
       */
      MoreOptionsSelectedThanAllowed = 'ProductBundles:MoreOptionsSelectedThanAllowed',
      /**
       * Selected product {selectedProductID:number} on ProductBundleLine {productBundleLineID:number} is excluded by the selected option on ProductBundleLine {excludingProductBundleLineID:number}
       */
      ProductIsExcludedByOtherProductBundleLine = 'ProductBundles:ProductIsExcludedByOtherProductBundleLine'
    }

    export const enum PriceCalculation {
      /**
       * PriceList {0:number} references itself.
       */
      PriceListReferencesItself = 'PriceCalculation:PriceListReferencesItself',
      /**
       * PriceList {priceListID:number} depends on deleted pricelist {adjustmentPriceListID:number}.
       */
      PriceListDependsOnDeletedPriceList = 'PriceCalculation:PriceListDependsOnDeletedPriceList',
      /**
       * PriceList {priceListID:number} has a component {adjustmentPriceListID:number} that does not have the required data object.
       */
      MissingData = 'PriceCalculation:MissingData'
    }

    export const enum PriceLists {
      /**
       * Currency mismatch: OrganizationUnitID {organizationUnitID:number} uses CurrencyID {ouCurrency:string} but PriceList {priceListID:number} uses CurrencyID {priceListCurrency:string}
       */
      CurrencyMismatch = 'PriceLists:CurrencyMismatch',
      /**
       * OrganizationUnit {organizationUnit:string} already uses pricelist {priceListName:string} for {usageType:string}, remove it first before attaching a new pricelist.
       */
      PriceListAlreadyAttachedToOrganizationUnit = 'PriceLists:PriceListAlreadyAttachedToOrganizationUnit',
      /**
       * You are not allowed to attach a pricelist of type {UsageType:string} to organization unit {OrganizationUnitName:string}.
       */
      NotAllowed = 'PriceLists:NotAllowed',
      /**
       * The adjustment or provided data for the adjustment is invalid.
       */
      InvalidAdjustment = 'PriceLists:InvalidAdjustment',
      /**
       * Cannot modify or delete second chance product adjustment.
       */
      CannotModifyOrDeleteSecondChanceProductAdjustment = 'PriceLists:CannotModifyOrDeleteSecondChanceProductAdjustment',
      /**
       * Historical pricelists are protected and cannot be modified.
       */
      HistoricalPricesAreProtectedAndCannotBeModified = 'PriceLists:HistoricalPricesAreProtectedAndCannotBeModified'
    }

    export const enum PaymentRequiredDataValidation {
      /**
       * Order {orderID:number} can't be paid, because it has validation errors: {errors:string}
       */
      OrderRequiredDataValidationFailed = 'PaymentRequiredDataValidation:OrderRequiredDataValidationFailed'
    }

    export const enum OpenAmountValidation {
      /**
       * This order has already been paid for.
       */
      OrderAlreadyFullyPaid = 'OpenAmountValidation:OrderAlreadyFullyPaid'
    }

    export const enum RefundAmountValidation {
      /**
       * This order has only {openAmount:number} available for refund and {givenAmount:number} was requested.
       */
      AmountNotAvailableForRefund = 'RefundAmountValidation:AmountNotAvailableForRefund'
    }

    export const enum CreatePayment {
      /**
       * Could not calculate sales tax for this order.
       */
      TaxCalculationFailed = 'CreatePayment:TaxCalculationFailed',
      /**
       * MultiCurrency is not available for this payment method.
       */
      MultiCurrencyNotAvailable = 'CreatePayment:MultiCurrencyNotAvailable',
      /**
       * MultiCurrency is not available for this payment type.
       */
      MultiCurrencyNotAvailableForPaymentType = 'CreatePayment:MultiCurrencyNotAvailableForPaymentType',
      /**
       * MultiCurrency is not available for refunds.
       */
      MultiCurrencyNotAvailableForRefunds = 'CreatePayment:MultiCurrencyNotAvailableForRefunds',
      /**
       * There is no PaymentMethod available for the requested PaymentType {paymentTypeOrCode:string}, available methods are: {availableMethods:string}
       */
      NoPaymentMethodAvailable = 'CreatePayment:NoPaymentMethodAvailable'
    }

    export const enum Payments {
      /**
       * PaymentTransaction {0:number} can no longer be cancelled.
       */
      CancellationNotAvailable = 'Payments:CancellationNotAvailable',
      /**
       * Failed to cancel PaymentTransaction {0:number}.
       */
      CancellationFailed = 'Payments:CancellationFailed',
      /**
       * Auto shipment after confirm is only allowed in the context of a store.
       */
      AutoShipOnlyAllowedInShops = 'Payments:AutoShipOnlyAllowedInShops',
      /**
       * The current order is not valid for auto shipment after confirm.
       */
      InvalidOrderForAutoShip = 'Payments:InvalidOrderForAutoShip',
      /**
       * The current order needs a payment with Tokenization support first.
       */
      NeedsTokenization = 'Payments:NeedsTokenization',
      /**
       * Payments with amount zero are only allowed for Tokenized payments.
       */
      ZeroPaymentNotAllowed = 'Payments:ZeroPaymentNotAllowed',
      /**
       * Refunds should be created with the CreateRefund service.
       */
      InvalidAmount = 'Payments:InvalidAmount'
    }

    export const enum PaymentMethods {
      /**
       * No internet connection available and payment method not usable offline
       */
      NotUsableOffline = 'PaymentMethods:NotUsableOffline',
      /**
       * EVA is running on watchtower and this payment method is not supported
       */
      PaymentMethodNotUsableOnWatchtower = 'PaymentMethods:PaymentMethodNotUsableOnWatchtower',
      /**
       * EVA is running normally and this payment method is only supported in ops/offline
       */
      PaymentMethodNotUsableInCloud = 'PaymentMethods:PaymentMethodNotUsableInCloud'
    }

    export const enum Settlements {
      /**
       * The summed amount of the settlements ({summedAmount:number}) doesn't match the totalamount ({totalAmount:number}).
       */
      AmountMismatch = 'Settlements:AmountMismatch',
      /**
       * No financialperiod for settlement.
       */
      NoFinancialPeriod = 'Settlements:NoFinancialPeriod'
    }

    export const enum PaymentDispute {
      /**
       * PaymentTransaction {0:number} was already resolved.
       */
      AlreadyResolved = 'PaymentDispute:AlreadyResolved',
      /**
       * PaymentTransaction {0:number} has no dipute.
       */
      NoDispute = 'PaymentDispute:NoDispute',
      /**
       * PaymentTransaction {0:number} has no order attached.
       */
      NoOrderAttached = 'PaymentDispute:NoOrderAttached'
    }

    export const enum CustomPaymentMethod {
      /**
       * This payment needs to be confirmed
       */
      ConfirmationRequired = 'CustomPaymentMethod:ConfirmationRequired',
      /**
       * Over payments are blocked on this payment method
       */
      BlockedOverPayments = 'CustomPaymentMethod:BlockedOverPayments',
      /**
       * Currency not available for the current organization unit.
       */
      CurrencyNotAvailable = 'CustomPaymentMethod:CurrencyNotAvailable',
      /**
       * Exchange rate is required.
       */
      ExchangeRateRequired = 'CustomPaymentMethod:ExchangeRateRequired'
    }

    export const enum OrganizationUnitSets {
      /**
       * An OrganizationUnit can only be part of a single set within the scope {scope:string}, but it appears in multiple sets: {setNames:string}
       */
      OrganizationUnitNotUniqueInScope = 'OrganizationUnitSets:OrganizationUnitNotUniqueInScope',
      /**
       * OrganizationUnitSet {set:string} has scope {scope:string}, cannot add subset {subSet:string} with scope {subScope:string}
       */
      SubsetCannotHaveDifferentScope = 'OrganizationUnitSets:SubsetCannotHaveDifferentScope',
      /**
       * OrganizationUnitSet {set:string} does not have a scope, cannot add subset {subset:string} with scope {subScope:string} to it.
       */
      SetWithoutScopeCannotHaveSubsetWithScope = 'OrganizationUnitSets:SetWithoutScopeCannotHaveSubsetWithScope',
      /**
       * OrganizationUnitSet {set:string} has a Scope {scope:string} with OrganizationUnitUniqueInScope = true, which means it cannot contain dynamic sets.
       */
      ScopeCannotContainDynamicSet = 'OrganizationUnitSets:ScopeCannotContainDynamicSet',
      /**
       * OrganizationUnitSet {setID:number} is its own subset. Reference chain: {recursionChain:string}
       */
      CircularReferenceInSet = 'OrganizationUnitSets:CircularReferenceInSet',
      /**
       * All subsets are required for reordering.
       */
      AllSubsetsAreRequiredForReordering = 'OrganizationUnitSets:AllSubsetsAreRequiredForReordering',
      /**
       * Duplicate subsets are not allowed when setting sequences.
       */
      DuplicateSubsetsNotAllowedWhenSequencing = 'OrganizationUnitSets:DuplicateSubsetsNotAllowedWhenSequencing'
    }

    export const enum OrganizationUnit {
      /**
       * ParentID is required.
       */
      MissingParentID = 'OrganizationUnit:MissingParentID',
      /**
       * Name is required.
       */
      MissingName = 'OrganizationUnit:MissingName',
      /**
       * EmailAddress is invalid.
       */
      InvalidEmailAddress = 'OrganizationUnit:InvalidEmailAddress',
      /**
       * Subnet is invalid.
       */
      InvalidSubnet = 'OrganizationUnit:InvalidSubnet',
      /**
       * IpAddress is invalid.
       */
      InvalidIpAddress = 'OrganizationUnit:InvalidIpAddress',
      /**
       * Cannot enable endless stock on non supplier organizationUnit.
       */
      CannotEnableEndlessStockOnNonSupplierOrganizationUnit = 'OrganizationUnit:CannotEnableEndlessStockOnNonSupplierOrganizationUnit',
      /**
       * Cannot remove the VisibilityGroup from an organizationUnit.
       */
      CannotRemoveVisibilityGroup = 'OrganizationUnit:CannotRemoveVisibilityGroup',
      /**
       * Cannot update organization unit while it is archived.
       */
      CannotUpdateWhileArchived = 'OrganizationUnit:CannotUpdateWhileArchived',
      /**
       * Container cannot also be shop.
       */
      ContainerCannotAlsoBeShop = 'OrganizationUnit:ContainerCannotAlsoBeShop',
      /**
       * Cash handler currency must be equal to organizationUnit currency.
       */
      InvalidCashHandler = 'OrganizationUnit:InvalidCashHandler',
      /**
       * BackendID {0:string} is already in use.
       */
      DuplicateBackendID = 'OrganizationUnit:DuplicateBackendID',
      /**
       * Cannot delete root organization unit.
       */
      CannotDeleteRootOrganizationUnit = 'OrganizationUnit:CannotDeleteRootOrganizationUnit',
      /**
       * Cannot delete organization unit with children. Please delete the children first.
       */
      CannotDeleteOrganizationUnitWithChildren = 'OrganizationUnit:CannotDeleteOrganizationUnitWithChildren',
      /**
       * Cannot delete organization unit with archived children. Please delete the children first.
       */
      CannotDeleteOrganizationUnitWithArchivedChildren = 'OrganizationUnit:CannotDeleteOrganizationUnitWithArchivedChildren',
      /**
       * Cannot archive organization unit with children. Please archive the children first.
       */
      CannotArchiveOrganizationUnitWithChildren = 'OrganizationUnit:CannotArchiveOrganizationUnitWithChildren',
      /**
       * Cannot unarchive organization unit with archived parent. Please unarchive the parent first.
       */
      CannotUnArchiveOrganizationUnitWithArchivedParent = 'OrganizationUnit:CannotUnArchiveOrganizationUnitWithArchivedParent',
      /**
       * It's not possible to change the CostPriceCurrencyMethod to FIFO for OrganizationUnit {0:string} when it has existing stock. Remove the stock first and re-create it by receiving a Purchase Order
       */
      CannotChangeToFifoWithExistingStock = 'OrganizationUnit:CannotChangeToFifoWithExistingStock'
    }

    export const enum LoyaltyAPI {
      /**
       * The configuration for this LoyaltyAPI is incomplete.
       */
      ConfigurationIncomplete = 'LoyaltyAPI:ConfigurationIncomplete',
      /**
       * Could not validate the payment. Service returned the following error: {0:string}.
       */
      CouldNotValidatePayment = 'LoyaltyAPI:CouldNotValidatePayment'
    }

    export const enum EVALoyalty {
      /**
       * User is not (or no longer) subscribed.
       */
      UserIsNotOrNoLongerSubscribed = 'EVALoyalty:UserIsNotOrNoLongerSubscribed',
      /**
       * Withdrawal not allowed.
       */
      WithdrawalNotAllowed = 'EVALoyalty:WithdrawalNotAllowed',
      /**
       * Refund not allowed.
       */
      RefundNotAllowed = 'EVALoyalty:RefundNotAllowed',
      /**
       * Invalid deposit transaction id.
       */
      InvalidDepositTransactionID = 'EVALoyalty:InvalidDepositTransactionID',
      /**
       * Unknown deposit transaction id.
       */
      UnknownDepositTransactionID = 'EVALoyalty:UnknownDepositTransactionID',
      /**
       * Cannot revoke more than deposited.
       */
      CannotRevokeMoreThanDeposited = 'EVALoyalty:CannotRevokeMoreThanDeposited',
      /**
       * Cannot withdraw more than available.
       */
      CannotWithdrawMoreThanAvailable = 'EVALoyalty:CannotWithdrawMoreThanAvailable',
      /**
       * Cannot refund more than there is left to refund.
       */
      CannotRefundMoreThanThereIsLeftToRefund = 'EVALoyalty:CannotRefundMoreThanThereIsLeftToRefund',
      /**
       * Original transaction does not exist.
       */
      OriginalTransactionDoesNotExist = 'EVALoyalty:OriginalTransactionDoesNotExist',
      /**
       * Can only refund on a withdraw transaction.
       */
      CanOnlyRefundOnAWithdrawTransaction = 'EVALoyalty:CanOnlyRefundOnAWithdrawTransaction',
      /**
       * Can only revoke on a deposit transaction.
       */
      CanOnlyRevokeOnADepositTransaction = 'EVALoyalty:CanOnlyRevokeOnADepositTransaction',
      /**
       * The LoyaltyPointAdjustmentType provided is not supported for LoyaltyPoint rebalances.
       */
      UnsupportedLoyaltyPointAdjustmentType = 'EVALoyalty:UnsupportedLoyaltyPointAdjustmentType',
      /**
       * Too many mutations requested, the limit of this service is 10.000 mutations per request.
       */
      TooManyMutationsRequested = 'EVALoyalty:TooManyMutationsRequested',
      /**
       * Only the EVALOYALTY can be used for this service.
       */
      UnsupportedHandlerForService = 'EVALoyalty:UnsupportedHandlerForService',
      /**
       * Unknown error while mutating the user's loyalty point balance.
       */
      UnknownLoyaltyPointBalanceError = 'EVALoyalty:UnknownLoyaltyPointBalanceError'
    }

    export const enum PointPolicy {
      /**
       * The point policy `{0:string}` is unknown.
       */
      UnknownPointPolicy = 'PointPolicy:UnknownPointPolicy',
      /**
       * Could not calculate the data because the data isn't initialized.
       */
      DataNotInitialized = 'PointPolicy:DataNotInitialized',
      /**
       * {PolicyName:string} data for the {Type:PointPolicyType} policy in {parentType:string} {parentID:number} is required.
       */
      MissingPolicyData = 'PointPolicy:MissingPolicyData',
      /**
       * {PolicyName:string} data for the {Type:PointPolicyType} policy in {parentType:string} {parentID:number} is invalid.
       */
      InvalidPolicyData = 'PointPolicy:InvalidPolicyData'
    }

    export const enum CustomPointPolicy {
      /**
       * The custom policy time interval `{0:string}` is not implemented.
       */
      NotImplementedCustomPolicyTimeInterval = 'CustomPointPolicy:NotImplementedCustomPolicyTimeInterval',
      /**
       * Interval value must be higher then zero.
       */
      IntervalValueMustBeHigherThanZero = 'CustomPointPolicy:IntervalValueMustBeHigherThanZero'
    }

    export const enum ExpireEndOfYearPointPolicy {
      /**
       * LeniencyDays cannot be negative.
       */
      LeniencyDaysCannotBeNegative = 'ExpireEndOfYearPointPolicy:LeniencyDaysCannotBeNegative'
    }

    export const enum ExpireEndOfMonthPointPolicy {
      /**
       * LeniencyDays cannot be negative.
       */
      LeniencyDaysCannotBeNegative = 'ExpireEndOfMonthPointPolicy:LeniencyDaysCannotBeNegative'
    }

    export const enum ExpireSetDatePointPolicy {
      /**
       * Invalid month value.
       */
      InvalidMonthValue = 'ExpireSetDatePointPolicy:InvalidMonthValue',
      /**
       * Invalid day value.
       */
      InvalidDayValue = 'ExpireSetDatePointPolicy:InvalidDayValue',
      /**
       * LeniencyDays cannot be negative.
       */
      LeniencyDaysCannotBeNegative = 'ExpireSetDatePointPolicy:LeniencyDaysCannotBeNegative'
    }

    export const enum EvaClient {
      /**
       * Failed to call service {serviceName:string}: {error:string}
       */
      CallFailed = 'EvaClient:CallFailed'
    }

    export const enum LiveGuard {
      /**
       * No TOTP token generated for this store.
       */
      NoTOTPTokenGenerated = 'LiveGuard:NoTOTPTokenGenerated'
    }

    export const enum Invoices {
      /**
       * Missing billing details for invoice {0:string}
       */
      MissingBillingDetailsForInvoice = 'Invoices:MissingBillingDetailsForInvoice',
      /**
       * Invoice {0:number} is not open for modification
       */
      CannotBeModified = 'Invoices:CannotBeModified',
      /**
       * Could not calculate sales tax for order {0:number}.
       */
      TaxCalculationFailed = 'Invoices:TaxCalculationFailed',
      /**
       * Dispute {0:number} is not open for modification
       */
      DisputeCannotBeModified = 'Invoices:DisputeCannotBeModified',
      /**
       * Invoice {0:number} is already closed
       */
      AlreadyClosed = 'Invoices:AlreadyClosed',
      /**
       * Invoice {invoiceID:number} has an original amount of {originalTotalAmount:number}, but the total amount is {totalAmount:number}.
       */
      TotalAmountMismatch = 'Invoices:TotalAmountMismatch',
      /**
       * Invoice {invoiceID:number} has an expected amount of {expectedTotalAmount:number}, but the total amount is {totalAmount:number}.
       */
      ExpectedTotalAmountMismatch = 'Invoices:ExpectedTotalAmountMismatch',
      /**
       * InvoiceAdditionalAmount {invoiceAdditionalAmountID:number} has an original amount of {originalTotalAmount:number}, but the total amount is {totalAmount:number}.
       */
      AdditionalAmountMismatch = 'Invoices:AdditionalAmountMismatch',
      /**
       * Invoice {0:number} has another CalculationMethod than the OrderLine.
       */
      CalculationMismatch = 'Invoices:CalculationMismatch',
      /**
       * An OrderLineID or ShipmentLineID must be supplied to create an InvoiceLine
       */
      OrderLineOrShipmentLineRequired = 'Invoices:OrderLineOrShipmentLineRequired',
      /**
       * A Discount OrderLine cannot be invoiced, it will be invoiced based on the other lines
       */
      DiscountOrderLinesCantBeInvoiced = 'Invoices:DiscountOrderLinesCantBeInvoiced',
      /**
       * A Dispute cannot be attached to an InvoiceLine and an AdditionalAmount
       */
      DisputeCannotBeAttachedTwice = 'Invoices:DisputeCannotBeAttachedTwice',
      /**
       * There already exists a blob for invoice {invoiceID:number} and order {orderID:number}
       */
      InvoiceBlobAlreadyExists = 'Invoices:InvoiceBlobAlreadyExists',
      /**
       * There already exists a blob for invoice {invoiceID:number}, attached to order {orderID:number}
       */
      InvoiceBlobAlreadyExistsForDifferentOrder = 'Invoices:InvoiceBlobAlreadyExistsForDifferentOrder',
      /**
       * There is no email available to send the invoice.
       */
      EmailNotAvailable = 'Invoices:EmailNotAvailable',
      /**
       * Invoice {0:number} has unresolved disputes
       */
      HasUnresolvedDisputes = 'Invoices:HasUnresolvedDisputes',
      /**
       * There are no point of sale available for organization: {0:number}.
       */
      PointOfSaleNotAvailable = 'Invoices:PointOfSaleNotAvailable',
      /**
       * The payment is not available: {0:string}.
       */
      PaymentNotAvailable = 'Invoices:PaymentNotAvailable',
      /**
       * Manual Invoices are not available for this country: {0:string}.
       */
      ManualInvoicesDisabled = 'Invoices:ManualInvoicesDisabled'
    }

    export const enum InvoiceExport {
      /**
       * Invoice {0:number} must be closed before it can be exported.
       */
      InvoiceNotClosed = 'InvoiceExport:InvoiceNotClosed'
    }

    export const enum ExecutableAction {
      /**
       * Invalid action.
       */
      InvalidAction = 'ExecutableAction:InvalidAction'
    }

    export const enum OpeningHours {
      /**
       * Either DayOfWeek or Date is required for an OpeningHour
       */
      DayOfWeekOrDateRequired = 'OpeningHours:DayOfWeekOrDateRequired',
      /**
       * Cannot create OpeningHours in the past
       */
      CannotCreateHoursInThePast = 'OpeningHours:CannotCreateHoursInThePast',
      /**
       * Time slots start time can not be higher or equal to the end time
       */
      TimeSlotStartTimeCanNotBeHigherOrEqualToTheEndTime = 'OpeningHours:TimeSlotStartTimeCanNotBeHigherOrEqualToTheEndTime',
      /**
       * Multiple time slots on the same day cannot overlap each other
       */
      TimeSlotsCannotOverlap = 'OpeningHours:TimeSlotsCannotOverlap',
      /**
       * Time slot start time and end time must be between 00:00:00.0 and 23:59:59.0
       */
      InvalidTimeSlotTimeSpan = 'OpeningHours:InvalidTimeSlotTimeSpan',
      /**
       * OpeninghoursTemplate can not be removed untill all organization unit sets are disconnected from it.
       */
      CannotRemoveOpeninghoursTemplateWhenOUSetsAreConnected = 'OpeningHours:CannotRemoveOpeninghoursTemplateWhenOUSetsAreConnected',
      /**
       * Special openinghours can not be added or updated when the date is in the past.
       */
      CannotAddOrUpdateSpecialOpeningHoursInThePast = 'OpeningHours:CannotAddOrUpdateSpecialOpeningHoursInThePast',
      /**
       * Either `DayOfWeek` or `Date` is required to set openinghours exception.
       */
      EitherDayOfWeekOrDateIsRequiredToSetOpeningHoursException = 'OpeningHours:EitherDayOfWeekOrDateIsRequiredToSetOpeningHoursException',
      /**
       * Invalid period given.
       */
      InvalidPeriodGiven = 'OpeningHours:InvalidPeriodGiven',
      /**
       * OrganizationUnitSet {0:number} is already attached to a template of the same type. When you wish to overwrite this, you must provide the 'OverrideIfOpeningHoursTypeAlreadyAttached' or remove the already attached template of the same type.
       */
      AlreadyAttached = 'OpeningHours:AlreadyAttached'
    }

    export const enum PhoneNumber {
      /**
       * The phonenumber is invalid: {0:string}
       */
      InvalidPhoneNumber = 'PhoneNumber:InvalidPhoneNumber'
    }

    export const enum GiftWrapping {
      /**
       * The selected product is not a greetingcard.
       */
      NoGreetingCardProduct = 'GiftWrapping:NoGreetingCardProduct',
      /**
       * The selected orderline is not available for giftwrapping.
       */
      LineNotAvailableForWrapping = 'GiftWrapping:LineNotAvailableForWrapping',
      /**
       * An OrderLine in the giftwrapping is not in the duplicated order, can't duplicate the giftwrapping.
       */
      LineInGiftWrappingNotInDuplicatedOrder = 'GiftWrapping:LineInGiftWrappingNotInDuplicatedOrder'
    }

    export const enum GiftCards {
      /**
       * The given amount {amount:number} is not in the allowed values {values:string}.
       */
      ActivateValueNotInValues = 'GiftCards:ActivateValueNotInValues',
      /**
       * The given amount {givenAmount:number} is lower than {minAmount:number}.
       */
      ActivateValueTooLow = 'GiftCards:ActivateValueTooLow',
      /**
       * The given amount {givenAmount:number} is higher than {maxAmount:number}.
       */
      ActivateValueTooHigh = 'GiftCards:ActivateValueTooHigh',
      /**
       * Failed to execute the action {action:string} for orderline {orderLineID:number}
       */
      ActionFailed = 'GiftCards:ActionFailed',
      /**
       * Failed to {0:string}
       */
      UnknownError = 'GiftCards:UnknownError',
      /**
       * It's required to supply a PIN when calling this services without being logged in
       */
      PinRequiredForAnonymous = 'GiftCards:PinRequiredForAnonymous',
      /**
       * Unable to determine the cardhandler for this card.
       */
      CardHandlerNotFound = 'GiftCards:CardHandlerNotFound',
      /**
       * No Giftcard configuration for product {0:number}
       */
      CardHandlerNotFoundForProduct = 'GiftCards:CardHandlerNotFoundForProduct',
      /**
       * Unable to fetch cardinfo: {0:string}
       */
      FailedToFetchCardInfo = 'GiftCards:FailedToFetchCardInfo',
      /**
       * The delivery of this giftcard is scheduled within an hour, updates are not allowed.
       */
      DeliveryScheduleToClose = 'GiftCards:DeliveryScheduleToClose',
      /**
       * Redemption of card {0:string} failed
       */
      RedemptionFailed = 'GiftCards:RedemptionFailed',
      /**
       * Card with number {0:string} was not found.
       */
      CardNotFound = 'GiftCards:CardNotFound',
      /**
       * Card with number {0:string} is expired.
       */
      CardExpired = 'GiftCards:CardExpired',
      /**
       * The card has currency {cardCurrency:string}, but the requested currency is {transactionCurrency:string}.
       */
      CurrencyMismatch = 'GiftCards:CurrencyMismatch',
      /**
       * The total balance of all the cards cannot cover the paid amount
       */
      CardsBalanceTooLow = 'GiftCards:CardsBalanceTooLow',
      /**
       * The current card handler does not support multiple cards at once.
       */
      MultipleCardsPaymentNotSupported = 'GiftCards:MultipleCardsPaymentNotSupported',
      /**
       * It is not allowed to pay for GiftCards with a GiftCard.
       */
      PayingForGiftCardsWithGiftCards = 'GiftCards:PayingForGiftCardsWithGiftCards',
      /**
       * A PaymentTransaction for this type of giftcard can only be refunded for the full amount
       */
      RefundsCanOnlyBeDoneForTheFullAmount = 'GiftCards:RefundsCanOnlyBeDoneForTheFullAmount',
      /**
       * No CardActionLedger could be found for the PaymentTransaction
       */
      NoCardActionLedgerFound = 'GiftCards:NoCardActionLedgerFound',
      /**
       * No refund option available for this giftcard
       */
      RefundNotAvailable = 'GiftCards:RefundNotAvailable',
      /**
       * This Giftcard does not allow for refunding this directly.
       */
      RefundWithoutTransactionNotAllowed = 'GiftCards:RefundWithoutTransactionNotAllowed',
      /**
       * This Giftcard has a higher value than the allowed amount for refunding directly.
       */
      CardBalanceTooHigh = 'GiftCards:CardBalanceTooHigh',
      /**
       * An expired card cannot be used.
       */
      Expired = 'GiftCards:Expired',
      /**
       * A card must be activated before use.
       */
      NotActivated = 'GiftCards:NotActivated',
      /**
       * Insufficient balance on card.
       */
      InsufficientBalance = 'GiftCards:InsufficientBalance'
    }

    export const enum APIGiftCard {
      /**
       * The cards have these currencies {cardCurrency:string}, but the requested ones are {transactionCurrency:string}.
       */
      CurrencyMismatches = 'APIGiftCard:CurrencyMismatches'
    }

    export const enum Finance {
      /**
       * There is still an open CashJournal for this Device.
       */
      OpenCashJournal = 'Finance:OpenCashJournal',
      /**
       * There is still an open CashJournal for this Station.
       */
      OpenCashJournalForStation = 'Finance:OpenCashJournalForStation'
    }

    export const enum FinancialPeriods {
      /**
       * There is no financial period available for this organization.
       */
      NoFinancialPeriod = 'FinancialPeriods:NoFinancialPeriod'
    }

    export const enum OpenFinancialPeriod {
      /**
       * The period has already been opened.
       */
      PeriodAlreadyOpened = 'OpenFinancialPeriod:PeriodAlreadyOpened'
    }

    export const enum CloseFinancialPeriod {
      /**
       * The period can only be closed when its status is Open or Closing, it's currently {0:string}.
       */
      PeriodNotOpen = 'CloseFinancialPeriod:PeriodNotOpen',
      /**
       * Financial period management for webshops is temporarily disabled.
       */
      WebshopFinancialPeriodManagementDisabled = 'CloseFinancialPeriod:WebshopFinancialPeriodManagementDisabled'
    }

    export const enum FinancialPeriodOpeningImpediments {
      /**
       * No employees linked to the financial period.
       */
      LinkedEmployees = 'FinancialPeriodOpeningImpediments:LinkedEmployees',
      /**
       * Loyalty program is not linked to the financial period.
       */
      LoyaltyProgram = 'FinancialPeriodOpeningImpediments:LoyaltyProgram'
    }

    export const enum FinancialPeriodClosingImpediments {
      /**
       * There are {0:number} active user tasks remaining that must be completed or deactivated before the period can be closed.
       */
      ActiveUserTasks = 'FinancialPeriodClosingImpediments:ActiveUserTasks',
      /**
       * There are {0:number} products with negative stock that must be corrected before the period can be closed.
       */
      NegativeStock = 'FinancialPeriodClosingImpediments:NegativeStock',
      /**
       * There are {0:number} open cash journals remaining. These must be closed before the period can be closed.
       */
      OpenCashJournals = 'FinancialPeriodClosingImpediments:OpenCashJournals',
      /**
       * The PCI question is not yet answered, this is required to close the period.
       */
      PCIQuestionNotAnswered = 'FinancialPeriodClosingImpediments:PCIQuestionNotAnswered'
    }

    export const enum FinancialPeriodExport {
      /**
       * No endpoint configured for period ledger export.
       */
      EndpointNotConfigured = 'FinancialPeriodExport:EndpointNotConfigured',
      /**
       * Financial period ledger export failed: {0:string}.
       */
      LedgerExportFailed = 'FinancialPeriodExport:LedgerExportFailed'
    }

    export const enum CashServices {
      /**
       * The given TotalAmount does not match with the counted coins and banknotes.
       */
      InvalidTotalAmount = 'CashServices:InvalidTotalAmount'
    }

    export const enum Cash {
      /**
       * The amount of {amount:number} is too precise, an amount in currency {currencyID:string} can only have a precision of {maxDigits:number} digits.
       */
      TooMuchPrecision = 'Cash:TooMuchPrecision',
      /**
       * Depositing cash requires a number.
       */
      CashDepositNumberRequired = 'Cash:CashDepositNumberRequired',
      /**
       * Depositing cash is only allowed from the safe.
       */
      CashDepositIsOnlyAllowedFromSafe = 'Cash:CashDepositIsOnlyAllowedFromSafe',
      /**
       * A required (pending) cash deposit is missing.
       */
      CashDepositMissing = 'Cash:CashDepositMissing',
      /**
       * Safe can not result in a negative balance
       */
      NegativeSafeBalance = 'Cash:NegativeSafeBalance',
      /**
       * This sealbag number was already used on {0:string}
       */
      CashDepositNumberAlreadyInUse = 'Cash:CashDepositNumberAlreadyInUse'
    }

    export const enum CashCorrections {
      /**
       * Remark is required when creating a cash correction.
       */
      RemarkIsRequired = 'CashCorrections:RemarkIsRequired'
    }

    export const enum CashDepositManager {
      /**
       * Cannot drop-off cash deposit because it is not pending.
       */
      CashDepositNotPending = 'CashDepositManager:CashDepositNotPending'
    }

    export const enum CashJournal {
      /**
       * There is no open cash journal for device {0:string}
       */
      NoOpenCashJournal = 'CashJournal:NoOpenCashJournal',
      /**
       * There is still an open cash journal for device {0:string}
       */
      OpenCashJournal = 'CashJournal:OpenCashJournal',
      /**
       * This PaymentMethod requires a Device
       */
      DeviceRequired = 'CashJournal:DeviceRequired',
      /**
       * It's not possible to open a cash journal for a device when you're not currently logged into that OrganizationUnit.
       */
      InvalidOrganizationUnit = 'CashJournal:InvalidOrganizationUnit',
      /**
       * This device could not be found, is not a cash device, or it's not accessible to you.
       */
      InvalidDevice = 'CashJournal:InvalidDevice',
      /**
       * This cashjournal has CashJournalMethod None and can't be opened.
       */
      InvalidCashJournalMethod = 'CashJournal:InvalidCashJournalMethod',
      /**
       * This currency is not available for this organizationunit.
       */
      InvalidCurrency = 'CashJournal:InvalidCurrency'
    }

    export const enum OpenCashJournal {
      /**
       * There is no open financial period available for device {0:string}.
       */
      FinancialPeriodNotOpened = 'OpenCashJournal:FinancialPeriodNotOpened',
      /**
       * There is already an open cash journal for device {device:string}, paymenttype {paymentType:string} in currency {currencyID:string}.
       */
      AlreadyOpened = 'OpenCashJournal:AlreadyOpened',
      /**
       * The previous cash journal closed with a different amount than the new journal's opening, this should be corrected before the new journal can be opened.
       */
      UnexplainedOpeningDeviation = 'OpenCashJournal:UnexplainedOpeningDeviation'
    }

    export const enum CloseCashJournal {
      /**
       * The amount of cash in device {0:string} exceeds the allowed limit for this device.
       */
      ExceedsCashLimit = 'CloseCashJournal:ExceedsCashLimit',
      /**
       * The cash journal cannot be closed when the difference between the expected and the counted amount has not been corrected.
       */
      UnexplainedClosingDeviation = 'CloseCashJournal:UnexplainedClosingDeviation',
      /**
       * The cash journal cannot be closed with a correction being made without providing a reason or description.
       */
      MissingReasonOrDescriptionForCashCorrection = 'CloseCashJournal:MissingReasonOrDescriptionForCashCorrection'
    }

    export const enum MoveCash {
      /**
       * Source device ({source:string}) cannot be used for moving cash to destination device ({destination:string}).
       */
      InvalidDevice = 'MoveCash:InvalidDevice',
      /**
       * An amount of {currencyID:string} {amount:number} is not valid.
       */
      InvalidAmount = 'MoveCash:InvalidAmount',
      /**
       * When moving cash between two journals they must both be in the same financial period, but the source period was {sourceFinancialPeriodID:number} while the destination period was {destinationFinancialPeriodID:number}.
       */
      CashJournalsMustBeInSamePeriod = 'MoveCash:CashJournalsMustBeInSamePeriod',
      /**
       * Cannot supply Total and Coins or Notes at the same time. Try supplying either the Total or the Coins and Notes.
       */
      CannotSupplyTotalAndCoinsOrNotesAtTheSameTime = 'MoveCash:CannotSupplyTotalAndCoinsOrNotesAtTheSameTime'
    }

    export const enum ExchangeRates {
      /**
       * There is no exchange rate available from {baseCurrencyID:string} to {currencyID:string}
       */
      NoExchangeRateAvailable = 'ExchangeRates:NoExchangeRateAvailable'
    }

    export const enum EventExportConfiguration {
      /**
       * The provided endpoint is either invalid or is not secure
       */
      InvalidEndpoint = 'EventExportConfiguration:InvalidEndpoint',
      /**
       * Cannot change status to Error
       */
      CannotSetToError = 'EventExportConfiguration:CannotSetToError',
      /**
       * The provided config is invalid
       */
      InvalidConfig = 'EventExportConfiguration:InvalidConfig',
      /**
       * The key ID is invalid (should be either 1 or 2)
       */
      InvalidKeyID = 'EventExportConfiguration:InvalidKeyID'
    }

    export const enum Auditing {
      /**
       * There are multiple orders for invoice {0:number}, this is not allowed.
       */
      MultipleOrdersForInvoice = 'Auditing:MultipleOrdersForInvoice',
      /**
       * Not allowed to autocomplete orders in an audited country when invoicing is required.
       */
      AutoCompletionNotAllowed = 'Auditing:AutoCompletionNotAllowed',
      /**
       * '{0}' with value '{1}' doesn't pass validation.
       */
      ValidationError = 'Auditing:ValidationError'
    }

    export const enum Printing {
      /**
       * Unable to find a printer.
       */
      PrinterNotFound = 'Printing:PrinterNotFound',
      /**
       * IPP printing requires that a host name is configured.
       */
      MissingHostName = 'Printing:MissingHostName',
      /**
       * Device {0:number} has no network name or ip address specified, one of these is required for IPP printing
       */
      MissingNetworkName = 'Printing:MissingNetworkName',
      /**
       * Converting PDF to PCL through URL {0:string} failed.
       */
      FailureConvertingPDF2PCL = 'Printing:FailureConvertingPDF2PCL',
      /**
       * Failed to print: {0:string}
       */
      PrintFailure = 'Printing:PrintFailure'
    }

    export const enum Devices {
      /**
       * Unable to find a device.
       */
      DeviceNotFound = 'Devices:DeviceNotFound',
      /**
       * There is no connection available to the requested device.
       */
      NoConnectionAvailable = 'Devices:NoConnectionAvailable',
      /**
       * Watchtowers can only be created with the CreateWatchtowerDevice service.
       */
      WatchtowerTypeNotAllowed = 'Devices:WatchtowerTypeNotAllowed',
      /**
       * Devices need a Station or OrganizationUnit.
       */
      StationOrOrganizationUnitRequired = 'Devices:StationOrOrganizationUnitRequired',
      /**
       * Device {0:number} has no Address configured.
       */
      AddressNotConfigured = 'Devices:AddressNotConfigured',
      /**
       * Device {0:number} has no valid Address ({1:string}) configured.
       */
      UnableToParseAddress = 'Devices:UnableToParseAddress'
    }

    export const enum Stations {
      /**
       * Station is required.
       */
      StationRequired = 'Stations:StationRequired',
      /**
       * Station '{0:number}' is not a point of sale
       */
      StationIsNotPointOfSale = 'Stations:StationIsNotPointOfSale',
      /**
       * Station {0:number} cannot be used from your current user context.
       */
      InvalidStation = 'Stations:InvalidStation'
    }

    export const enum Global {
      /**
       * The client to communicate with the global eva instance is not configured.
       */
      GlobalClientNotConfigured = 'Global:GlobalClientNotConfigured',
      /**
       * This service has been deprecated from version {deprecationVersion:number} and will be removed in version {wopVersion:number}.
       */
      ServiceNoLongerInUse = 'Global:ServiceNoLongerInUse'
    }

    export const enum Users {
      /**
       * User does not exist.
       */
      DoesNotExist = 'Users:DoesNotExist',
      /**
       * Another user with this BackendID already exists.
       */
      DuplicateBackendID = 'Users:DuplicateBackendID',
      /**
       * Can only generate a PIN for an employee.
       */
      CanOnlyGeneratePINForEmployee = 'Users:CanOnlyGeneratePINForEmployee',
      /**
       * This PIN is not secure enough.
       */
      InsecurePIN = 'Users:InsecurePIN',
      /**
       * Tried to generate a PIN with length {attemptLength:number} but it must be length {requiredLength:number}.
       */
      InvalidLengthForPIN = 'Users:InvalidLengthForPIN',
      /**
       * EmailAddress '{0:string}' is already in use.
       */
      EmailAddressInUse = 'Users:EmailAddressInUse',
      /**
       * EmailAddress of a Customer can't be changed.
       */
      CantChangeCustomerEmailAddress = 'Users:CantChangeCustomerEmailAddress',
      /**
       * It is not allowed to change the EmailAddress of another employee.
       */
      CantChangeEmailAddressOfAnotherEmployee = 'Users:CantChangeEmailAddressOfAnotherEmployee',
      /**
       * Nickname '{0:string}' is already in use.
       */
      NicknameInUse = 'Users:NicknameInUse',
      /**
       * Fiscal ID '{0:string}' is already in use.
       */
      FiscalIDInUse = 'Users:FiscalIDInUse',
      /**
       * When no emailaddress is supplied, a password is required.
       */
      PasswordRequired = 'Users:PasswordRequired',
      /**
       * It is not allowed to set a password for employee accounts.
       */
      PasswordNotAllowedForEmployees = 'Users:PasswordNotAllowedForEmployees',
      /**
       * EmailAddress '{0:string}' is not valid.
       */
      InvalidEmailAddress = 'Users:InvalidEmailAddress',
      /**
       * PhoneNumber '{0:string}' is not valid.
       */
      InvalidPhoneNumber = 'Users:InvalidPhoneNumber',
      /**
       * This nickname '{0:string}' is not valid.
       */
      InvalidNickname = 'Users:InvalidNickname',
      /**
       * This password reset token is not valid
       */
      PasswordResetTokenInvalid = 'Users:PasswordResetTokenInvalid',
      /**
       * This password reset token has already been used to reset a password
       */
      PasswordResetTokenAlreadyUsed = 'Users:PasswordResetTokenAlreadyUsed',
      /**
       * This password is not valid: {0:string}
       */
      PasswordPolicyViolation = 'Users:PasswordPolicyViolation',
      /**
       * It is not allowed to create an employee that is also customer
       */
      MixedAccountsNotAllowed = 'Users:MixedAccountsNotAllowed',
      /**
       * It is not allowed to create a customer standard account in this visibility group
       */
      NoCustomerAccountsAllowedInThisVisibilityGroup = 'Users:NoCustomerAccountsAllowedInThisVisibilityGroup',
      /**
       * It is not allowed to recover your own account
       */
      CantRecoverOwnAccount = 'Users:CantRecoverOwnAccount',
      /**
       * The selected user is not visible.
       */
      NotVisible = 'Users:NotVisible',
      /**
       * Delete users limit of {0:number} exceeded.
       */
      DeleteUsersLimitExceeded = 'Users:DeleteUsersLimitExceeded',
      /**
       * Duplicate custom fields are invalid.
       */
      DuplicateCustomFields = 'Users:DuplicateCustomFields',
      /**
       * A company a user is attached to must be a consumer company.
       */
      UserCompanyMustBeConsumerCompany = 'Users:UserCompanyMustBeConsumerCompany'
    }

    export const enum Roles {
      /**
       * The Role {roleName:string} is not contained in the RoleSet of OrganizationUnit {ouName:string}.
       */
      RoleNotInRoleSet = 'Roles:RoleNotInRoleSet',
      /**
       * You are not allowed to set the role {roleName:string} for organization unit {ouName:string}
       */
      NotAllowedToSetRole = 'Roles:NotAllowedToSetRole',
      /**
       * The selected Role `{0:number}` has a non-matching UserType.
       */
      RoleUserTypeMismatch = 'Roles:RoleUserTypeMismatch',
      /**
       * This role still has users attached - please remove them first!
       */
      RoleStillHasUsers = 'Roles:RoleStillHasUsers'
    }

    export const enum Login {
      /**
       * Username is a required field when authenticating with credentials.
       */
      UsernameRequired = 'Login:UsernameRequired',
      /**
       * Failed to execute the custom login.
       */
      CustomAuthenticationFailed = 'Login:CustomAuthenticationFailed'
    }

    export const enum Barcodes {
      /**
       * Invalid barcode ({0:string}) provided
       */
      InvalidBarcode = 'Barcodes:InvalidBarcode',
      /**
       * Invalid handler type was provided to ExecuteBarcode.
       */
      InvalidExecuteHandlerType = 'Barcodes:InvalidExecuteHandlerType'
    }

    export const enum OrderLine {
      /**
       * Quantity cannot be modified: {0:string}
       */
      CannotModifyQuantity = 'OrderLine:CannotModifyQuantity',
      /**
       * Quantity to split must be positive and cannot be greather or equal to the quantity of the orderline.
       */
      InvalidSplitQuantity = 'OrderLine:InvalidSplitQuantity',
      /**
       * Order line #{0:number} has already been shipped.
       */
      AlreadyShipped = 'OrderLine:AlreadyShipped',
      /**
       * Require a product to mutate the order line
       */
      ProductRequiredToMutatePrice = 'OrderLine:ProductRequiredToMutatePrice',
      /**
       * Require a product with custom pricing to mutate the order line
       */
      ProductRequiresCustomPricingToMutatePrice = 'OrderLine:ProductRequiresCustomPricingToMutatePrice',
      /**
       * A GiftCard with CustomPricing requires a positive UnitPrice
       */
      GiftCardsRequireAPositiveUnitPrice = 'OrderLine:GiftCardsRequireAPositiveUnitPrice',
      /**
       * This lineactiontype is not valid for the orderline {OrderLineID:number}: {Error:string}
       */
      LineActionTypeChangeNotValid = 'OrderLine:LineActionTypeChangeNotValid',
      /**
       * OrderLine {0:number} has already been completed/shipped/invoiced and can therefor no longer be corrected in price.
       */
      UnitPriceCanNoLongerBeCorrected = 'OrderLine:UnitPriceCanNoLongerBeCorrected',
      /**
       * It is required to supply a reason for a UnitPriceCorrection.
       */
      UnitPriceCorrectionReasonRequired = 'OrderLine:UnitPriceCorrectionReasonRequired',
      /**
       * UnitPriceCorrections are only allowed on manual returnlines.
       */
      UnitPriceCorrectionNotAManualReturn = 'OrderLine:UnitPriceCorrectionNotAManualReturn',
      /**
       * Correction amount is limited to {Limit:number}, but {Requested:number} was requested.
       */
      CorrectionAmountExceeded = 'OrderLine:CorrectionAmountExceeded'
    }

    export const enum Shipment {
      /**
       * Cannot receive an unshipped shipment.
       */
      CannotReceiveUnshippedShipment = 'Shipment:CannotReceiveUnshippedShipment',
      /**
       * Cannot fully receive shipment {0:number}, because all lines are already completed.
       */
      CannotFullyReceiveCompletedShipment = 'Shipment:CannotFullyReceiveCompletedShipment',
      /**
       * Shipment already exists with that BackendSystemID/BackendID combination: {backendSystemID:string}/{backendID:string}
       */
      ShipmentAlreadyExists = 'Shipment:ShipmentAlreadyExists',
      /**
       * ShipmentReceipt already exists with that BackendSystemID/BackendID combination: {backendSystemID:string}/{backendID:string}
       */
      ShipmentReceiptAlreadyExists = 'Shipment:ShipmentReceiptAlreadyExists',
      /**
       * Can only ship purchase orders.
       */
      CanOnlyShipPurchaseOrders = 'Shipment:CanOnlyShipPurchaseOrders',
      /**
       * Orders should be supplied with full details.
       */
      OrderWithFullDetailsRequired = 'Shipment:OrderWithFullDetailsRequired',
      /**
       * ShipFromOrganizationUnit does not match for order #{orderID:number} which has #{shipFromOnOrder:number} and the shipment being created which has #{shipFromOnShipment:number}
       */
      ShipFromOrganizationUnitMismatch = 'Shipment:ShipFromOrganizationUnitMismatch',
      /**
       * The shipment contains an order of the wrong type for shipmentreceiver {0:string}
       */
      OrderTypeMismatch = 'Shipment:OrderTypeMismatch',
      /**
       * Surplus are not allowed.
       */
      SurplusNotAllowed = 'Shipment:SurplusNotAllowed',
      /**
       * Overshipment is not allowed; attempted to ship {quantityShipped:number} on order line {orderLine:number} even though it only has an open quantity of {quantityOpen:number}.
       */
      OvershipmentNotAllowed = 'Shipment:OvershipmentNotAllowed',
      /**
       * Shipment {0:number} is not Pending and cannot be mutated.
       */
      IsNotPending = 'Shipment:IsNotPending',
      /**
       * Pending shipments are not yet supported for non-sales orders.
       */
      PendingShipmentNotSupported = 'Shipment:PendingShipmentNotSupported',
      /**
       * Can't return OrderLine {returnOrderLineID:number} on Order {returnOrderID:number} for original OrderLine {originalOrderLineID:number}. The QuantityReturned ({quantityReturned:number}) is greather than the QuantityShipped ({quantityShipped:number})
       */
      CannotReturnMoreThanShipped = 'Shipment:CannotReturnMoreThanShipped',
      /**
       * Multiple shipping methods are not supported for one shipment.
       */
      MultipleShippingMethodsNotSupported = 'Shipment:MultipleShippingMethodsNotSupported',
      /**
       * There are no lines to receive specified for shipment {0:number}
       */
      NoReceiptLinesSpecified = 'Shipment:NoReceiptLinesSpecified',
      /**
       * Can't ship order {orderID:number}. There is still an open amount of {openAmount:number}.
       */
      OpenAmount = 'Shipment:OpenAmount',
      /**
       * A shipment can either contain lines or packages with lines, not both.
       */
      ShipmentCanOnlyContainLinesOrPackagesWithLines = 'Shipment:ShipmentCanOnlyContainLinesOrPackagesWithLines',
      /**
       * Shipment with multiple packages aren't allowed.
       */
      ShipmentWithMultiplePackagesNotAllowed = 'Shipment:ShipmentWithMultiplePackagesNotAllowed',
      /**
       * Preventing creation of empty shipment!
       */
      EmptyShipment = 'Shipment:EmptyShipment',
      /**
       * Invalid delivery type for shipping method
       */
      InvalidShippingMethodDeliveryType = 'Shipment:InvalidShippingMethodDeliveryType',
      /**
       * Package does not match shipping method
       */
      PackageDoesNotMatchShippingMethod = 'Shipment:PackageDoesNotMatchShippingMethod'
    }

    export const enum EntityFieldValidator {
      /**
       * The provided field name is not available or doesn't exist for this entity. To see available fields, execute ListEntityFieldValidatorEntityFieldNames.
       */
      FieldDoesNotExist = 'EntityFieldValidator:FieldDoesNotExist',
      /**
       * There is already a validator that covers this usertype.
       */
      UserTypeAlreadyExists = 'EntityFieldValidator:UserTypeAlreadyExists',
      /**
       * EntityFieldValidators on {entity:string} -> {property:string} with value {value:string} doesn't comply with rule {rule:string} -> {ruleValue:string}.
       */
      FieldValidationError = 'EntityFieldValidator:FieldValidationError'
    }

    export const enum Payment {
      /**
       * An Order with an attached customer is required for this payment.
       */
      CustomerRequired = 'Payment:CustomerRequired',
      /**
       * Transaction {0:number} has already been confirmed.
       */
      TransactionAlreadyConfirmed = 'Payment:TransactionAlreadyConfirmed',
      /**
       * Transaction {0:number} is already being processed.
       */
      TransactionAlreadyProcessing = 'Payment:TransactionAlreadyProcessing',
      /**
       * TransactionCapture {0:number} has already been confirmed.
       */
      CaptureAlreadyConfirmed = 'Payment:CaptureAlreadyConfirmed',
      /**
       * Transaction {0:number} is failed, create a new transaction.
       */
      TransactionFailed = 'Payment:TransactionFailed',
      /**
       * Refund failed: {0:string}
       */
      RefundFailed = 'Payment:RefundFailed',
      /**
       * Refund is not available for this order
       */
      RefundNotAvailable = 'Payment:RefundNotAvailable',
      /**
       * Requested to refund {requested:number} on the order, but only {available:number} is available for refund
       */
      RefundAmountNotAvailable = 'Payment:RefundAmountNotAvailable',
      /**
       * PaymentMethod {0:string} is not available
       */
      PaymentMethodNotAvailable = 'Payment:PaymentMethodNotAvailable',
      /**
       * Can't pay more than is due. Order {orderID:number} has an openamount of {openAmount:number} and a payment of {amountToPay:number} is requested.
       */
      OverPayment = 'Payment:OverPayment',
      /**
       * CashJournalMethod on PaymentType must be None/Open/OpenAndClose. {0:PaymentCashJournalMethod} is not allowed.
       */
      InvalidCashJournalMethod = 'Payment:InvalidCashJournalMethod',
      /**
       * Only Custom PaymentMethods can be mutated.
       */
      PaymentMethodIsNotCustom = 'Payment:PaymentMethodIsNotCustom',
      /**
       * A PaymentType must be of the same PaymentMethod.
       */
      PaymentTypeCannotBeChangedToOtherMethod = 'Payment:PaymentTypeCannotBeChangedToOtherMethod',
      /**
       * A PaymentTransaction must be committed before it can be captured.
       */
      UncommittedPaymentsCantBeCaptured = 'Payment:UncommittedPaymentsCantBeCaptured',
      /**
       * This paymenttransaction cannot be captured.
       */
      CaptureNotAvailable = 'Payment:CaptureNotAvailable',
      /**
       * This paymenttransaction can no langer be captured, the authorization has been expired.
       */
      AuthorizationExpired = 'Payment:AuthorizationExpired',
      /**
       * The selected device is already in use for a pin transaction.
       */
      PinDeviceAlreadyInUse = 'Payment:PinDeviceAlreadyInUse',
      /**
       * Cannot perform this action when setting `PaymentMethods:PaymentTypeAvailabilityByOuSetType` is enabled!
       */
      PaymentTypeAvailabilityByOuSetTypeEnabled = 'Payment:PaymentTypeAvailabilityByOuSetTypeEnabled',
      /**
       * The current payment method does not support multiple cards at once.
       */
      MultipleCardsPaymentNotSupported = 'Payment:MultipleCardsPaymentNotSupported',
      /**
       * Payment initialization not supported
       */
      InitializationNotSupported = 'Payment:InitializationNotSupported',
      /**
       * The current payment method does not support multi currency.
       */
      PaymentMethodDoesNotSupportMultiCurrency = 'Payment:PaymentMethodDoesNotSupportMultiCurrency',
      /**
       * The payment has no tokization data.
       */
      MissingTokenizationData = 'Payment:MissingTokenizationData'
    }

    export const enum Discounts {
      /**
       * Coupon {0:string} is invalid.
       */
      InvalidDiscountCoupon = 'Discounts:InvalidDiscountCoupon',
      /**
       * Discount {DiscountID:number} has already been used the maximum number of times.
       */
      MaximumDiscountUsageReached = 'Discounts:MaximumDiscountUsageReached',
      /**
       * Discount {0:number} has already been used the maximum number of times by the user.
       */
      MaximumDiscountUserUsageCountReached = 'Discounts:MaximumDiscountUserUsageCountReached',
      /**
       * User reached the maximum usage of discount {0:number}.
       */
      MaximumDiscountUserUsageBalanceReached = 'Discounts:MaximumDiscountUserUsageBalanceReached',
      /**
       * User {CustomerID:number} has insufficient credit to use Discount {DiscountID:number}. Available: {Balance:number}, Discount: {DiscountAmount:number}, Order: {OrderID:number}
       */
      InsufficientUserCardBalance = 'Discounts:InsufficientUserCardBalance',
      /**
       * Coupon resolved on different handler then registerd on the discount.
       */
      InvalidCouponHandlerResolvement = 'Discounts:InvalidCouponHandlerResolvement',
      /**
       * Coupon '{0:string}' not usable in current organization unit.
       */
      CouponNotUsableInCurrentOrganizationUnit = 'Discounts:CouponNotUsableInCurrentOrganizationUnit',
      /**
       * Coupon '{couponCode:string}' not usable for currency '{currency:string}'.
       */
      CouponNotUsableInCurrentCurrency = 'Discounts:CouponNotUsableInCurrentCurrency',
      /**
       * Coupon '{couponCode:string}' from '{handler:string}' not longer usable.
       */
      CouponNoLongerUsable = 'Discounts:CouponNoLongerUsable',
      /**
       * Coupon maximum usage reached
       */
      CouponMaximumUsageReached = 'Discounts:CouponMaximumUsageReached',
      /**
       * Coupon has expired
       */
      ExpiredCoupon = 'Discounts:ExpiredCoupon',
      /**
       * Coupon already added
       */
      CouponAlreadyAdded = 'Discounts:CouponAlreadyAdded',
      /**
       * Discount can not be used as a manual discount. Trigger is not set as manual.
       */
      DiscountNotSetAsManualDiscount = 'Discounts:DiscountNotSetAsManualDiscount',
      /**
       * Discount can not be used as a loyalty discount. Trigger is not set as manual.
       */
      DiscountNotSetAsLoyaltyDiscount = 'Discounts:DiscountNotSetAsLoyaltyDiscount',
      /**
       * Coupon {couponCode:string} with DiscountBackendID `{discountBackendID:string}` did not resolve to a valid discount.
       */
      CouponDidNotResolveToAValidDiscount = 'Discounts:CouponDidNotResolveToAValidDiscount',
      /**
       * Invalid coupon
       */
      InvalidCoupon = 'Discounts:InvalidCoupon',
      /**
       * Line level discount requires lines te be applied to
       */
      LineLevelDiscountRequiresLinesToApplyTo = 'Discounts:LineLevelDiscountRequiresLinesToApplyTo',
      /**
       * Discount reason required
       */
      DiscountReasonRequired = 'Discounts:DiscountReasonRequired',
      /**
       * Customer is required in order to apply this discount.
       */
      CustomerRequiredForDiscount = 'Discounts:CustomerRequiredForDiscount',
      /**
       * Required custom field `{0:number}` is missing.
       */
      RequiredCustomFieldMissing = 'Discounts:RequiredCustomFieldMissing',
      /**
       * Manual discount amount is invalid
       */
      ManualDiscountAmountIsInvalid = 'Discounts:ManualDiscountAmountIsInvalid',
      /**
       * Manual discount already applied to the order.
       */
      ManualDiscountAlreadyAppliedToTheOrder = 'Discounts:ManualDiscountAlreadyAppliedToTheOrder',
      /**
       * Manual discount given on invalid orderline.
       */
      ManualDiscountGivenOnInvalidOrderLine = 'Discounts:ManualDiscountGivenOnInvalidOrderLine',
      /**
       * Manual discount on line can not exceed orderline quantity.
       */
      ManualDiscountOnLineCanNotExceedOrderLineQuantity = 'Discounts:ManualDiscountOnLineCanNotExceedOrderLineQuantity',
      /**
       * Discount is already verified
       */
      DiscountAlreadyVerified = 'Discounts:DiscountAlreadyVerified',
      /**
       * Discount is not verified
       */
      DiscountIsNotVerified = 'Discounts:DiscountIsNotVerified',
      /**
       * Discount is not active
       */
      DiscountIsntActive = 'Discounts:DiscountIsntActive',
      /**
       * Discount is archived and can no longer be used
       */
      DiscountArchived = 'Discounts:DiscountArchived',
      /**
       * Discount is system managed and can not be displayed.
       */
      DiscountIsSystemManaged = 'Discounts:DiscountIsSystemManaged',
      /**
       * Order is not of correct type for the discount
       */
      OrderDoesNotMeetDiscountOrderType = 'Discounts:OrderDoesNotMeetDiscountOrderType',
      /**
       * Discount is disabled on order
       */
      DiscountIsDisabledOnOrder = 'Discounts:DiscountIsDisabledOnOrder',
      /**
       * Coupon is invalid
       */
      CouponIsInvalid = 'Discounts:CouponIsInvalid',
      /**
       * Allow price riles for interbranch order is disabled
       */
      AllowPriceRulesForInterbranchOrdersIsDisabled = 'Discounts:AllowPriceRulesForInterbranchOrdersIsDisabled',
      /**
       * Automatic discounts aren't allowed on returntosupplier orders
       */
      AutomaticDiscountsArentAllowedOnReturnToSupplierOrders = 'Discounts:AutomaticDiscountsArentAllowedOnReturnToSupplierOrders',
      /**
       * Discount on return order is disabled
       */
      DiscountOnReturnOrderIsDisabled = 'Discounts:DiscountOnReturnOrderIsDisabled',
      /**
       * Discount on return reversal order disabled
       */
      DiscountOnReturnReversalIsDisabled = 'Discounts:DiscountOnReturnReversalIsDisabled',
      /**
       * Order did not meet all of the discount conditions. Condition(s) not met; {0:string}
       */
      OrderDidNotMeetAllTheDiscountConditions = 'Discounts:OrderDidNotMeetAllTheDiscountConditions',
      /**
       * Order did not meet any of the discount conditions. Condition(s) not met; {0:string}
       */
      OrderDidNotMeetAnyOfTheDiscountConditions = 'Discounts:OrderDidNotMeetAnyOfTheDiscountConditions',
      /**
       * Roles can only be applied to manual discounts.
       */
      RolesCanOnlyBeAppliedToManualDiscounts = 'Discounts:RolesCanOnlyBeAppliedToManualDiscounts',
      /**
       * Discount with trigger {0:string} can not be disabled on order. Cancel or removed them.
       */
      CannotDisableDiscountOfTypeX = 'Discounts:CannotDisableDiscountOfTypeX',
      /**
       * {0:string} discount action type is invalid.
       */
      InvalidActionType = 'Discounts:InvalidActionType',
      /**
       * {0:string} discount condition type is invalid.
       */
      InvalidConditionType = 'Discounts:InvalidConditionType',
      /**
       * Discount is generated from a template and can not be modified
       */
      DiscountGeneratedFromTemplate = 'Discounts:DiscountGeneratedFromTemplate',
      /**
       * Discount campaign name is required.
       */
      DiscountCampaignNameIsRequired = 'Discounts:DiscountCampaignNameIsRequired',
      /**
       * Discount campaign names must be unique. '{0:string}' is already taken.
       */
      DiscountCampaignNameMustBeUnique = 'Discounts:DiscountCampaignNameMustBeUnique',
      /**
       * Discount can only applied with order generated coupons.
       */
      DiscountRequiresOrderGeneratedCoupon = 'Discounts:DiscountRequiresOrderGeneratedCoupon',
      /**
       * Coupon originating order does not exist.
       */
      OriginatingOrderDoesNotExist = 'Discounts:OriginatingOrderDoesNotExist',
      /**
       * Coupon originating order isn't paid.
       */
      OriginatingOrderIsntPaid = 'Discounts:OriginatingOrderIsntPaid',
      /**
       * Coupon originating order isn't shipped.
       */
      OriginatingOrderIsntShipped = 'Discounts:OriginatingOrderIsntShipped',
      /**
       * Coupon originating order is fully returned and coupon can no longer be used.
       */
      OriginatingOrderIsFullyReturned = 'Discounts:OriginatingOrderIsFullyReturned',
      /**
       * Can not create coupon for discount that hasn't got triggertype 'Coupon'.
       */
      CannotCreateCouponForDiscountWhereTriggerTypeIsntCoupon = 'Discounts:CannotCreateCouponForDiscountWhereTriggerTypeIsntCoupon',
      /**
       * Coupons for this discount are generated by another discount.
       */
      CouponsForThisDiscountAreGeneratedByOtherDiscount = 'Discounts:CouponsForThisDiscountAreGeneratedByOtherDiscount',
      /**
       * Cannot modify active discount template.
       */
      CannotModifyActiveDiscountTemplate = 'Discounts:CannotModifyActiveDiscountTemplate',
      /**
       * Cannot create discount from inactive discount template.
       */
      CannotCreateDiscountFromInActiveDiscountTemplate = 'Discounts:CannotCreateDiscountFromInActiveDiscountTemplate',
      /**
       * Service only accepts discount lines to cancel.
       */
      ServiceOnlyAcceptsDiscountLinesToCancel = 'Discounts:ServiceOnlyAcceptsDiscountLinesToCancel',
      /**
       * DiscountLines of discount type {0:string} cannot be cancelled
       */
      DiscountLinesOfDiscountTypeXCannotBeCancelled = 'Discounts:DiscountLinesOfDiscountTypeXCannotBeCancelled',
      /**
       * CustomUserUsageField {CustomFieldID:number} on Discount {DiscountID:number} is not (or no longer) a decimal data type.
       */
      CustomUserUsageFieldTypeInvalid = 'Discounts:CustomUserUsageFieldTypeInvalid',
      /**
       * The value in CustomUserUsageField {CustomFieldID:number} for customer {CustomerID:number} is to low to use Discount {DiscountID:number}. CustomUserUsageField value: {CustomUserUsageFieldValue:number}, Discount amount: {DiscountAmount:number}, Order: {OrderID:number}
       */
      CustomUserUsageFieldValueToLow = 'Discounts:CustomUserUsageFieldValueToLow',
      /**
       * Discount {0:number} does not support product selection.
       */
      DiscountDoesNotSupportProductSelection = 'Discounts:DiscountDoesNotSupportProductSelection',
      /**
       * Failed to load discount product selection data for orderline {0:number}.
       */
      FailedToLoadSelectionDataForDiscountLine = 'Discounts:FailedToLoadSelectionDataForDiscountLine',
      /**
       * Invalid orderline for discount product selection.
       */
      InvalidOrderlineForDiscountProductSelection = 'Discounts:InvalidOrderlineForDiscountProductSelection',
      /**
       * Coupon `{0:string}` already exists.
       */
      CouponAlreadyExists = 'Discounts:CouponAlreadyExists',
      /**
       * Coupon `{0:string}` already exists on discount.
       */
      CouponAlreadyExistsOnDiscount = 'Discounts:CouponAlreadyExistsOnDiscount',
      /**
       * Coupon `{0:string}` is bound to a specific user.
       */
      CouponIsUserBound = 'Discounts:CouponIsUserBound',
      /**
       * There are duplicate coupon codes in the upload.
       */
      DuplicateCouponCodeInUpload = 'Discounts:DuplicateCouponCodeInUpload',
      /**
       * The selected product requirement does not (or does no longer) exist.
       */
      InvalidProductRequirement = 'Discounts:InvalidProductRequirement',
      /**
       * The given product requirement value (or one of the values) is empty.
       */
      InvalidProductRequirementValue = 'Discounts:InvalidProductRequirementValue',
      /**
       * Cannot apply this discount to an order of the logged in user.
       */
      CannotApplyDiscountToOwnOrder = 'Discounts:CannotApplyDiscountToOwnOrder',
      /**
       * Loyalty program no longer valid.
       */
      LoyaltyProgramNoLongerValid = 'Discounts:LoyaltyProgramNoLongerValid',
      /**
       * Not subscribed to loyalty program.
       */
      NotSubscribedToLoyaltyProgram = 'Discounts:NotSubscribedToLoyaltyProgram',
      /**
       * Loyalty program subscription blocked.
       */
      LoyaltyProgramSubscriptionBlocked = 'Discounts:LoyaltyProgramSubscriptionBlocked',
      /**
       * Cannot withdraw from loyalty program.
       */
      CannotWithdrawFromLoyaltyProgram = 'Discounts:CannotWithdrawFromLoyaltyProgram',
      /**
       * There are insufficient loyalty points to apply the discount.
       */
      InsufficientLoyaltyPoints = 'Discounts:InsufficientLoyaltyPoints',
      /**
       * Discount cannot be applied to lines, only on order.
       */
      DiscountCannotBeAppliedToLines = 'Discounts:DiscountCannotBeAppliedToLines',
      /**
       * All discount layers are required for reordering.
       */
      AllDiscountLayersAreRequiredForReordering = 'Discounts:AllDiscountLayersAreRequiredForReordering',
      /**
       * The system discount layer cannot be changed
       */
      SystemLayerCannotBeChanged = 'Discounts:SystemLayerCannotBeChanged',
      /**
       * Layer has active discounts.
       */
      LayerHasActiveDiscounts = 'Discounts:LayerHasActiveDiscounts',
      /**
       * A description is required.
       */
      DescriptionRequired = 'Discounts:DescriptionRequired',
      /**
       * A currency is required.
       */
      CurrencyRequired = 'Discounts:CurrencyRequired',
      /**
       * An action is required.
       */
      ActionRequired = 'Discounts:ActionRequired',
      /**
       * An OrganizationUnitSet is required.
       */
      OrganizationUnitSetRequired = 'Discounts:OrganizationUnitSetRequired',
      /**
       * A Layer is required.
       */
      LayerRequired = 'Discounts:LayerRequired',
      /**
       * The selected date range is invalid.
       */
      InvalidDateRange = 'Discounts:InvalidDateRange',
      /**
       * A (Discount)OrderType is required.
       */
      OrderTypeRequired = 'Discounts:OrderTypeRequired',
      /**
       * A customer is required.
       */
      CustomerRequired = 'Discounts:CustomerRequired',
      /**
       * DiscountValue in LookupList cannot be negative
       */
      DiscountValueInLookupListCannotBeNegative = 'Discounts:DiscountValueInLookupListCannotBeNegative',
      /**
       * DiscountValue in LookupList must be a valid percentage
       */
      DiscountValueInLookupListMustBeAValidPercentage = 'Discounts:DiscountValueInLookupListMustBeAValidPercentage',
      /**
       * CustomField to use as discount value must be of type integer or decimal
       */
      CustomFieldToUseAsDiscountValueMustBeOfTypeIntegerOrDecimal = 'Discounts:CustomFieldToUseAsDiscountValueMustBeOfTypeIntegerOrDecimal',
      /**
       * CustomField enum values must be convertible to numeric (integer or decimal) values
       */
      CustomFieldEnumValuesMustBeConvertibleToNumericValues = 'Discounts:CustomFieldEnumValuesMustBeConvertibleToNumericValues'
    }

    export const enum DiscountsV2 {
      /**
       * Old discount actions and conditions are no longer supported. Please update the discount or archive it and create a new one (recommended).
       */
      OldDiscountActionsAndConditionsAreNoLongerSupported = 'DiscountsV2:OldDiscountActionsAndConditionsAreNoLongerSupported',
      /**
       * The discount calculation failed with an unexpected error.
       */
      DiscountCalculationFailedWithUnexpectedError = 'DiscountsV2:DiscountCalculationFailedWithUnexpectedError',
      /**
       * DiscountCondition {0:string} is not allowed for discount trigger {1:string}.
       */
      ConditionNotEnabledForTriggerType = 'DiscountsV2:ConditionNotEnabledForTriggerType',
      /**
       * CouponCondition {ConditionID:number} for discount {DiscountID:number} was malformed or its build-up resulted in an exception.
       */
      InvalidDiscountCouponCondition = 'DiscountsV2:InvalidDiscountCouponCondition',
      /**
       * The data for CouponCondition {ConditionID:number} on discount {DiscountID:number} is not initialized properly.
       */
      DiscountCouponConditionDataNotInitialized = 'DiscountsV2:DiscountCouponConditionDataNotInitialized',
      /**
       * The DiscountAction for discount {0:number} was malformed or its build-up resulted in an exception.
       */
      InvalidDiscountAction = 'DiscountsV2:InvalidDiscountAction',
      /**
       * Action {0:string} cannot be used as currency independent.
       */
      ActionCannotBeUsedAsCurrencyIndependent = 'DiscountsV2:ActionCannotBeUsedAsCurrencyIndependent',
      /**
       * The DiscountAction {0:string} is not allowed for discount trigger {1:string}.
       */
      ActionNotEnabledForTriggerType = 'DiscountsV2:ActionNotEnabledForTriggerType',
      /**
       * Action data for discount {0:number} is not initialized properly.
       */
      ActionDataNotInitialized = 'DiscountsV2:ActionDataNotInitialized',
      /**
       * Discount action type can not be updated when discount is used.
       */
      ActionTypeCanNotBeChangedWhenDiscountIsUsed = 'DiscountsV2:ActionTypeCanNotBeChangedWhenDiscountIsUsed',
      /**
       * Discount cannot be applied because order {0:number} is already invoiced.
       */
      OrderIsAlreadyInvoiced = 'DiscountsV2:OrderIsAlreadyInvoiced',
      /**
       * Discount cannot be applied because order {0:number} is placed and `FreezeOrderAfterPlacement` is enabled.
       */
      OrderIsPlacedAndFreezeOrderAfterPlacementIsEnabled = 'DiscountsV2:OrderIsPlacedAndFreezeOrderAfterPlacementIsEnabled',
      /**
       * Discount cannot be applied because order {0:number} has IgnoreDiscounts enabled.
       */
      IgnoreDiscountsEnabled = 'DiscountsV2:IgnoreDiscountsEnabled',
      /**
       * Condition '{0:string}' is deprecated.
       */
      ConditionIsDeprecated = 'DiscountsV2:ConditionIsDeprecated',
      /**
       * Action '{0:string}' is deprecated.
       */
      ActionIsDeprecated = 'DiscountsV2:ActionIsDeprecated',
      /**
       * Action '{ActionType:string}' requires at least {X:number} occurences of the condition '{ConditionType:string}'.
       */
      ActionRequiresTheConditionAtLeastXTimes = 'DiscountsV2:ActionRequiresTheConditionAtLeastXTimes',
      /**
       * Action '{ActionType:string}' allows a maximum of {X:number} occurences of the condition '{ConditionType:string}'.
       */
      ActionAllowsTheConditionForAMaximumOfXTimes = 'DiscountsV2:ActionAllowsTheConditionForAMaximumOfXTimes',
      /**
       * Action '{ActionType:string}' can not be combined with condition type '{ConditionType:string}'.
       */
      ActionDoesNotAllowConditions = 'DiscountsV2:ActionDoesNotAllowConditions',
      /**
       * Action '{0:string}' can not be applied to a particular line.
       */
      ActionDoesNotAllowLineLevelDiscount = 'DiscountsV2:ActionDoesNotAllowLineLevelDiscount',
      /**
       * The value of property {0:string} is missing
       */
      MissingValue = 'DiscountsV2:MissingValue',
      /**
       * The value of property {0:string} is cannot be fractional.
       */
      FractionalPercentageNotSupported = 'DiscountsV2:FractionalPercentageNotSupported',
      /**
       * At least one of the following values is required: {0:string}
       */
      RequiresAtLeastOneOfTheFollowingValues = 'DiscountsV2:RequiresAtLeastOneOfTheFollowingValues',
      /**
       * The value of property {0:string} must be higher then 0.
       */
      ValueCannotBeNegativeOrZero = 'DiscountsV2:ValueCannotBeNegativeOrZero',
      /**
       * The value of property {0:string} must be higher then or equals to 0.
       */
      ValueCannotBeNegative = 'DiscountsV2:ValueCannotBeNegative',
      /**
       * The value of property {PropertyName:string} must be between {1:number} and {2:number}.
       */
      IntValueMustBeBetweenXAndY = 'DiscountsV2:IntValueMustBeBetweenXAndY',
      /**
       * Value of property {PropertyNameX:string} must be equal to or larger then property {PropertyNameY:string}
       */
      ValueOfXMustBeLargerThenOrEqualToValueOfY = 'DiscountsV2:ValueOfXMustBeLargerThenOrEqualToValueOfY',
      /**
       * Value of property {PropertyNameX:string} must be larger then property {PropertyNameY:string}
       */
      ValueOfXMustBeLargerThenValueOfY = 'DiscountsV2:ValueOfXMustBeLargerThenValueOfY',
      /**
       * The date of property {0:string} is invalid.
       */
      InvalidDate = 'DiscountsV2:InvalidDate',
      /**
       * The value of property {PropertyName:string} must be between {1:string} and {2:string}.
       */
      DateValueMustBeBetweenXAndY = 'DiscountsV2:DateValueMustBeBetweenXAndY',
      /**
       * At least two tiers is required.
       */
      NoTiersGiven = 'DiscountsV2:NoTiersGiven',
      /**
       * Duplicate tier with value '{0:any}' detected.
       */
      DuplicateTiersGiven = 'DiscountsV2:DuplicateTiersGiven',
      /**
       * ProductSets in {0:string} can not be mixed. All ProductSets must be either including or exluding.
       */
      ProductSetsIncludingExcludingCanNotBeMixed = 'DiscountsV2:ProductSetsIncludingExcludingCanNotBeMixed',
      /**
       * No product sets are provided.
       */
      NoProductSetsGiven = 'DiscountsV2:NoProductSetsGiven',
      /**
       * At least one product set must be selected as the discountable product set.
       */
      NoDiscountableProductSetSelected = 'DiscountsV2:NoDiscountableProductSetSelected',
      /**
       * The value of property {PropertyName:string} in tier {TierNumber:number} is missing
       */
      TierMissingValue = 'DiscountsV2:TierMissingValue',
      /**
       * Tier {TierNumber:number} requires at least one of the following values: {PropertyNames:string}
       */
      TierRequiresAtLeastOneOfTheFollowingValues = 'DiscountsV2:TierRequiresAtLeastOneOfTheFollowingValues',
      /**
       * The value of property {PropertyName:string} in tier {TierNumber:number} must be higher then 0.
       */
      TierValueCannotBeNegativeOrZero = 'DiscountsV2:TierValueCannotBeNegativeOrZero',
      /**
       * The value of property {PropertyName:string} in tier {TierNumber:number} must be higher then or equals to 0.
       */
      TierValueCannotBeNegative = 'DiscountsV2:TierValueCannotBeNegative',
      /**
       * The value of property {PropertyName:string} in tier {TierNumber:number} must be between {2:number} and {3:number}.
       */
      TierValueMustBeBetweenXAndY = 'DiscountsV2:TierValueMustBeBetweenXAndY',
      /**
       * Product with ID {ID:number} in property {PropertyName:string} for tier {TierNumber:number} not found.
       */
      TierProductNotFound = 'DiscountsV2:TierProductNotFound',
      /**
       * All product sets must have a name.
       */
      AllProductsSetsRequireANameToBePresent = 'DiscountsV2:AllProductsSetsRequireANameToBePresent',
      /**
       * Product set {ProductSetName:string} requires at least one of the following values: {PropertyName:string}
       */
      ProductSetRequiresAtLeastOneOfTheFollowingValues = 'DiscountsV2:ProductSetRequiresAtLeastOneOfTheFollowingValues',
      /**
       * The value of product set property {PropertyName:string} in product set {ProductSetName:string} must be higher then 0.
       */
      ProductSetValueCannotBeNegativeOrZero = 'DiscountsV2:ProductSetValueCannotBeNegativeOrZero',
      /**
       * The value of product set property {PropertyName:string} in product set {ProductSetName:string} must be higher then or equals to 0.
       */
      ProductSetValueCannotBeNegative = 'DiscountsV2:ProductSetValueCannotBeNegative',
      /**
       * The value of product set property {PropertyNameX:string} in product set {ProductSetName:string} must be higher then or equals to property {PropertyNameY:string}.
       */
      ProductSetValueOfXMustBeLargerThenOrEqualToValueOfY = 'DiscountsV2:ProductSetValueOfXMustBeLargerThenOrEqualToValueOfY',
      /**
       * The product set {ProductSetName:string} requires a connected loyalty program when property {PropertyName:string} is set.
       */
      ProductSetUseLoyaltyProgramProductsRequiresALoyaltyProgram = 'DiscountsV2:ProductSetUseLoyaltyProgramProductsRequiresALoyaltyProgram',
      /**
       * Product set {0:string} did not resolve to a valid list of products.
       */
      ProductSetDidNotResolveToAListOfValidProducts = 'DiscountsV2:ProductSetDidNotResolveToAListOfValidProducts',
      /**
       * Product set {0:string} product requirement values must be present.
       */
      ProductSetProductRequirementValuesMustBePresent = 'DiscountsV2:ProductSetProductRequirementValuesMustBePresent',
      /**
       * Product set properties ProductsIDs, ProductSearchID, Filters, PersonalizedPromotionID and UseLoyaltyProgramProducts cannot be combined in product sets.
       */
      ProductSetPropertiesAreMutuallyExclusive = 'DiscountsV2:ProductSetPropertiesAreMutuallyExclusive',
      /**
       * A productset price filter requires a valid from/to value.
       */
      ProductSetPriceFilterRequiresAValidFromOrToValue = 'DiscountsV2:ProductSetPriceFilterRequiresAValidFromOrToValue',
      /**
       * The value {ID:number} of property {PropertyName:string} is an invalid {ObjectName:string} ID.
       */
      InvalidID = 'DiscountsV2:InvalidID',
      /**
       * Product {0:number} is not found
       */
      ProductNotFound = 'DiscountsV2:ProductNotFound',
      /**
       * Product {0:number} has an invalid type for GetAProductAction: {1:ProductTypes}.
       */
      ProductInvalidType = 'DiscountsV2:ProductInvalidType',
      /**
       * The provided stocklabel {0:number} could not be found.
       */
      InvalidStockLabel = 'DiscountsV2:InvalidStockLabel',
      /**
       * The orderlinetype should be ShippingCosts, ReturnCosts or GiftWrappingCosts.
       */
      InvalidLineType = 'DiscountsV2:InvalidLineType',
      /**
       * The coupon handler {0:string} is unknown.
       */
      UnknownCouponHandler = 'DiscountsV2:UnknownCouponHandler',
      /**
       * The discount to be applied for the generated coupon is invalid.
       */
      InvalidPostponedDiscount = 'DiscountsV2:InvalidPostponedDiscount',
      /**
       * The coupon distribution handler is missing.
       */
      CouponDistributionHandlerMissing = 'DiscountsV2:CouponDistributionHandlerMissing',
      /**
       * The coupon distribution handler '{0:string}' is invalid.
       */
      InvalidCouponDistributionHandler = 'DiscountsV2:InvalidCouponDistributionHandler',
      /**
       * The given RestitutionOrganizationUnit is invalid. OrganizationUnit needs to exist and typed as DiscountRestitutionOrganizationUnit.
       */
      InvalidRestitutionOrganizationUnit = 'DiscountsV2:InvalidRestitutionOrganizationUnit',
      /**
       * Action does not allow excluding product filters on discountable product sets
       */
      ActionDoesNotAllowExcludingProductFiltersOnDiscountableProductSets = 'DiscountsV2:ActionDoesNotAllowExcludingProductFiltersOnDiscountableProductSets',
      /**
       * StringFilter {0:string} must have a value to compare.
       */
      StringFilterMustHaveAValue = 'DiscountsV2:StringFilterMustHaveAValue',
      /**
       * Invalid user usage reload strategy `{0:string}`.
       */
      InvalidUserUsageReloadStrategy = 'DiscountsV2:InvalidUserUsageReloadStrategy',
      /**
       * A discount of trigger type `{0:string}` cannot be combined with (custom)UserUsageLimit.
       */
      TriggertypeCannotBeCombinedWithUserUsageLimit = 'DiscountsV2:TriggertypeCannotBeCombinedWithUserUsageLimit',
      /**
       * A discount of trigger type `{0:string}` cannot have other conditions.
       */
      TriggertypeDoesNotAllowForConditions = 'DiscountsV2:TriggertypeDoesNotAllowForConditions',
      /**
       * Cannot apply discount to orderline {0:number}.
       */
      InvalidOrderLineForDiscount = 'DiscountsV2:InvalidOrderLineForDiscount',
      /**
       * OrderLine {0:number} does not support discount product pick selection.
       */
      InvalidOrderLineForProductPicking = 'DiscountsV2:InvalidOrderLineForProductPicking',
      /**
       * Invalid product for product picking.
       */
      InvalidProductForProductPicking = 'DiscountsV2:InvalidProductForProductPicking',
      /**
       * Action '{0:string}' Cannot Be Used In Currency Independend Discount.
       */
      ActionCannotBeUsedInCurrencyIndependendDiscount = 'DiscountsV2:ActionCannotBeUsedInCurrencyIndependendDiscount',
      /**
       * Action '{0:string}' can not be used on currency independend discount.
       */
      ValueCannotBeUsedAsAmountWhenDiscountIsCurrencyIndependent = 'DiscountsV2:ValueCannotBeUsedAsAmountWhenDiscountIsCurrencyIndependent',
      /**
       * Property '{PropertyName:string}' is not allowed for action '{ActionType:string}' when discount is currency independend.
       */
      ActionPropertyNotAllowedWhenDiscountIsCurrencyIndependend = 'DiscountsV2:ActionPropertyNotAllowedWhenDiscountIsCurrencyIndependend',
      /**
       * Property '{0:string}' is not allowed when discount is currency independend.
       */
      PropertyNotAllowedWhenDiscountIsCurrencyIndependend = 'DiscountsV2:PropertyNotAllowedWhenDiscountIsCurrencyIndependend',
      /**
       * Loyalty program is required when discount trigger is 'Loyalty'
       */
      LoyaltyProgramRequired = 'DiscountsV2:LoyaltyProgramRequired',
      /**
       * The given loyalty program is unknown
       */
      UnknowLoyaltyProgram = 'DiscountsV2:UnknowLoyaltyProgram',
      /**
       * Only EVA loyalty handler can be used
       */
      OnlyEVALoyaltyHandlerCanBeUsed = 'DiscountsV2:OnlyEVALoyaltyHandlerCanBeUsed',
      /**
       * Product subscription is required when discount trigger is 'ProductSubscription'
       */
      ProductSubscriptionRequired = 'DiscountsV2:ProductSubscriptionRequired',
      /**
       * The given product subscription is unknown
       */
      UnknowProductSubscription = 'DiscountsV2:UnknowProductSubscription',
      /**
       * Either `Data` or `BlobID` is required for upload.
       */
      EitherDataOrBlobIDIsRequired = 'DiscountsV2:EitherDataOrBlobIDIsRequired',
      /**
       * Non async processing only accepts `Data`.
       */
      NonAsyncProcessingOnlyAcceptsData = 'DiscountsV2:NonAsyncProcessingOnlyAcceptsData',
      /**
       * Async processing only accepts `BlobID`.
       */
      AsyncProcessingOnlyAcceptsBlobID = 'DiscountsV2:AsyncProcessingOnlyAcceptsBlobID',
      /**
       * Invalid custom field type `{0:number}`.
       */
      InvalidCustomFieldType = 'DiscountsV2:InvalidCustomFieldType',
      /**
       * Required custom fields are not supported for discount trigger `{0:DiscountTriggers}`.
       */
      RequiredCustomFieldsAreNotSupportedForDiscountTrigger = 'DiscountsV2:RequiredCustomFieldsAreNotSupportedForDiscountTrigger',
      /**
       * Custom field type `{0:number}` cannot be required on discount that applies to `{1:DiscountAppliesTo}`.
       */
      DiscountApplyToMismatchOnCustomFieldType = 'DiscountsV2:DiscountApplyToMismatchOnCustomFieldType',
      /**
       * Age cannot be used as amount when discount is currency independent.
       */
      AgeCannotBeUsedAsAmountWhenDiscountIsCurrencyIndependent = 'DiscountsV2:AgeCannotBeUsedAsAmountWhenDiscountIsCurrencyIndependent',
      /**
       * Tier value cannot be used as amount when discount is currency independent.
       */
      TierValueCannotBeUsedAsAmountWhenDiscountIsCurrencyIndependent = 'DiscountsV2:TierValueCannotBeUsedAsAmountWhenDiscountIsCurrencyIndependent'
    }

    export const enum PurchaseOrders {
      /**
       * Expecting UnitPrice to be greater than 0
       */
      UnitPriceNeedsToBeGreaterThenZero = 'PurchaseOrders:UnitPriceNeedsToBeGreaterThenZero',
      /**
       * Pruchase order already has a line with the same ProductID and StockLabel.
       */
      PurchaseOrderAlreadyHasALineWithTheSameProductAndStockLabelID = 'PurchaseOrders:PurchaseOrderAlreadyHasALineWithTheSameProductAndStockLabelID'
    }

    export const enum CustomFieldFilterErrors {
      /**
       * No fields given to validate filter
       */
      NoFieldsGivenToValidateFilter = 'CustomFieldFilterErrors:NoFieldsGivenToValidateFilter',
      /**
       * Invalid custom field value given
       */
      InvalidCustomFieldValueGiven = 'CustomFieldFilterErrors:InvalidCustomFieldValueGiven',
      /**
       * Filter validate failed because there are not custom fields of type {0:string}
       */
      CouldNotValidateFilterWhenNoCustomFieldsAreSetToCustomFieldTypeX = 'CustomFieldFilterErrors:CouldNotValidateFilterWhenNoCustomFieldsAreSetToCustomFieldTypeX',
      /**
       * Custom field {0:number} in filter is unknown.
       */
      InvalidCustomFieldInFilter = 'CustomFieldFilterErrors:InvalidCustomFieldInFilter',
      /**
       * Customfield {0:number} is an array valued field which only supports the `Contains` and `DoesNotContain` operators
       */
      InvalidArrayValueOperator = 'CustomFieldFilterErrors:InvalidArrayValueOperator',
      /**
       * Customfield {CustomFieldId:number} of type {DataType:string} does not support the operator {Operator:string}
       */
      InvalidValueOperator = 'CustomFieldFilterErrors:InvalidValueOperator'
    }

    export const enum Cultures {
      /**
       * This country already exists for this OrganizationUnit
       */
      CountryAlreadyExists = 'Cultures:CountryAlreadyExists'
    }

    export const enum Stock {
      /**
       * Not enough stock available for product {0:number}.
       */
      InsufficientStock = 'Stock:InsufficientStock',
      /**
       * Not enough stock available for product {0:number}.
       */
      InsufficientStockForCommit = 'Stock:InsufficientStockForCommit'
    }

    export const enum StockMutationReason {
      /**
       * Duplicate name or backendID.
       */
      DuplicateReason = 'StockMutationReason:DuplicateReason',
      /**
       * Cannot delete internal stock mutation reason.
       */
      InternalReason = 'StockMutationReason:InternalReason'
    }

    export const enum Products {
      /**
       * Product {duplicateProductID:number} already uses BackendID {backendID:string} and BackendID must be unique per catalog.
       */
      DuplicateBackendID = 'Products:DuplicateBackendID',
      /**
       * Cannot copy product of this type.
       */
      CannotCopyProductOfThisType = 'Products:CannotCopyProductOfThisType',
      /**
       * Can't identify product. Serial number or Orderline ID is missing or Orderline does not contain serial number.
       */
      CannotIdentifyProduct = 'Products:CannotIdentifyProduct'
    }

    export const enum TaxRates {
      /**
       * There is no TaxRate for TaxCode {taxCodeName:string} in country {countryID:string} / {countrySubdivisionID:string}.
       */
      NotFoundForTaxCode = 'TaxRates:NotFoundForTaxCode',
      /**
       * There is no TaxRate for Product {productID:number} in country {countryID:string} / {countrySubdivisionID:string}.
       */
      NotFoundForProduct = 'TaxRates:NotFoundForProduct',
      /**
       * There is no TaxRate for Rate {taxRate:number} in country {countryID:string} / {countrySubdivisionID:string}.
       */
      NotFoundForTaxRate = 'TaxRates:NotFoundForTaxRate',
      /**
       * Cannot create a tax rate for tax code {0:string} without specifying a TaxRateCategory.
       */
      CategoryIsRequired = 'TaxRates:CategoryIsRequired'
    }

    export const enum ReturnOrders {
      /**
       * Not allowed to add lines of an extax order to an intax order and vice versa.
       */
      CannotCreateReturnLinesWithDifferentTaxHandling = 'ReturnOrders:CannotCreateReturnLinesWithDifferentTaxHandling',
      /**
       * Not allowed to return invalid order line {ID:number} ({reason:string})
       */
      CannotCreateReturnOrderWithInvalidLines = 'ReturnOrders:CannotCreateReturnOrderWithInvalidLines',
      /**
       * Can't return orderline {0:number} because the original orderline can not be found.
       */
      CannotReturnLineWithInvalidOriginalLine = 'ReturnOrders:CannotReturnLineWithInvalidOriginalLine',
      /**
       * Can't return orderline {returnOrderLineID:number} because the original orderline ({originalOrderLineID:number}) is not returnable.
       */
      CannotReturnNonReturnableLine = 'ReturnOrders:CannotReturnNonReturnableLine',
      /**
       * Can't send invoices when the original order has no customer or when no customer is provided for unreferenced returns.
       */
      CannotSendInvoiceWithoutCustomer = 'ReturnOrders:CannotSendInvoiceWithoutCustomer',
      /**
       * Unreferenced return reversals are not allowed.
       */
      CannotCreateUnreferencedReturnReversals = 'ReturnOrders:CannotCreateUnreferencedReturnReversals',
      /**
       * The return reason {0:number} requires a remark.
       */
      RemarkRequired = 'ReturnOrders:RemarkRequired'
    }

    export const enum ReturnReason {
      /**
       * Return reason {0:number} requires a remark.
       */
      RemarkRequired = 'ReturnReason:RemarkRequired',
      /**
       * Return reason {0:number} doesn't exist.
       */
      ReasonNotFound = 'ReturnReason:ReasonNotFound',
      /**
       * Return reason {0:number} doesn't exist.
       */
      ReasonTypeMismatch = 'ReturnReason:ReasonTypeMismatch'
    }

    export const enum Countries {
      /**
       * Subdivision doesn't match the selected country.
       */
      InvalidSubdivision = 'Countries:InvalidSubdivision'
    }

    export const enum Companies {
      /**
       * VAT Number is already in use.
       */
      VatNumberAlreadyInUse = 'Companies:VatNumberAlreadyInUse',
      /**
       * Backend ID is already in use.
       */
      BackendIDAlreadyInUse = 'Companies:BackendIDAlreadyInUse',
      /**
       * Company is still attached to some organization unit(s). Please detach those first before proceeding.
       */
      CannotDeleteCompanyWithRelatedOrganizationUnits = 'Companies:CannotDeleteCompanyWithRelatedOrganizationUnits',
      /**
       * Company {0:number} does not have the required type {1:CompanyType}.
       */
      CompanyHasInvalidType = 'Companies:CompanyHasInvalidType'
    }

    export const enum Company {
      /**
       * It is not allowed to modify the registration number with closed transactions
       */
      ModifyRegistrationNumberNotAllowed = 'Company:ModifyRegistrationNumberNotAllowed',
      /**
       * It is not allowed to modify the vat number with closed transactions
       */
      ModifyVatNumberNotAllowed = 'Company:ModifyVatNumberNotAllowed',
      /**
       * Push companies limit exceeded.
       */
      PushCompaniesLimitExceeded = 'Company:PushCompaniesLimitExceeded',
      /**
       * Unknown error while pushing company with BackendID `{0:string}`
       */
      UnknownPushCompanyError = 'Company:UnknownPushCompanyError',
      /**
       * Invalid user for consumer company.
       */
      InvalidUserForConsumerCompany = 'Company:InvalidUserForConsumerCompany',
      /**
       * Property '{0:string}' is required.
       */
      PropertyIsRequired = 'Company:PropertyIsRequired',
      /**
       * Property '{0:string}' does not match regex pattern.
       */
      PropertyDoesNotMatchRegexPattern = 'Company:PropertyDoesNotMatchRegexPattern',
      /**
       * Property '{0:string}' must have a minimum length of {1:number} characters.
       */
      PropertyMinLength = 'Company:PropertyMinLength',
      /**
       * Property '{0:string}' must have a maximum length of {1:number} characters.
       */
      PropertyMaxLength = 'Company:PropertyMaxLength',
      /**
       * The company must have a name.
       */
      NameRequired = 'Company:NameRequired'
    }

    export const enum Offers {
      /**
       * Offers cannot be shipped.
       */
      ShipmentsNotAllowed = 'Offers:ShipmentsNotAllowed',
      /**
       * Offers cannot have payments.
       */
      PaymentsNotAllowed = 'Offers:PaymentsNotAllowed',
      /**
       * Offers cannot be invoiced, yet.
       */
      InvoicesNotSupportedYet = 'Offers:InvoicesNotSupportedYet',
      /**
       * This offer requires a customer based on configured settings.
       */
      OfferRequiresCustomer = 'Offers:OfferRequiresCustomer',
      /**
       * Expired Offers cannot be mutated.
       */
      Expired = 'Offers:Expired',
      /**
       * Order {0:number} cannot be changed, changing an offer is not allowed.
       */
      Unchangeable = 'Offers:Unchangeable'
    }

    export const enum OpeningHoursTemplateExcelUpload {
      /**
       * [row {0:number}, column {1:string}]: Status must be either 'Open' or 'Closed'
       */
      NoValidStatusProvided = 'OpeningHoursTemplateExcelUpload:NoValidStatusProvided',
      /**
       * [row {0:number}, column {1:string}]: Date must be after today
       */
      InvalidDateProvided = 'OpeningHoursTemplateExcelUpload:InvalidDateProvided',
      /**
       * [row {0:number}, column {1:string}]: From and To must be set if status is 'Open'
       */
      NoOpeningHoursProvided = 'OpeningHoursTemplateExcelUpload:NoOpeningHoursProvided',
      /**
       * [row {0:number}, column {1:string}]: From and To must not be set if status is 'Closed'
       */
      NoOpeningHoursAllowedIfStatusIsClosed = 'OpeningHoursTemplateExcelUpload:NoOpeningHoursAllowedIfStatusIsClosed',
      /**
       * [row {0:number}, column {1:string}]: The hour of opening must be before the hour of closing
       */
      InvalidOpeningHoursProvided = 'OpeningHoursTemplateExcelUpload:InvalidOpeningHoursProvided',
      /**
       * [row {0:number}, column {1:string}]: Multiple time slots on the same day cannot overlap each other
       */
      OverlappingTimeSlots = 'OpeningHoursTemplateExcelUpload:OverlappingTimeSlots',
      /**
       * Multiple rows have been provided with Date '{0:string}'. Please only provide one row per date
       */
      MultipleRowsWithSameDate = 'OpeningHoursTemplateExcelUpload:MultipleRowsWithSameDate'
    }

    export const enum Assortments {
      /**
       * It's not possible to delete the default Assortment.
       */
      CannotDeleteDefault = 'Assortments:CannotDeleteDefault'
    }

    export const enum AssortmentProducts {
      /**
       * When adding products to an assortment, either Products or Query needs to have a value.
       */
      NoProductsSpecified = 'AssortmentProducts:NoProductsSpecified',
      /**
       * It's not possible to remove products from the default assortment.
       */
      CannotRemoveProductsFromDefaultAssortment = 'AssortmentProducts:CannotRemoveProductsFromDefaultAssortment',
      /**
       * Invalid AssortmentProduct date sequence: {0:string} (value: {1:string}) cannot be after {2:string} (value: {3:string}).
       */
      PreorderDatesOutOfOrder = 'AssortmentProducts:PreorderDatesOutOfOrder'
    }

    export const enum ProductRelation {
      /**
       * ProductRelationType of type `Group` cannot have a StockRelationType.
       */
      ProductRelationTypeOfTypeGroupCannotHaveAStockRelationType = 'ProductRelation:ProductRelationTypeOfTypeGroupCannotHaveAStockRelationType',
      /**
       * Only ProductRelationType `Group` or types with the DynamicRelationProductID set accept a ProductSearchTemplateID or ProductSearchFilters.
       */
      DynamicRelationTypeOnlyAllowedForGroupOrWhenDynamicRelationProductIDIsSet = 'ProductRelation:DynamicRelationTypeOnlyAllowedForGroupOrWhenDynamicRelationProductIDIsSet',
      /**
       * Cannot add static relation to a dynamic relationtype
       */
      CannotCreateStaticRelationOnADynamicRelationType = 'ProductRelation:CannotCreateStaticRelationOnADynamicRelationType',
      /**
       * Product cannot have a relation with itself
       */
      ProductCannotHaveARelationWithItself = 'ProductRelation:ProductCannotHaveARelationWithItself',
      /**
       * Uni- or bidirectional relations require a primary and related product ID
       */
      UniOrBidirectionalRelationsRequireAPrimaryAndRelatedProductID = 'ProductRelation:UniOrBidirectionalRelationsRequireAPrimaryAndRelatedProductID',
      /**
       * A unidirectional relation already exists from product {relatedProductID:number} to product {primaryProductID:number}. Can not register a unidirectional relation from {primaryProductID:number} to {relatedProductID:number} on the same relation type.
       */
      UnidirectionalRelationAlreadyExistsFromRelatedProduct = 'ProductRelation:UnidirectionalRelationAlreadyExistsFromRelatedProduct',
      /**
       * Product relation not found with primary product '{primaryProductID:number}' and related product '{relatedProductID:number}'.
       */
      ProductRelationNotFound = 'ProductRelation:ProductRelationNotFound',
      /**
       * There are no product relations for type the given product relation type '{0:number}'.
       */
      NoProductRelationsForGivenType = 'ProductRelation:NoProductRelationsForGivenType',
      /**
       * Filters are required for a dynamic product relation type with uni or bi directional
       */
      DynamicUniOrBiDirectionalRelationTypesRequireAProductFilter = 'ProductRelation:DynamicUniOrBiDirectionalRelationTypesRequireAProductFilter',
      /**
       * DynamicRelationProductID required for a dynamic product relation type with uni or bi directional
       */
      DynamicUniOrBiDirectionalRelationTypesRequireADynamicRelationProductID = 'ProductRelation:DynamicUniOrBiDirectionalRelationTypesRequireADynamicRelationProductID',
      /**
       * Cannot convert product relation from static to dynamic
       */
      CannotConvertProductRelationFromStaticToDynamic = 'ProductRelation:CannotConvertProductRelationFromStaticToDynamic',
      /**
       * Cannot change second chance relation type.
       */
      CannotChangeSecondChanceRelationType = 'ProductRelation:CannotChangeSecondChanceRelationType'
    }

    export const enum Inquiries {
      /**
       * The type for custom field {customFieldId:number} should by User, got {type:string}
       */
      InvalidType = 'Inquiries:InvalidType',
      /**
       * Items should point to unique custom fields.
       */
      CustomFieldsShouldBeUnique = 'Inquiries:CustomFieldsShouldBeUnique'
    }

    export const enum Inquiry {
      /**
       * Inquire can only be filled in once.
       */
      InquireCanOnlyBeFilledInOnce = 'Inquiry:InquireCanOnlyBeFilledInOnce',
      /**
       * You cannot submit duplicate inquire items.
       */
      DuplicateInquireItemSubmitted = 'Inquiry:DuplicateInquireItemSubmitted',
      /**
       * Missing the following required inquiry item(s): {0:string}.
       */
      MissingRequiredInquiryItems = 'Inquiry:MissingRequiredInquiryItems'
    }

    export const enum CaseStatus {
      /**
       * Name '{0:string}' already exists.
       */
      StatusNameAlreadyExists = 'CaseStatus:StatusNameAlreadyExists',
      /**
       * Script is not valid.
       */
      ScriptIsNotAValid = 'CaseStatus:ScriptIsNotAValid',
      /**
       * The name of internal case status '{0:string}' cannot be modified.
       */
      NameOfInternalStatusCannotBeModified = 'CaseStatus:NameOfInternalStatusCannotBeModified',
      /**
       * Internal case status '{0:string}' cannot be deleted.
       */
      InternalStatusCannotBeDeleted = 'CaseStatus:InternalStatusCannotBeDeleted'
    }

    export const enum CaseTopic {
      /**
       * Name '{0:string}' already exists.
       */
      TopicNameAlreadyExists = 'CaseTopic:TopicNameAlreadyExists',
      /**
       * Can not filter on both RootOnly and ParentID, please provide only one.
       */
      CanNotFilterOnBothRootOnlyAndParent = 'CaseTopic:CanNotFilterOnBothRootOnlyAndParent'
    }

    export const enum CaseInteraction {
      /**
       * Can only update own interactions.
       */
      CanOnlyUpdateOwnInteraction = 'CaseInteraction:CanOnlyUpdateOwnInteraction',
      /**
       * Can only delete own interactions.
       */
      CanOnlyDeleteOwnInteraction = 'CaseInteraction:CanOnlyDeleteOwnInteraction'
    }

    export const enum Case {
      /**
       * Case already closed.
       */
      CaseAlreadyClosed = 'Case:CaseAlreadyClosed',
      /**
       * Can only archive closed cases.
       */
      CanOnlyArchiveClosedCases = 'Case:CanOnlyArchiveClosedCases',
      /**
       * Cannot update title and description of customer created case.
       */
      CannotUpdateTitleAndDescriptionOfCustomerCreatedCase = 'Case:CannotUpdateTitleAndDescriptionOfCustomerCreatedCase',
      /**
       * Cannot update title or description after assignment.
       */
      CannotUpdateTitleOrDescriptionAfterAssignment = 'Case:CannotUpdateTitleOrDescriptionAfterAssignment',
      /**
       * Can only update case title and description of own cases.
       */
      CanOnlyUpdateCaseTitleAndDescriptionOfOwnCases = 'Case:CanOnlyUpdateCaseTitleAndDescriptionOfOwnCases',
      /**
       * Assignee is invalid user type to assign to case.
       */
      AssigneeIsInvalidUserTypeToAssignToCase = 'Case:AssigneeIsInvalidUserTypeToAssignToCase',
      /**
       * Related orderline does not match related order.
       */
      RelatedOrderLineDoesNotMatchRelatedOrder = 'Case:RelatedOrderLineDoesNotMatchRelatedOrder',
      /**
       * Can only set warranty on products.
       */
      CanOnlySetWarrantyOnProducts = 'Case:CanOnlySetWarrantyOnProducts',
      /**
       * Cannot revert case status to `new` status.
       */
      CannotRevertCaseStatusToNewStatus = 'Case:CannotRevertCaseStatusToNewStatus',
      /**
       * Either an OrderLineID or ProductID is required for case related items.
       */
      EitherOrderLineIDOrProductIDIsRequired = 'Case:EitherOrderLineIDOrProductIDIsRequired',
      /**
       * Cannot update originating organization unit after it is set.
       */
      CannotUpdateOriginatingOrganizationUnit = 'Case:CannotUpdateOriginatingOrganizationUnit',
      /**
       * The case with BackendID `{0:string}` already exists.
       */
      CaseWithBackendIDAlreadyExists = 'Case:CaseWithBackendIDAlreadyExists',
      /**
       * CaseTopics are required for Cases.
       */
      CaseTopicIsRequiredForCase = 'Case:CaseTopicIsRequiredForCase'
    }

    export const enum PushCase {
      /**
       * Pushed topic '{0:string}' is unknown.
       */
      UnknownPushedTopic = 'PushCase:UnknownPushedTopic',
      /**
       * No CaseTopic was found for the given BackendID, but no Name was provided either. Please provide a Name to be able to find the CaseTopic by the Name and Parent.
       */
      NameIsRequiredIfBackendIDIsNotFound = 'PushCase:NameIsRequiredIfBackendIDIsNotFound',
      /**
       * There are more than 1 CaseTopics with name `{0:string}`, please use the new field `CaseTopic` and specify the BackendID.
       */
      MultipleOptionsForCaseTopicName = 'PushCase:MultipleOptionsForCaseTopicName',
      /**
       * Pushed status '{0:string}' is unknown.
       */
      UnknownPushedStatus = 'PushCase:UnknownPushedStatus',
      /**
       * Invalid product backend ID for case related item.
       */
      InvalidProductBackendID = 'PushCase:InvalidProductBackendID'
    }

    export const enum Script {
      /**
       * Script {0:number} is unknown.
       */
      UnknownScript = 'Script:UnknownScript',
      /**
       * Script type `{givenType:string}` is invalid. Expected script of type `{expectedType:string}`.
       */
      InvalidScriptType = 'Script:InvalidScriptType',
      /**
       * Dialect {0:string} is not a recognized dialect
       */
      UnknownDialect = 'Script:UnknownDialect',
      /**
       * No proposal exists for script {0:number}
       */
      NoProposalExists = 'Script:NoProposalExists',
      /**
       * You cannot approve your own proposal for script {0:number}
       */
      SelfApprovalNotAllowed = 'Script:SelfApprovalNotAllowed',
      /**
       * Compilation failed for the proposed edit for script {0:number}
       */
      ProposalCompilationFailed = 'Script:ProposalCompilationFailed',
      /**
       * The proposal data for script {0:number} is invalid.
       */
      InvalidProposalData = 'Script:InvalidProposalData'
    }

    export const enum UserRequirement {
      /**
       * Property `{0:string}` is not supported as an user requirement.
       */
      UnsupportedProperty = 'UserRequirement:UnsupportedProperty',
      /**
       * Can only set a script when the requirement is for a single action.
       */
      CanOnlySetScriptForSingleRequiredFor = 'UserRequirement:CanOnlySetScriptForSingleRequiredFor'
    }

    export const enum LoyaltyProgramPayment {
      /**
       * Cannot use given payment type: {0:string}
       */
      CannotUseGivenPaymentType = 'LoyaltyProgramPayment:CannotUseGivenPaymentType',
      /**
       * Can only pay for fixed amount
       */
      CanOnlyPayForFixedAmount = 'LoyaltyProgramPayment:CanOnlyPayForFixedAmount',
      /**
       * Amount exceeds maximum allowed amount
       */
      AmountExceedsMaximumAllowedAmount = 'LoyaltyProgramPayment:AmountExceedsMaximumAllowedAmount',
      /**
       * Can only refund full amount
       */
      CannotRefundMoreThenOriginalAmount = 'LoyaltyProgramPayment:CannotRefundMoreThenOriginalAmount',
      /**
       * Payment requires preceding payment to be executed
       */
      PaymentRequiresPrecedingPaymentToBeExecuted = 'LoyaltyProgramPayment:PaymentRequiresPrecedingPaymentToBeExecuted'
    }

    export const enum ShippingRestriction {
      /**
       * Invalid ProductPropertyType, only types with a Boolean DataType are allowed.
       */
      InvalidProductPropertyType = 'ShippingRestriction:InvalidProductPropertyType',
      /**
       * Invalid script type.
       */
      InvalidScriptType = 'ShippingRestriction:InvalidScriptType',
      /**
       * OrganizationUnitID or OrganizationUnitSetID is required unless a leading script is provided.
       */
      OrganizationUnitOrSetRequired = 'ShippingRestriction:OrganizationUnitOrSetRequired',
      /**
       * CountryID is required unless a leading script is provided.
       */
      CountryRequired = 'ShippingRestriction:CountryRequired'
    }

    export const enum PersonalizedPromotion {
      /**
       * Value of property `{0:string}` must be higher than 0.
       */
      ValueMustBeGreaterThanZero = 'PersonalizedPromotion:ValueMustBeGreaterThanZero',
      /**
       * Value of property `{0:string}` must be unique.
       */
      ValueMustBeUnique = 'PersonalizedPromotion:ValueMustBeUnique',
      /**
       * No products are provided.
       */
      NoProductsGiven = 'PersonalizedPromotion:NoProductsGiven',
      /**
       * No available products.
       */
      NoAvailableProducts = 'PersonalizedPromotion:NoAvailableProducts',
      /**
       * Product '{0}' not available.
       */
      ProductNotAvailable = 'PersonalizedPromotion:ProductNotAvailable',
      /**
       * Maximum distinct products exceeded.
       */
      MaximumDistinctProductsExceeded = 'PersonalizedPromotion:MaximumDistinctProductsExceeded',
      /**
       * Personalized promotions is already applied.
       */
      AlreadyApplied = 'PersonalizedPromotion:AlreadyApplied'
    }

    export const enum ProductSet {
      /**
       * Product set {ProductSetName:string} requires at least one of the following values: {PropertyName:string}
       */
      ProductSetRequiresAtLeastOneOfTheFollowingValues = 'ProductSet:ProductSetRequiresAtLeastOneOfTheFollowingValues',
      /**
       * The value of product set property {PropertyName:string} in product set {ProductSetName:string} must be higher then 0.
       */
      ProductSetValueCannotBeNegativeOrZero = 'ProductSet:ProductSetValueCannotBeNegativeOrZero',
      /**
       * The value of product set property {PropertyName:string} in product set {ProductSetName:string} must be higher then or equals to 0.
       */
      ProductSetValueCannotBeNegative = 'ProductSet:ProductSetValueCannotBeNegative',
      /**
       * The value of product set property {PropertyNameX:string} in product set {ProductSetName:string} must be higher then or equals to property {PropertyNameY:string}.
       */
      ProductSetValueOfXMustBeLargerThenOrEqualToValueOfY = 'ProductSet:ProductSetValueOfXMustBeLargerThenOrEqualToValueOfY',
      /**
       * Product set {0:string} did not resolve to a valid list of products.
       */
      ProductSetDidNotResolveToAListOfValidProducts = 'ProductSet:ProductSetDidNotResolveToAListOfValidProducts',
      /**
       * A productset price filter requires a valid from/to value.
       */
      ProductSetPriceFilterRequiresAValidFromOrToValue = 'ProductSet:ProductSetPriceFilterRequiresAValidFromOrToValue'
    }

    export const enum AddressRequirement {
      /**
       * Property does not support predefined values.
       */
      PropertyDoesNotSupportPredefinedValues = 'AddressRequirement:PropertyDoesNotSupportPredefinedValues',
      /**
       * Property '{0:PropertyType}' cannot exceed a maximum length higher than '{1:number}'.
       */
      PropertyMaxLengthExceeded = 'AddressRequirement:PropertyMaxLengthExceeded',
      /**
       * Predefined value for property '{0:PropertyType}' cannot exceed the maximum length allowed.
       */
      PropertyPredefinedValueExceedsMaxLength = 'AddressRequirement:PropertyPredefinedValueExceedsMaxLength'
    }

    export const enum Address {
      /**
       * Invalid country subdivision.
       */
      InvalidCountrySubdivision = 'Address:InvalidCountrySubdivision'
    }

    export const enum CashHandlers {
      /**
       * MaxAmountPerOrder {0:number} needs to be rounded based on RoundingFactor. Try again using {1:number} or another rounded value.
       */
      IncorrectMaxAmountPerOrder = 'CashHandlers:IncorrectMaxAmountPerOrder'
    }

    export const enum EntityTranslations {
      /**
       * Cannot copy translations from an entity to itself.
       */
      CannotCopyToItself = 'EntityTranslations:CannotCopyToItself',
      /**
       * Entity `{0:string}` does not have any translations.
       */
      EntityDoesNotHaveTranslations = 'EntityTranslations:EntityDoesNotHaveTranslations'
    }

    export const enum OrderVerificationReason {
      /**
       * Name '{0:string}' already exists.
       */
      NameAlreadyExists = 'OrderVerificationReason:NameAlreadyExists',
      /**
       * Internal order verification reason '{0:string}' cannot be deleted.
       */
      InternalOrderVerificationReasonCannotBeDeleted = 'OrderVerificationReason:InternalOrderVerificationReasonCannotBeDeleted',
      /**
       * The name of internal order verification reason '{0:string}' cannot be modified.
       */
      NameOfInternalOrderVerificationReasonCannotBeModified = 'OrderVerificationReason:NameOfInternalOrderVerificationReasonCannotBeModified'
    }

    export const enum Surveys {
      /**
       * This is a system survey, it can't be managed.
       */
      SystemSurvey = 'Surveys:SystemSurvey',
      /**
       * Another survey with this BackendID already exists.
       */
      DuplicateBackendID = 'Surveys:DuplicateBackendID',
      /**
       * The trigger type `{0:string}` is unknown.
       */
      UnknownTriggerType = 'Surveys:UnknownTriggerType',
      /**
       * The distribution handler `{0:string}` is unknown.
       */
      UnknownDistributionHandler = 'Surveys:UnknownDistributionHandler',
      /**
       * The after effect type `{0:string}` is unknown.
       */
      UnknownAfterEffectType = 'Surveys:UnknownAfterEffectType',
      /**
       * Survey '{SurveyID:number}' is missing data for trigger '{TriggerType:string}'.
       */
      MissingTriggerData = 'Surveys:MissingTriggerData',
      /**
       * Survey '{SurveyID:number}' has invalid data for trigger '{TriggerType:string}'.
       */
      InvalidTriggerData = 'Surveys:InvalidTriggerData',
      /**
       * The date of property '{0:string}' is invalid.
       */
      InvalidDate = 'Surveys:InvalidDate',
      /**
       * Email addresses '{0:string}' are invalid.
       */
      InvalidEmailAddresses = 'Surveys:InvalidEmailAddresses',
      /**
       * Value of property '{PropertyNameX:string}' must be larger then property '{PropertyNameY:string}'
       */
      ValueOfXMustBeLargerThenValueOfY = 'Surveys:ValueOfXMustBeLargerThenValueOfY',
      /**
       * Cannot publish survey without questions.
       */
      CannotPublishSurveyWithoutQuestions = 'Surveys:CannotPublishSurveyWithoutQuestions',
      /**
       * All questions have routings pointing to them. One question needs to have no routings pointing to it to act as the first question.
       */
      AllQuestionsRoutedTo = 'Surveys:AllQuestionsRoutedTo',
      /**
       * Multiple questions without routings pointing to them. Only one question needs to have no routings pointing to it to act as the first question.
       */
      MultipleQuestionsNotRoutedTo = 'Surveys:MultipleQuestionsNotRoutedTo',
      /**
       * Unknown error while verifying survey with ID `{0:number}`
       */
      UnknownVerifySurveyError = 'Surveys:UnknownVerifySurveyError',
      /**
       * Question recursion detected; {0:string}.
       */
      PossibleLoopDetectedForQuestion = 'Surveys:PossibleLoopDetectedForQuestion',
      /**
       * Routed to non existing question within survey `{0:number}`.
       */
      RoutedToNonExistingQuestionWithinSurvey = 'Surveys:RoutedToNonExistingQuestionWithinSurvey',
      /**
       * Possible loop detected.
       */
      PossibleLoopDetected = 'Surveys:PossibleLoopDetected',
      /**
       * Cannot update taken survey.
       */
      CannotUpdateTakenSurvey = 'Surveys:CannotUpdateTakenSurvey',
      /**
       * Cannot update {0:string} for published survey.
       */
      CannotUpdatePropertyForPublishedSurvey = 'Surveys:CannotUpdatePropertyForPublishedSurvey',
      /**
       * Survey is being published
       */
      SurveyIsBeingPublished = 'Surveys:SurveyIsBeingPublished',
      /**
       * Survey doesn't have pending changes
       */
      SurveyDoesntHavePendingChanges = 'Surveys:SurveyDoesntHavePendingChanges',
      /**
       * Cannot start survey because it has not been published.
       */
      SurveyIsNotPublished = 'Surveys:SurveyIsNotPublished',
      /**
       * Question not part of survey.
       */
      QuestionNotPartOfSurvey = 'Surveys:QuestionNotPartOfSurvey',
      /**
       * An answer is required.
       */
      QuestionAnswerIsRequired = 'Surveys:QuestionAnswerIsRequired',
      /**
       * Survey is not started.
       */
      SurveyIsNotStarted = 'Surveys:SurveyIsNotStarted',
      /**
       * Survey requires context.
       */
      SurveyRequiresContext = 'Surveys:SurveyRequiresContext',
      /**
       * Automatic survey cannot be started manually.
       */
      AutomaticSurveyCannotBeStartedManually = 'Surveys:AutomaticSurveyCannotBeStartedManually',
      /**
       * Either Token or a SurveyID is required
       */
      EitherTokenOrSurveyIDRequired = 'Surveys:EitherTokenOrSurveyIDRequired',
      /**
       * Unknown survey response token
       */
      UnknownSurveyResponseToken = 'Surveys:UnknownSurveyResponseToken',
      /**
       * Answer is invalid
       */
      AnswerInvalid = 'Surveys:AnswerInvalid',
      /**
       * Survey response cancelled
       */
      SurveyResponseCancelled = 'Surveys:SurveyResponseCancelled',
      /**
       * Survey response completed
       */
      SurveyResponseCompleted = 'Surveys:SurveyResponseCompleted',
      /**
       * Survey expired
       */
      SurveyExpired = 'Surveys:SurveyExpired',
      /**
       * Survey not available.
       */
      SurveyNotAvailable = 'Surveys:SurveyNotAvailable',
      /**
       * Question not answered yet
       */
      QuestionNotAnsweredYet = 'Surveys:QuestionNotAnsweredYet',
      /**
       * System triggered survey cannot be started manually
       */
      SystemTriggeredSurveyCannotBeStartedManually = 'Surveys:SystemTriggeredSurveyCannotBeStartedManually',
      /**
       * The value of property '{PropertyName:string}' is missing for after effect type '{AfterEffectType:string}'
       */
      AfterEffectDataMissing = 'Surveys:AfterEffectDataMissing',
      /**
       * Invalid after effect type '{0:string}'
       */
      InvalidAfterEffect = 'Surveys:InvalidAfterEffect',
      /**
       * After efect '{0:string}' isn't available for given survey context.
       */
      AfterEffectNotAvailableForContext = 'Surveys:AfterEffectNotAvailableForContext',
      /**
       * Cannot distribute survey to customer
       */
      CannotDistributeSurveyToCustomer = 'Surveys:CannotDistributeSurveyToCustomer',
      /**
       * Only surveys triggered by system can be unbound from an OrganizationUnitSet.
       */
      OnlySystemSurveysCanBeUnbound = 'Surveys:OnlySystemSurveysCanBeUnbound'
    }

    export const enum SurveyQuestions {
      /**
       * Another survey question with this BackendID already exists.
       */
      DuplicateBackendID = 'SurveyQuestions:DuplicateBackendID',
      /**
       * Either ContextCustomField or question data is Required.
       */
      EitherContextCustomFieldOrQuestionDataIsRequired = 'SurveyQuestions:EitherContextCustomFieldOrQuestionDataIsRequired',
      /**
       * ContextCustomField and question data are mutually exclusive.
       */
      ContextCustomFieldAndQuestionDataAreMutuallyExclusive = 'SurveyQuestions:ContextCustomFieldAndQuestionDataAreMutuallyExclusive',
      /**
       * Custom field type is required to be of type 'User'.
       */
      InvalidCustomFieldType = 'SurveyQuestions:InvalidCustomFieldType',
      /**
       * Data type 'Enum' requires optional answers.
       */
      DataTypeEnumRequiresOptionalAnswers = 'SurveyQuestions:DataTypeEnumRequiresOptionalAnswers',
      /**
       * Optional answers require a non empty key and value.
       */
      EnumValuesRequireAKeyAndValue = 'SurveyQuestions:EnumValuesRequireAKeyAndValue',
      /**
       * Optional answer keys must be unique.
       */
      OptionalAnswerKeysMustBeUnique = 'SurveyQuestions:OptionalAnswerKeysMustBeUnique',
      /**
       * Optional answers are only allowed for datatype `Enum`.
       */
      OptionalAnswersAreOnlyAllowedForDataTypeEnum = 'SurveyQuestions:OptionalAnswersAreOnlyAllowedForDataTypeEnum',
      /**
       * Saving on customer requires a custom field.
       */
      SaveOnCustomerRequiresCustomField = 'SurveyQuestions:SaveOnCustomerRequiresCustomField',
      /**
       * The question cannot be added to a set belonging to a different survey.
       */
      QuestionSetBelongsToDifferentSurvey = 'SurveyQuestions:QuestionSetBelongsToDifferentSurvey',
      /**
       * All question routings are required for reordering.
       */
      AllQuestionRoutingsAreRequiredForReordering = 'SurveyQuestions:AllQuestionRoutingsAreRequiredForReordering',
      /**
       * Cannot switch question to other custom field after publish.
       */
      CannotSwitchQuestionToOtherCustomFieldAfterPublish = 'SurveyQuestions:CannotSwitchQuestionToOtherCustomFieldAfterPublish',
      /**
       * Question cannot be detached from custom field after creation.
       */
      QuestionCannotBeDetachedFromCustomFieldAfterCreation = 'SurveyQuestions:QuestionCannotBeDetachedFromCustomFieldAfterCreation',
      /**
       * Question cannot be attached to custom field after creation.
       */
      QuestionCannotBeAttachedToCustomFieldAfterCreation = 'SurveyQuestions:QuestionCannotBeAttachedToCustomFieldAfterCreation',
      /**
       * Cannot switch DataType after publish.
       */
      CannotSwitchDataTypeAfterPublish = 'SurveyQuestions:CannotSwitchDataTypeAfterPublish',
      /**
       * Cannot create multiple routes without filter.
       */
      CannotCreateMultipleRoutesWithoutFilter = 'SurveyQuestions:CannotCreateMultipleRoutesWithoutFilter',
      /**
       * Cannot add route to statement question.
       */
      CannotAddRouteToStatementQuestion = 'SurveyQuestions:CannotAddRouteToStatementQuestion',
      /**
       * Route should either have a `RouteToQuestionID` or exit remarks
       */
      RouteShouldEitherHaveARouteToQuestionIDOrExitRemarks = 'SurveyQuestions:RouteShouldEitherHaveARouteToQuestionIDOrExitRemarks'
    }

    export const enum CompanyRequirement {
      /**
       * Property '{0:CompanyRequirementPropertyType}' cannot exceed a maximum length higher than '{1:number}'.
       */
      PropertyMaxLengthExceeded = 'CompanyRequirement:PropertyMaxLengthExceeded',
      /**
       * There is already a requirement for property '{property:CompanyRequirementPropertyType}' on country '{countryID:string}' that applies to company type '{applyToCompanyType:ApplyToCompanyType}'.
       */
      DuplicateRequirement = 'CompanyRequirement:DuplicateRequirement'
    }

    export const enum EnvironmentInitialization {
      /**
       * Could not convert initialization state value in Redis to initialization state Enum.
       */
      InvalidEnvironmentInitializationState = 'EnvironmentInitialization:InvalidEnvironmentInitializationState',
      /**
       * Tried to set environment state to created but the environment state is already set.
       */
      EnvironmentStateAlreadySet = 'EnvironmentInitialization:EnvironmentStateAlreadySet',
      /**
       * Tried to set an already Initialized environment to Initialized.
       */
      EnvironmentAlreadyInitialized = 'EnvironmentInitialization:EnvironmentAlreadyInitialized',
      /**
       * The currency passed is not a valid option.
       */
      InvalidCurrencyPassed = 'EnvironmentInitialization:InvalidCurrencyPassed',
      /**
       * The country passed is not a valid option.
       */
      InvalidCountryPassed = 'EnvironmentInitialization:InvalidCountryPassed',
      /**
       * The language passed is not a valid option.
       */
      InvalidLanguagePassed = 'EnvironmentInitialization:InvalidLanguagePassed',
      /**
       * The e-mail passed is not a valid e-mail address.
       */
      InvalidEmailPassed = 'EnvironmentInitialization:InvalidEmailPassed'
    }

    export const enum EndpointConfiguration {
      /**
       * The provided endpoint is either invalid or is not secure
       */
      InvalidEndpoint = 'EndpointConfiguration:InvalidEndpoint',
      /**
       * Cannot change status to Error
       */
      CannotSetToError = 'EndpointConfiguration:CannotSetToError',
      /**
       * The provided config is invalid
       */
      InvalidConfig = 'EndpointConfiguration:InvalidConfig',
      /**
       * The key ID is invalid (should be either 1 or 2)
       */
      InvalidKeyID = 'EndpointConfiguration:InvalidKeyID',
      /**
       * The requested BackendID is already in use
       */
      DuplicateBackendID = 'EndpointConfiguration:DuplicateBackendID'
    }

    export const enum ConditionHandler {
      /**
       * Condition {ConditionName:string} (id {ConditionID:number}) for {ParentName:string} (id {ParentID:number}) was malformed or its build-up resulted in an exception.
       */
      InvalidCondition = 'ConditionHandler:InvalidCondition',
      /**
       * The data for condition {ConditionName:string} (id {ConditionID:number}) on {ParentName:string} (id {ParentID:number}) is not initialized properly.
       */
      ConditionDataNotInitialized = 'ConditionHandler:ConditionDataNotInitialized',
      /**
       * Condition {0:string} cannot be used as currency independent.
       */
      ConditionCannotBeUsedAsCurrencyIndependent = 'ConditionHandler:ConditionCannotBeUsedAsCurrencyIndependent'
    }

    export const enum CouponOriginatingOrderOrganizationUnitCondition {
      /**
       * Coupon can only be used on originating order organization unit.
       */
      CouponCanOnlyBeUsedOnOriginatingOrderOrganizationUnit = 'CouponOriginatingOrderOrganizationUnitCondition:CouponCanOnlyBeUsedOnOriginatingOrderOrganizationUnit'
    }

    export const enum CouponValidityCondition {
      /**
       * Invalid condition configuration. At least one of the properties must be set.
       */
      InvalidConditionConfiguration = 'CouponValidityCondition:InvalidConditionConfiguration',
      /**
       * Originating order does not this coupon registered.
       */
      OriginatingOrderHasntGotThisCouponRegistered = 'CouponValidityCondition:OriginatingOrderHasntGotThisCouponRegistered',
      /**
       * Coupon can only be used on originating order requested date, but the originating order does not have a requested date registered.
       */
      OriginatingOrderDoesntHaveARequestedDate = 'CouponValidityCondition:OriginatingOrderDoesntHaveARequestedDate',
      /**
       * Coupon is usable from {0:string}
       */
      CouponIsUsableFrom = 'CouponValidityCondition:CouponIsUsableFrom',
      /**
       * Coupon is usable on {0:string}
       */
      CouponIsUsableOn = 'CouponValidityCondition:CouponIsUsableOn',
      /**
       * Coupon was usable till {0:string}
       */
      CouponWasUsableTill = 'CouponValidityCondition:CouponWasUsableTill'
    }

    export const enum OldUserFieldConditionErrors {
      /**
       * No userfield's defined.
       */
      NoUserFieldDefined = 'OldUserFieldConditionErrors:NoUserFieldDefined',
      /**
       * Userfield {0:number} is unknown.
       */
      UnknownUserField = 'OldUserFieldConditionErrors:UnknownUserField',
      /**
       * User field {0:number} ({1:string}) has options and expects an integer value
       */
      UserFieldWithOptionsExpectsAnIntegerValue = 'OldUserFieldConditionErrors:UserFieldWithOptionsExpectsAnIntegerValue',
      /**
       * Option value {2:number} for user field {0:number} ({1:string}) is invalid
       */
      InvalidUserFieldOptionValue = 'OldUserFieldConditionErrors:InvalidUserFieldOptionValue'
    }

    export const enum DiscountGiftCardHandlerErrors {
      /**
       * Invalid discount to issue card for
       */
      InvalidDiscountToIssueCardFor = 'DiscountGiftCardHandlerErrors:InvalidDiscountToIssueCardFor'
    }

    export namespace Document {
      export namespace Printer {
        export const enum Factory {
          /**
           * Was unable to determine the correct organization unit for device #{0:number}
           */
          UnknownOrganizationUnit = 'Document:Printer:Factory:UnknownOrganizationUnit',
          /**
           * Do not have a printer implementation for type {0:string}
           */
          UnknownPrinterType = 'Document:Printer:Factory:UnknownPrinterType',
          /**
           * Address of device #{0:string} has not been configured
           */
          NotConfigured = 'Document:Printer:Factory:NotConfigured'
        }

      }

    }

    export const enum ReceiptPrinter {
      /**
       * Not allowed to print this invoice
       */
      NotAllowedToPrint = 'ReceiptPrinter:NotAllowedToPrint',
      /**
       * Not allowed to print more than 1 copy
       */
      NoMoreThanOneDuplicateAllowed = 'ReceiptPrinter:NoMoreThanOneDuplicateAllowed'
    }

    export const enum ReprintThermalPrintResult {
      /**
       * Blob {0:string} cannot be rendered as it is not a thermal print result.
       */
      InvalidBlob = 'ReprintThermalPrintResult:InvalidBlob'
    }

    export const enum ThermalPrinter {
      /**
       * Printing to device failed: {0:string}
       */
      DeviceFailure = 'ThermalPrinter:DeviceFailure',
      /**
       * Template {0:string} was not found.
       */
      TemplateNotFound = 'ThermalPrinter:TemplateNotFound',
      /**
       * Template {0:string} was not found or was disabled.
       */
      TemplateNotFoundOrDisabled = 'ThermalPrinter:TemplateNotFoundOrDisabled',
      /**
       * There is no paper present in device {0:string}.
       */
      NoPaper = 'ThermalPrinter:NoPaper',
      /**
       * Device {0:string} can't currently print as the cover is open.
       */
      CoverOpen = 'ThermalPrinter:CoverOpen',
      /**
       * Device {0:string} is reporting its status as offline.
       */
      Offline = 'ThermalPrinter:Offline'
    }

    export const enum OrderField {
      /**
       * Value {value:string} does not match type {type:CustomFieldDataTypes}
       */
      InvalidDataType = 'OrderField:InvalidDataType'
    }

    export const enum CustomFields {
      /**
       * CustomField {0:number} is unknown for the given type.
       */
      UnknownFieldForType = 'CustomFields:UnknownFieldForType',
      /**
       * CustomField {0:string} is unknown for the given type.
       */
      UnknownFieldNameForType = 'CustomFields:UnknownFieldNameForType',
      /**
       * CustomField {0:number} is required
       */
      Required = 'CustomFields:Required',
      /**
       * You are not allowed to edit CustomField {0:number}
       */
      NotAllowed = 'CustomFields:NotAllowed',
      /**
       * CustomField {CustomFieldID:number} is {CurrentLength:number} chars long but should not be longer than {MaxLength:number}
       */
      TooLong = 'CustomFields:TooLong',
      /**
       * CustomField {CustomFieldID:number} is {CurrentLength:number} chars long but should be minimal {MinLength:number} chars
       */
      TooShort = 'CustomFields:TooShort',
      /**
       * CustomField {CustomFieldID:number} is {CurrentValue:number} but should not be larger than {MaxValue:number}
       */
      TooLarge = 'CustomFields:TooLarge',
      /**
       * CustomField {CustomFieldID:number} is {CurrentValue:number} but should be at least {MinValue:number}
       */
      TooSmall = 'CustomFields:TooSmall',
      /**
       * CustomField {CustomFieldID:number} is {CurrentValue:string} but should not be later than {MaxDate:string}
       */
      TooLate = 'CustomFields:TooLate',
      /**
       * CustomField {CustomFieldID:number} is {CurrentValue:string} but should not be earlier than {MinDate:string}
       */
      TooEarly = 'CustomFields:TooEarly',
      /**
       * CustomField {CustomFieldID:number} is an enum, but the value {Value:string} doesn't exist
       */
      WrongEnumValue = 'CustomFields:WrongEnumValue',
      /**
       * CustomField {0:number} is an integer field and can't have a fraction
       */
      IntegerCantHaveFraction = 'CustomFields:IntegerCantHaveFraction',
      /**
       * The requested BackendID is already in use
       */
      DuplicateBackendID = 'CustomFields:DuplicateBackendID',
      /**
       * A custom field with BackendID {0:string} does not exist
       */
      BackendIDDoesNotExist = 'CustomFields:BackendIDDoesNotExist',
      /**
       * Enum values are only allowed when CustomField is of DataType 'Enum'
       */
      EnumValuesAreOnlyAllowedWhenCustomFieldIsOfDataTypeEnum = 'CustomFields:EnumValuesAreOnlyAllowedWhenCustomFieldIsOfDataTypeEnum',
      /**
       * Enum values require a key and a value
       */
      EnumValuesRequireAKeyAndValue = 'CustomFields:EnumValuesRequireAKeyAndValue',
      /**
       * Cannot remove enum value that is in use
       */
      CannotRemoveEnumValueThatIsUsedAsDefaultValue = 'CustomFields:CannotRemoveEnumValueThatIsUsedAsDefaultValue',
      /**
       * Enum values are required when CustomField is of DataType 'Enum'
       */
      DataTypeEnumRequiresSomeEnumValues = 'CustomFields:DataTypeEnumRequiresSomeEnumValues',
      /**
       * Date options are only allowed on customfields with type Date or DateTime
       */
      DateOptionsOnNonDateField = 'CustomFields:DateOptionsOnNonDateField',
      /**
       * Range options are only allowed on customfields with type Integer or Decimal
       */
      RangeOptionsOnNonNumberField = 'CustomFields:RangeOptionsOnNonNumberField',
      /**
       * CustomField {CustomFieldID:number} does not match regex {Pattern:string}
       */
      RegexNotMatched = 'CustomFields:RegexNotMatched',
      /**
       * The requested CustomField has a wrong type. Handling {expected:string}, but got a field with {actual:string}
       */
      InvalidType = 'CustomFields:InvalidType',
      /**
       * The provided data type does not allow for array values.
       */
      ArrayNotAllowedForDataType = 'CustomFields:ArrayNotAllowedForDataType',
      /**
       * One or more custom fields are invalid.
       */
      InvalidCustomFields = 'CustomFields:InvalidCustomFields',
      /**
       * Organization unit and organization unit set are mutually exclusive.
       */
      OrganizationUnitAndSetAreMutuallyExclusive = 'CustomFields:OrganizationUnitAndSetAreMutuallyExclusive'
    }

    export const enum DiscountCampaign {
      /**
       * Budget of a discount campaign is required and cannot be negative.
       */
      BudgetCannotBeNegative = 'DiscountCampaign:BudgetCannotBeNegative',
      /**
       * Budget currency cannot be changed.
       */
      CurrencyCannotBeChanged = 'DiscountCampaign:CurrencyCannotBeChanged',
      /**
       * Currency is required when budget is set.
       */
      CurrencyRequiredWhenBudgetIsSet = 'DiscountCampaign:CurrencyRequiredWhenBudgetIsSet',
      /**
       * Start date required when discount need to adhere to the campaing start/end date.
       */
      StartDateRequired = 'DiscountCampaign:StartDateRequired',
      /**
       * cannot set EndDate without StartDate.
       */
      CannotSetEndDateWithoutStartDate = 'DiscountCampaign:CannotSetEndDateWithoutStartDate',
      /**
       * EndDate cannot be lower then StartDate
       */
      EndDateCannotBeLowerThanStartDate = 'DiscountCampaign:EndDateCannotBeLowerThanStartDate'
    }

    export const enum EndpointConfigurations {
      /**
       * The certificate could not be parsed.
       */
      InvalidCertificate = 'EndpointConfigurations:InvalidCertificate',
      /**
       * The certificate has no private key, please provide a certificate with a private key.
       */
      CertificateHasNoPrivateKey = 'EndpointConfigurations:CertificateHasNoPrivateKey',
      /**
       * The certificate does not have Client Authentication usage.
       */
      CertificateHasNoClientAuthentication = 'EndpointConfigurations:CertificateHasNoClientAuthentication',
      /**
       * The certificate does not have Digital Signature or Key Agreement usage.
       */
      CertificateHasNoDigitalSignatureOrKeyAgreement = 'EndpointConfigurations:CertificateHasNoDigitalSignatureOrKeyAgreement',
      /**
       * The certificate must not be expired.
       */
      CertificateMustNotBeExpired = 'EndpointConfigurations:CertificateMustNotBeExpired'
    }

    export const enum EventExportConfigurations {
      /**
       * The certificate could not be parsed.
       */
      InvalidCertificate = 'EventExportConfigurations:InvalidCertificate',
      /**
       * The certificate has no private key, please provide a certificate with a private key.
       */
      CertificateHasNoPrivateKey = 'EventExportConfigurations:CertificateHasNoPrivateKey',
      /**
       * The certificate does not have Client Authentication usage.
       */
      CertificateHasNoClientAuthentication = 'EventExportConfigurations:CertificateHasNoClientAuthentication',
      /**
       * The certificate does not have Digital Signature or Key Agreement usage.
       */
      CertificateHasNoDigitalSignatureOrKeyAgreement = 'EventExportConfigurations:CertificateHasNoDigitalSignatureOrKeyAgreement',
      /**
       * The certificate must not be expired.
       */
      CertificateMustNotBeExpired = 'EventExportConfigurations:CertificateMustNotBeExpired'
    }

    export const enum PriceListManualInputAdjustment {
      /**
       * ManualInputAdjustments ExpireDate cannot be before the EffectiveDate.
       */
      ManualInputAdjustmentsExpireDateCannotBeBeforeEffectiveDate = 'PriceListManualInputAdjustment:ManualInputAdjustmentsExpireDateCannotBeBeforeEffectiveDate'
    }

    export const enum Settings {
      /**
       * Setting with key '{0:string}' doesn't exist.
       */
      NotFound = 'Settings:NotFound',
      /**
       * Conversion failed for setting {key:string} to type {settingType:string} for value {value:string}
       */
      ConversionFailed = 'Settings:ConversionFailed',
      /**
       * Prevented submission of masked value '{0:string}'!
       */
      MaskedValue = 'Settings:MaskedValue',
      /**
       * This setting can only be set on rootlevel
       */
      RootLevelOnly = 'Settings:RootLevelOnly'
    }

    export const enum CompanyCustomerValidator {
      /**
       * The specified user does not belong to this company.
       */
      CompanyUserNotExists = 'CompanyCustomerValidator:CompanyUserNotExists'
    }

    export const enum Communications {
      /**
       * The template for this message cannot be found or has been disabled.
       */
      TemplateNotFoundOrDisabled = 'Communications:TemplateNotFoundOrDisabled'
    }

    export const enum Smtp {
      /**
       * The OAuth2 provider {0:string} is not configured correctly.
       */
      OAuth2ProviderNotConfigured = 'Smtp:OAuth2ProviderNotConfigured',
      /**
       * Failed to acquire OAuth2 token. {0:string}
       */
      OAuth2TokenAcquisitionFailed = 'Smtp:OAuth2TokenAcquisitionFailed'
    }

    export const enum CreateFinancialPeriodAudit {
      /**
       * No available Financial Periods were found to audit
       */
      NoFinancialPeriodsFound = 'CreateFinancialPeriodAudit:NoFinancialPeriodsFound',
      /**
       * The selected Financial Periods exceed a fiscal year, please limit your selection
       */
      FinancialPeriodsExceedFiscalYear = 'CreateFinancialPeriodAudit:FinancialPeriodsExceedFiscalYear',
      /**
       * The supplied organization unit must be a country ou
       */
      CountryOuNeeded = 'CreateFinancialPeriodAudit:CountryOuNeeded'
    }

    export const enum AntiMoneyLaundering {
      /**
       * Transaction blocked due to Anti-Money Laundering regulations.
       */
      Blocked = 'AntiMoneyLaundering:Blocked',
      /**
       * Order can't be finalized due to pending order requirements.
       */
      PendingOrderRequirements = 'AntiMoneyLaundering:PendingOrderRequirements',
      /**
       * There can only be a single Manual rule per country.
       */
      TooManyManualRules = 'AntiMoneyLaundering:TooManyManualRules',
      /**
       * All rules with trigger type Threshold require a Threshold value.
       */
      ThresholdWithoutValue = 'AntiMoneyLaundering:ThresholdWithoutValue',
      /**
       * All rules with trigger type Scripting require a ScriptID.
       */
      ScriptingWithoutValue = 'AntiMoneyLaundering:ScriptingWithoutValue',
      /**
       * All rules that require a Survey need a SurveyID.
       */
      SurveyWithoutValue = 'AntiMoneyLaundering:SurveyWithoutValue',
      /**
       * Only Threshold rules can have a SlidingWindow.
       */
      SlidingWindowWithoutThreshold = 'AntiMoneyLaundering:SlidingWindowWithoutThreshold',
      /**
       * Change of customer blocked due to Anti-Money Laundering regulations.
       */
      CustomerOnAMLOrderCantBeModified = 'AntiMoneyLaundering:CustomerOnAMLOrderCantBeModified'
    }

    export const enum CustomOrderStatus {
      /**
       * CustomOrderStatus with Name '{name:string}' already exists: {value:number}
       */
      StatusWithSameNameAlreadyExists = 'CustomOrderStatus:StatusWithSameNameAlreadyExists',
      /**
       * CustomOrderStatus with Value '{0:number}'
       */
      StatusWithSameValueAlreadyExists = 'CustomOrderStatus:StatusWithSameValueAlreadyExists',
      /**
       * Maximum allowed number of CustomOrderStatus rows has been reached
       */
      MaximumAllowedNumberOfStatusRowsReached = 'CustomOrderStatus:MaximumAllowedNumberOfStatusRowsReached',
      /**
       * Modifying objects created by EVA is not allowed
       */
      ModifyingEVAObjectsNotAllowed = 'CustomOrderStatus:ModifyingEVAObjectsNotAllowed',
      /**
       * Deleting objects created by EVA is not allowed
       */
      DeletingEVAObjectsNotAllowed = 'CustomOrderStatus:DeletingEVAObjectsNotAllowed'
    }

    export const enum AutoComplete {
      /**
       * Failed to create invoice while autocompleting order.
       */
      InvoiceNull = 'AutoComplete:InvoiceNull',
      /**
       * Failed to invocie the Order while autocompleting order.
       */
      InvoicingFailed = 'AutoComplete:InvoicingFailed',
      /**
       * Failed to cancel some of the lines while autocompleting order.
       */
      CancellationFailed = 'AutoComplete:CancellationFailed'
    }

    export const enum OrderGeneration {
      /**
       * Non-employee users cannot use LineActionType ShipLine on an Order with a shop as OrganizationUnit
       */
      ShipLinesNotAllowed = 'OrderGeneration:ShipLinesNotAllowed'
    }

    export const enum OrderLineCreator {
      /**
       * Missing pricing information provided for OrderLine and unable to determine this because no Product has been provided either.
       */
      NoPricingAndProduct = 'OrderLineCreator:NoPricingAndProduct',
      /**
       * A configurable product cannot be added to an order.
       */
      ConfigurableProduct = 'OrderLineCreator:ConfigurableProduct',
      /**
       * Can't add new lines to a signed order.
       */
      OrderIsSigned = 'OrderLineCreator:OrderIsSigned',
      /**
       * Can't add new lines to a completed order.
       */
      OrderIsCompleted = 'OrderLineCreator:OrderIsCompleted',
      /**
       * Can't add new lines to an order with a pending payment.
       */
      PendingPayment = 'OrderLineCreator:PendingPayment',
      /**
       * Can't add a line with another currency to an order.
       */
      InvalidCurrency = 'OrderLineCreator:InvalidCurrency',
      /**
       * Can't add a line with a product whose pre-sale date has not been reached.
       */
      OrderBeforePreSaleDate = 'OrderLineCreator:OrderBeforePreSaleDate',
      /**
       * OrderLine {lineToCloneID:number} is not part of source order {sourceOrderID:number}
       */
      LineToCloneNotPartOfSourceOrder = 'OrderLineCreator:LineToCloneNotPartOfSourceOrder',
      /**
       * LoyaltyProgram does not allow exchange orders
       */
      LoyaltyProgramDoesNotAllowExchangeOrders = 'OrderLineCreator:LoyaltyProgramDoesNotAllowExchangeOrders',
      /**
       * Cannot add return from different LoyaltyProgram
       */
      CannotAddReturnFromDifferentLoyaltyProgram = 'OrderLineCreator:CannotAddReturnFromDifferentLoyaltyProgram'
    }

    export const enum LineActionType {
      /**
       * Cannot mutate the line action type of line {0:number} because it has a related line.
       */
      CannotMutateRelatedLine = 'LineActionType:CannotMutateRelatedLine'
    }

    export const enum OrderCompanyManager {
      /**
       * The specified user does not belong to this company.
       */
      CompanyUserNotExists = 'OrderCompanyManager:CompanyUserNotExists',
      /**
       * The order is either already completed, currently exporting, or has been exported.
       */
      OrderNotModifiable = 'OrderCompanyManager:OrderNotModifiable'
    }

    export const enum OrderCurrency {
      /**
       * It's not possible to change the currency of Order {0:number} anymore, please create a new order
       */
      OrderImmutable = 'OrderCurrency:OrderImmutable',
      /**
       * It's not possible to change the currency of Order {orderID:number} from {oldCurrencyID:string} to {newCurrencyID:string}. The SoldFrom {orgID:number} has currency {ouCurrencyID:string}
       */
      Invalid = 'OrderCurrency:Invalid'
    }

    export const enum OrderCustomer {
      /**
       * Customer on this order can't be changed anymore because it has exported lines.
       */
      OrderHasExportedLines = 'OrderCustomer:OrderHasExportedLines',
      /**
       * The selected user {0:number} is not a customer.
       */
      UserIsNotACustomer = 'OrderCustomer:UserIsNotACustomer',
      /**
       * Attaching business customer to order is not allowed
       */
      AttachBusinessCustomerNotAllowed = 'OrderCustomer:AttachBusinessCustomerNotAllowed',
      /**
       * Attaching a customer to an offline order is not allowed
       */
      AttachCustomerToOfflineOrderNotAllowed = 'OrderCustomer:AttachCustomerToOfflineOrderNotAllowed',
      /**
       * Order is not applicable to attach customers
       */
      OrderNotApplicable = 'OrderCustomer:OrderNotApplicable',
      /**
       * Customer cannot be changed on orders that only have return lines.
       */
      CustomerCannotBeChangedOnFullyReturn = 'OrderCustomer:CustomerCannotBeChangedOnFullyReturn',
      /**
       * Customer cannot be changed when loyalty program payments are done.
       */
      CustomerCannotBeChangeWhenLoyaltyProgramPaymentsAreDone = 'OrderCustomer:CustomerCannotBeChangeWhenLoyaltyProgramPaymentsAreDone',
      /**
       * Customer cannot be changed on return reversals.
       */
      CustomerCannotBeChangedOnReturnReversals = 'OrderCustomer:CustomerCannotBeChangedOnReturnReversals'
    }

    export const enum ModifyQuantityOrdered {
      /**
       * Error: {0:string}
       */
      CannotModifyQuantityOrdered = 'ModifyQuantityOrdered:CannotModifyQuantityOrdered',
      /**
       * All lines should be in the same order
       */
      LinesShouldBeInSameOrder = 'ModifyQuantityOrdered:LinesShouldBeInSameOrder'
    }

    export const enum OrderOrganizationUnits {
      /**
       * SoldToOrganizationUnitID cannot be the same as the SoldFromOrganizationUnitID
       */
      InvalidOrganizationUnit = 'OrderOrganizationUnits:InvalidOrganizationUnit',
      /**
       * It's not possible to attach Order {orderID:number} to OrganizationUnit with ID {orgID:number} because it has Type {type:OrganizationUnitTypes}
       */
      InvalidOrganizationUnitType = 'OrderOrganizationUnits:InvalidOrganizationUnitType',
      /**
       * It's not possible to attach Order {orderID:number} to OrganizationUnit with ID {orgID:number} because the ou has currency {ouCurrencyID:string} and the order has currency {orderCurrencyID:string}
       */
      InvalidCurrency = 'OrderOrganizationUnits:InvalidCurrency',
      /**
       * Order {0:number} already has exported lines, can no longer change the OrganizationUnit of it.
       */
      OrderAlreadyExported = 'OrderOrganizationUnits:OrderAlreadyExported'
    }

    export const enum StockReservation {
      /**
       * Cannot reserve quantity {quantity:number} on OrderLine {orderLineID:number} because it already has {alreadyReserved:number} reserved and only {ordered:number} ordered
       */
      CannotReserveMoreThanOrdered = 'StockReservation:CannotReserveMoreThanOrdered',
      /**
       * Reservation task cannot be completed because order {0:number} is already completed.
       */
      OrderCompleted = 'StockReservation:OrderCompleted',
      /**
       * Lines not fully cancelled or confirmed
       */
      LineNotFullyCancelledOrConfirmed = 'StockReservation:LineNotFullyCancelledOrConfirmed',
      /**
       * StockProductID {0:number} is not a valid product for OrderLine {1:number}
       */
      InvalidStockProductID = 'StockReservation:InvalidStockProductID'
    }

    export const enum DeliverShipments {
      /**
       * Shipment {0:number} is not a sales order shipment, cannot deliver it.
       */
      MustBeSalesOrder = 'DeliverShipments:MustBeSalesOrder',
      /**
       * Shipment {0:number} has already been completed, no deliveries of it can be made anymore.
       */
      ShipmentAlreadyCompleted = 'DeliverShipments:ShipmentAlreadyCompleted'
    }

    export const enum ReturnToSupplierRequests {
      /**
       * The ReturnToSupplierRequest {0:number} is not New and cannot be mutated.
       */
      NotNew = 'ReturnToSupplierRequests:NotNew',
      /**
       * The ReturnToSupplierRequest {0:number} is not New or Error and cannot be processed or deleted.
       */
      NotNewOrError = 'ReturnToSupplierRequests:NotNewOrError',
      /**
       * A ReturnToSupplierRequest already exists with the Name {0:string}.
       */
      DuplicateName = 'ReturnToSupplierRequests:DuplicateName'
    }

    export const enum OrderOrchestration {
      /**
       * Cannot determine a fulfillment proposition for order {0:number}
       */
      CannotFulfill = 'OrderOrchestration:CannotFulfill'
    }

    export const enum OrderExportRouter {
      /**
       * Could not determine warehouse for Order {0:number}
       */
      NoWarehouseFound = 'OrderExportRouter:NoWarehouseFound',
      /**
       * Could not determine warehouse as there are multiple candidates: {0:string}
       */
      MultipleWarehousesFound = 'OrderExportRouter:MultipleWarehousesFound'
    }

    export const enum ReturnToSupplierOrderExporter {
      /**
       * Endpoint did not respond with a 200 OK, body [ACK]
       */
      InvalidResponse = 'ReturnToSupplierOrderExporter:InvalidResponse'
    }

    export const enum WarehouseOrderExporter {
      /**
       * Endpoint did not respond with a 200 OK, body [ACK]
       */
      InvalidResponse = 'WarehouseOrderExporter:InvalidResponse'
    }

    export const enum OrderDocuments {
      /**
       * Output type not allowed: {0:string}
       */
      NotAllowed = 'OrderDocuments:NotAllowed'
    }

    export const enum CheckoutOptions {
      /**
       * Handler is required
       */
      MissingHandler = 'CheckoutOptions:MissingHandler',
      /**
       * The given handler doesn't exist
       */
      UnknownHandler = 'CheckoutOptions:UnknownHandler',
      /**
       * The data is not in a valid format for the selected type
       */
      InvalidData = 'CheckoutOptions:InvalidData',
      /**
       * Updating data of this checkout option type is not supported
       */
      UpdatingNotSupported = 'CheckoutOptions:UpdatingNotSupported'
    }

    export const enum AddressBook {
      /**
       * There is already an addressbookitem with this backendid.
       */
      DuplicateBackendID = 'AddressBook:DuplicateBackendID',
      /**
       * It's not possible to delete a default address when you have two or more other addresses in your address book.
       */
      CannotDeleteDefaultAddress = 'AddressBook:CannotDeleteDefaultAddress'
    }

    export const enum Orders {
      /**
       * Order {0:number} does not have the required type {1:OrderTypes}.
       */
      OrderHasInvalidType = 'Orders:OrderHasInvalidType',
      /**
       * Order {0:number} does not have the required property {1:OrderProperties}.
       */
      OrderHasInvalidProperty = 'Orders:OrderHasInvalidProperty',
      /**
       * The current PickupOrganizationUnit of Order {OrderID:number} is not a shop ({OrganizationUnitID:number}).
       */
      PickupOrganizationUnitMustBeShop = 'Orders:PickupOrganizationUnitMustBeShop',
      /**
       * Cannot change the PickupOrganizationUnit of an Order to an OrganizationUnit that is not of type Shop.
       */
      OrganizationUnitMustBeShop = 'Orders:OrganizationUnitMustBeShop'
    }

    export const enum ReturnReasons {
      /**
       * ReturnReason {0:number} does not have the required type {1:ReturnReasonType}.
       */
      ReturnReasonHasInvalidType = 'ReturnReasons:ReturnReasonHasInvalidType'
    }

    export const enum CustomerOrderReturns {
      /**
       * Not allowed to create returns on your current organization unit.
       */
      CannotCreateReturnsOnOrganizationUnit = 'CustomerOrderReturns:CannotCreateReturnsOnOrganizationUnit',
      /**
       * Not allowed to create returns from order with type other than Sales.
       */
      OriginalOrderMustBeSalesOrder = 'CustomerOrderReturns:OriginalOrderMustBeSalesOrder',
      /**
       * No OrderLine found on Order {orderToReturnID:number} to ship {quantity:number} items of product/orderline {productOrderLineID:number}
       */
      NoOrderLineForReturn = 'CustomerOrderReturns:NoOrderLineForReturn'
    }

    export namespace UserTasks {
      export const enum Deactivate {
        /**
         * Cannot deactivate {taskType:string} task {taskID:number} because it has already been completed
         */
        UserTaskAlreadyCompleted = 'UserTasks:Deactivate:UserTaskAlreadyCompleted',
        /**
         * Cannot deactivate {taskType:string} task {taskID:number} because it has already been deactivated.
         */
        UserTaskAlreadyDeactivated = 'UserTasks:Deactivate:UserTaskAlreadyDeactivated'
      }

      export const enum Start {
        /**
         * Cannot start {taskType:string} task {taskID:number} because it has already been completed
         */
        UserTaskAlreadyCompleted = 'UserTasks:Start:UserTaskAlreadyCompleted',
        /**
         * Cannot start {taskType:string} task {taskID:number} because it is not active
         */
        UserTaskNotActive = 'UserTasks:Start:UserTaskNotActive',
        /**
         * Cannot start {taskType:string} task {taskID:number} because it requires a functionality you don't currently have.
         */
        UserTaskRequiresFunctionality = 'UserTasks:Start:UserTaskRequiresFunctionality'
      }

      export const enum Print {
        /**
         * Cannot print task {taskID:number} because its type ({taskTypeID:number}) is not supported
         */
        UserTaskTypeNotSupported = 'UserTasks:Print:UserTaskTypeNotSupported'
      }

      export const enum Complete {
        /**
         * Cannot complete {taskType:string} task {taskID:number} because it has already been completed
         */
        UserTaskAlreadyCompleted = 'UserTasks:Complete:UserTaskAlreadyCompleted',
        /**
         * Cannot complete {taskType:string} task {taskID:number} because it is not active
         */
        UserTaskNotActive = 'UserTasks:Complete:UserTaskNotActive',
        /**
         * Cannot complete {taskType:string} task {taskID:number} because it is not attached to the current user ({currentUserID:number}) but to {attachedUserID:number}
         */
        UserNotAttachedToUserTask = 'UserTasks:Complete:UserNotAttachedToUserTask',
        /**
         * Cannot complete {taskType:string} task {taskID:number} because it is not attached to any user
         */
        UserTaskNotAttached = 'UserTasks:Complete:UserTaskNotAttached'
      }

      export const enum PrintTask {
        /**
         * Cannot complete print task, it was not yet processed.
         */
        NotYetPrinted = 'UserTasks:PrintTask:NotYetPrinted'
      }

    }

    export const enum NamedInstanceFactory {
      /**
       * Handler {0:string} not found.
       */
      HandlerNotFound = 'NamedInstanceFactory:HandlerNotFound'
    }

    export const enum TaskScheduler {
      /**
       * Task ID cannot contain '$'
       */
      InvalidCharacters = 'TaskScheduler:InvalidCharacters',
      /**
       * Invalid cron expression: {0:string}
       */
      InvalidCronExpression = 'TaskScheduler:InvalidCronExpression'
    }

    export const enum Sorting {
      /**
       * Sortingproperty {SortingProperty:string} does not exist in object {ObjectName:string}
       */
      SortingPropertyDoesNotExistInObject = 'Sorting:SortingPropertyDoesNotExistInObject'
    }

    export const enum CreateApiKey {
      /**
       * Incorrect user type - must be of type `API`.
       */
      IncorrectUserType = 'CreateApiKey:IncorrectUserType',
      /**
       * The ExpirationDate should be in the future.
       */
      InvalidExpirationDate = 'CreateApiKey:InvalidExpirationDate',
      /**
       * A PermanentApiKey can't have an ExpirationDate.
       */
      PermanentKeyCantHaveExpirationDate = 'CreateApiKey:PermanentKeyCantHaveExpirationDate'
    }

    export const enum AttachUserToConsumerCompany {
      /**
       * Cannot attach a user to a company that is managed externally.
       */
      CompanyIsExternal = 'AttachUserToConsumerCompany:CompanyIsExternal'
    }

    export const enum DetachUserFromConsumerCompany {
      /**
       * Cannot detach a user from a company that is managed externally.
       */
      CompanyIsExternal = 'DetachUserFromConsumerCompany:CompanyIsExternal'
    }

    export const enum PhoneBook {
      /**
       * It's not possible to delete a primary phone number unless it's one of two or the only one.
       */
      CannotDeletePrimaryPhoneNumber = 'PhoneBook:CannotDeletePrimaryPhoneNumber'
    }

    export const enum SearchUsers {
      /**
       * Can only search `HouseNumber` in combination with `ZipCode`
       */
      CanOnlySearchHouseNumberWithZipCode = 'SearchUsers:CanOnlySearchHouseNumberWithZipCode'
    }

    export const enum UserAssociation {
      /**
       * Primary and related user IDs should be different.
       */
      SameIDsError = 'UserAssociation:SameIDsError',
      /**
       * User association type was deleted, please use another one.
       */
      DeletedAssociationTypeError = 'UserAssociation:DeletedAssociationTypeError'
    }

    export const enum ValidateUserEmailAddress {
      /**
       * Email address already validated.
       */
      EmailAddressAlreadyValidated = 'ValidateUserEmailAddress:EmailAddressAlreadyValidated',
      /**
       * Validation code incorrect.
       */
      InvalidValidationCode = 'ValidateUserEmailAddress:InvalidValidationCode'
    }

    export const enum UserInteractions {
      /**
       * A UserInteraction must be attached to a user. Either provide a UserID in the request or an OrderID that has a CustomerID.
       */
      UserRequired = 'UserInteractions:UserRequired'
    }

    export const enum CreateOrganizationUnitSupplier {
      /**
       * When creating a supplier relationship either SupplierOrganizationUnitID, SupplierOrganizationUnitSetID or SupplierOrganizationUnitIDs must be specified.
       */
      SupplierIsRequired = 'CreateOrganizationUnitSupplier:SupplierIsRequired',
      /**
       * The requested supplier relationship(s) already exist.
       */
      RelationshipAlreadyExists = 'CreateOrganizationUnitSupplier:RelationshipAlreadyExists'
    }

    export const enum DeleteOrganizationUnitSupplier {
      /**
       * Please delete the supplier stock allocation rules before deleting the supplier.
       */
      HasStockAllocationRules = 'DeleteOrganizationUnitSupplier:HasStockAllocationRules'
    }

    export const enum UpdateOrganizationUnitSupplier {
      /**
       * Cannot update supplier relationship as it would create a duplicate. A supplier relationship with the same organization unit, supplier, and target already exists.
       */
      WouldCreateDuplicate = 'UpdateOrganizationUnitSupplier:WouldCreateDuplicate'
    }

    export const enum AdjustStockService {
      /**
       * No adjustments defined
       */
      NoAdjustmentsDefined = 'AdjustStockService:NoAdjustmentsDefined',
      /**
       * ProductID or ProductBackendID required
       */
      ProductIDOrProductBackendIDRequired = 'AdjustStockService:ProductIDOrProductBackendIDRequired'
    }

    export const enum CommitOrderLines {
      /**
       * It's not possible to choose a commitment status other than ManualCommit or ForcedCommit.
       */
      CannotChooseCommitmentStatus = 'CommitOrderLines:CannotChooseCommitmentStatus'
    }

    export const enum MoveStock {
      /**
       * No movements defined.
       */
      NoMovementsDefined = 'MoveStock:NoMovementsDefined',
      /**
       * Parameter ProductID or ProductBackendID required.
       */
      ProductRequired = 'MoveStock:ProductRequired',
      /**
       * Mutation {0} ({1}) already exists.
       */
      AlreadyExists = 'MoveStock:AlreadyExists',
      /**
       * Source and destination product must be the same EP (stock aggregate product).
       */
      DestinationProductMustBeSameEP = 'MoveStock:DestinationProductMustBeSameEP'
    }

    export const enum ProcessStockMutationFile {
      /**
       * You are not allowed to update the stock of the specified OrganizationUnit.
       */
      UnauthorizedForStockMutation = 'ProcessStockMutationFile:UnauthorizedForStockMutation',
      /**
       * StockmutationReason 'FullStockCount' can only be used by the FullStockCount process.
       */
      StockmutationReasonFSCCanOnlyBeUsedByFSCProcress = 'ProcessStockMutationFile:StockmutationReasonFSCCanOnlyBeUsedByFSCProcress'
    }

    export const enum StockLabelSettings {
      /**
       * Cannot change the default settings for a stocklabel.
       */
      CannotChangeDefaultSettings = 'StockLabelSettings:CannotChangeDefaultSettings',
      /**
       * The feature shouldn't be inherited when setting it as default.
       */
      CannotSetIsDefaultForInheritedFeatue = 'StockLabelSettings:CannotSetIsDefaultForInheritedFeatue'
    }

    export const enum CreateShipment {
      /**
       * An Order identifier is required, either `OrderID`, `OrderFulfillmentID` or `OrderBackendID` and `OrderBackendSystemID` must be provided on the top-level request or in the `Lines` or `Packages`
       */
      MissingOrderReference = 'CreateShipment:MissingOrderReference',
      /**
       * Cannot have duplicate identifiers
       */
      NoDuplicateIdentifiersAllowed = 'CreateShipment:NoDuplicateIdentifiersAllowed'
    }

    export const enum UndoShipment {
      /**
       * Shipment line {ShipmentLineID:number} on shipment {ShipmentID:number} has already been received
       */
      ShipmentLineAlreadyReceived = 'UndoShipment:ShipmentLineAlreadyReceived',
      /**
       * Shipment {0:number} has not yet been received and cannot be undone.
       */
      ShipmentNotReceived = 'UndoShipment:ShipmentNotReceived'
    }

    export const enum UpdateShipment {
      /**
       * RequireReceiveMethodReason is required
       */
      ReceiveMethodReasonNeedsToBeProvided = 'UpdateShipment:ReceiveMethodReasonNeedsToBeProvided',
      /**
       * Cannot have duplicate identifiers
       */
      NoDuplicateIdentifiersAllowed = 'UpdateShipment:NoDuplicateIdentifiersAllowed'
    }

    export const enum CreateSerialNumber {
      /**
       * Cannot create serial numbers for second chance products using this service.
       */
      InvalidProduct = 'CreateSerialNumber:InvalidProduct'
    }

    export const enum Scripts {
      /**
       * The Script is still being used, cannot delete.
       */
      ScriptInUse = 'Scripts:ScriptInUse'
    }

    export const enum CreatePurchaseOrder {
      /**
       * A SupplierID is required when Unified Orders are enabled.
       */
      SupplierRequiredForUnifiedOrders = 'CreatePurchaseOrder:SupplierRequiredForUnifiedOrders'
    }

    export const enum SupplierPurchaseOrder {
      /**
       * Inconsistent use of product identifiers.
       */
      InconsistentProductIdentifiers = 'SupplierPurchaseOrder:InconsistentProductIdentifiers'
    }

    export const enum PrintProductPriceLabel {
      /**
       * No barcode found for product with ID {0:number}
       */
      ProductBarcodeNotFound = 'PrintProductPriceLabel:ProductBarcodeNotFound'
    }

    export const enum RenderThermalPrintResult {
      /**
       * Cannot use Blob with MimeType {0:string}.
       */
      InvalidMimeType = 'RenderThermalPrintResult:InvalidMimeType'
    }

    export const enum ExplainProductPrices {
      /**
       * PriceList is deactivated.
       */
      PriceListIsDeactivated = 'ExplainProductPrices:PriceListIsDeactivated',
      /**
       * Must provide between 1 and 100 product ID's.
       */
      RequestedProductIDsInvalid = 'ExplainProductPrices:RequestedProductIDsInvalid'
    }

    export const enum PushPriceList {
      /**
       * When creating a new price list, you must specify a currency ID.
       */
      MissingCurrencyID = 'PushPriceList:MissingCurrencyID',
      /**
       * Cannot create a markup component that does not have its associated MarkupData
       */
      MissingMarkupData = 'PushPriceList:MissingMarkupData',
      /**
       * Cannot create a CopyPricesFromOtherPriceList component that does not have its associated CopyPricesFromOtherPriceListData
       */
      MissingCopyPricesFromOtherPriceListData = 'PushPriceList:MissingCopyPricesFromOtherPriceListData'
    }

    export const enum Pricing {
      /**
       * This price list is not valid for simple updates.
       */
      NotValidForSimpleUpdates = 'Pricing:NotValidForSimpleUpdates',
      /**
       * Duplicate prices for products are not supported in simple price lists.
       */
      DuplicatePricesForProduct = 'Pricing:DuplicatePricesForProduct',
      /**
       * Expiration dates are not supported for simple price lists.
       */
      ExpirationDatesNotSupported = 'Pricing:ExpirationDatesNotSupported',
      /**
       * Prices must have either `ProductID`, `CustomID` or `BackendID` and cannot be mixed!
       */
      InvalidProductIdentifiers = 'Pricing:InvalidProductIdentifiers',
      /**
       * One or more products could not be found: {0:string}
       */
      ProductsNotFound = 'Pricing:ProductsNotFound'
    }

    export const enum PaymentTransactionLedger {
      /**
       * This PaymentTransactionLedgerType is internal and can't be used to create ledgers
       */
      IsInternal = 'PaymentTransactionLedger:IsInternal'
    }

    export const enum OrganizationUnitHierarchy {
      /**
       * If a Functionality Scope is passed, a Functionality must also be passed
       */
      NeedFunctionalityWithScope = 'OrganizationUnitHierarchy:NeedFunctionalityWithScope'
    }

    export const enum ImportOrganizationUnits {
      /**
       * ParentID {0:string} does not exist.
       */
      ParentNotFound = 'ImportOrganizationUnits:ParentNotFound',
      /**
       * ReturnOrganizationUnitID {0:string} does not exist.
       */
      ReturnOrganizationUnitNotFound = 'ImportOrganizationUnits:ReturnOrganizationUnitNotFound',
      /**
       * There is an infinite loop reference starting with {0:string} -> {1:string}.
       */
      InfiniteLoop = 'ImportOrganizationUnits:InfiniteLoop'
    }

    export const enum AddServiceProductToOrder {
      /**
       * Product {0:string} is not a service product.
       */
      ProductRequiresServiceType = 'AddServiceProductToOrder:ProductRequiresServiceType'
    }

    export const enum CreateOrderAppToken {
      /**
       * Order already has a customer attached.
       */
      OrderHasCustomerAttached = 'CreateOrderAppToken:OrderHasCustomerAttached'
    }

    export const enum CreateOrderLedger {
      /**
       * OrderLine is either not found or doesn't belong to the Order
       */
      OrderLineNotFound = 'CreateOrderLedger:OrderLineNotFound'
    }

    export const enum CreatePurchaseOrderLineUnitPriceCorrection {
      /**
       * Missing required parameters for creating a new purchase order line correction.
       */
      MissingRequiredParameters = 'CreatePurchaseOrderLineUnitPriceCorrection:MissingRequiredParameters',
      /**
       * No lines provided for correction.
       */
      NoLinesProvided = 'CreatePurchaseOrderLineUnitPriceCorrection:NoLinesProvided',
      /**
       * The product does not have a unit cost price list configured, which is required to calculate the corrected unit cost.
       */
      ProductMissingCostPriceList = 'CreatePurchaseOrderLineUnitPriceCorrection:ProductMissingCostPriceList'
    }

    export const enum OrderCustomStatus {
      /**
       * This name already exists!
       */
      AlreadyExists = 'OrderCustomStatus:AlreadyExists',
      /**
       * This Backend ID is already used!
       */
      AlreadyUsedBackendID = 'OrderCustomStatus:AlreadyUsedBackendID'
    }

    export const enum OrderCustomType {
      /**
       * This name already exists!
       */
      AlreadyExists = 'OrderCustomType:AlreadyExists',
      /**
       * This Backend ID is already used!
       */
      AlreadyUsedBackendID = 'OrderCustomType:AlreadyUsedBackendID'
    }

    export const enum OrderLink {
      /**
       * Primary and related order IDs should be different.
       */
      SameIDsError = 'OrderLink:SameIDsError',
      /**
       * Order link type was deleted, please use another one.
       */
      DeletedLinkTypeError = 'OrderLink:DeletedLinkTypeError'
    }

    export const enum PushSalesOrders {
      /**
       * The open amount on the order {backendID:string} is supposed to be zero, but it was {openAmount:number}
       */
      OpenAmountNotZero = 'PushSalesOrders:OpenAmountNotZero'
    }

    export const enum SetOrderBackendID {
      /**
       * Order already has a BackendID/BackendSystemID set.
       */
      OrderAlreadyHasBackendIdentifier = 'SetOrderBackendID:OrderAlreadyHasBackendIdentifier',
      /**
       * This BackendID/BackendSystemID already exists.
       */
      BackendIdentifierAlreadyExists = 'SetOrderBackendID:BackendIdentifierAlreadyExists',
      /**
       * Cannot use reserved BackendSystemID {0:string}.
       */
      CannotUseBackendSystemID = 'SetOrderBackendID:CannotUseBackendSystemID'
    }

    export const enum SoldBy {
      /**
       * The SoldByID {0:number} is not an Employee-type user.
       */
      SoldByMustBeEmployee = 'SoldBy:SoldByMustBeEmployee',
      /**
       * The SoldBy can no longer be updated on Order {0:number} as it has already been invoiced.
       */
      CanNoLongerUpdateSoldBy = 'SoldBy:CanNoLongerUpdateSoldBy',
      /**
       * The SoldBy cannot be updated on Order {0:number} because it is not a Sales Order.
       */
      OrderMustBeSalesOrder = 'SoldBy:OrderMustBeSalesOrder'
    }

    export const enum ShipExternalOrderService {
      /**
       * Cannot perform shipment on {0:string}, no lines could be shipped.
       */
      CannotPerformShipment = 'ShipExternalOrderService:CannotPerformShipment'
    }

    export const enum ShipOrder {
      /**
       * Nothing shipped: {0}
       */
      NothingShipped = 'ShipOrder:NothingShipped'
    }

    export const enum UpdateOrderCustomFields {
      /**
       * Either CustomFields or CustomFieldsByBackendID needs to be specified
       */
      MissingCustomFields = 'UpdateOrderCustomFields:MissingCustomFields'
    }

    export const enum UpdateOrderLineStockLabel {
      /**
       * Either OrderID or OrderLineID is required.
       */
      OrderIDOrOrderLineIDRequired = 'UpdateOrderLineStockLabel:OrderIDOrOrderLineIDRequired'
    }

    export const enum CreateReturnToSupplierOrder {
      /**
       * Cannot create a ReturnToSupplier order from an Interbranch order
       */
      CannotCreateRTSFromInterbranch = 'CreateReturnToSupplierOrder:CannotCreateRTSFromInterbranch'
    }

    export const enum UpdateReturnToSupplierOrder {
      /**
       * Order is not a return to supplier order
       */
      NotAnRTSOrder = 'UpdateReturnToSupplierOrder:NotAnRTSOrder',
      /**
       * Cannot update placed order
       */
      CannotUpdatePlacedOrder = 'UpdateReturnToSupplierOrder:CannotUpdatePlacedOrder'
    }

    export const enum AutoTransferInterbranchOrder {
      /**
       * One of the organization units must be the current organization unit.
       */
      OneOfOrganizationUnitsMustBeCurrent = 'AutoTransferInterbranchOrder:OneOfOrganizationUnitsMustBeCurrent',
      /**
       * Cannot transfer between these organization units.
       */
      CannotTransferBetweenOrganizationUnits = 'AutoTransferInterbranchOrder:CannotTransferBetweenOrganizationUnits',
      /**
       * Order is not an interbranch order.
       */
      OrderNotInterbranch = 'AutoTransferInterbranchOrder:OrderNotInterbranch',
      /**
       * Order cannot be placed: {0:string}.
       */
      OrderCannotBePlaced = 'AutoTransferInterbranchOrder:OrderCannotBePlaced',
      /**
       * Order must be unified to be shipped.
       */
      OrderMustBeUnified = 'AutoTransferInterbranchOrder:OrderMustBeUnified'
    }

    export const enum SetOrderFulfillmentOptions {
      /**
       * {0:string} is not available
       */
      InvalidOptionSelected = 'SetOrderFulfillmentOptions:InvalidOptionSelected',
      /**
       * Option {option:string} is not available, the available options are: {available:string}
       */
      InvalidFulfillmentOptionSelected = 'SetOrderFulfillmentOptions:InvalidFulfillmentOptionSelected',
      /**
       * Option {option:string} is not available, the available options are: {available:string}
       */
      InvalidFulfillmentSubOptionSelected = 'SetOrderFulfillmentOptions:InvalidFulfillmentSubOptionSelected',
      /**
       * Cannot pick a sub-option without selecting an option first
       */
      CannotPickSubOptionWithoutOption = 'SetOrderFulfillmentOptions:CannotPickSubOptionWithoutOption',
      /**
       * Could not find location with ID {0:string} in the selected fulfillment option
       */
      CouldNotFindLocation = 'SetOrderFulfillmentOptions:CouldNotFindLocation'
    }

    export const enum ShipOrderFulfillment {
      /**
       * It's only possible to ship OrderFulfillmentLines of type Physical.
       */
      CannotShipNonPhysicalLines = 'ShipOrderFulfillment:CannotShipNonPhysicalLines',
      /**
       * The OrderLine {OrderLineID:number} behind OrderFulfillmentLineID {OrderFulfillmentLineID:number} has already been shipped or otherwise completed.
       */
      AlreadyShipped = 'ShipOrderFulfillment:AlreadyShipped'
    }

    export const enum UpdateOrderFulfillmentLine {
      /**
       * It's not possible to increase the quantity of an OrderFulfillmentLine
       */
      CannotIncreaseQuantity = 'UpdateOrderFulfillmentLine:CannotIncreaseQuantity',
      /**
       * It's only possible to change the quantity of a physical fulfillment line.
       */
      PhysicalLineRequired = 'UpdateOrderFulfillmentLine:PhysicalLineRequired'
    }

    export const enum RequeueErrorMessage {
      /**
       * Can only requeue a message that is in status New or FailureAfterRetry.
       */
      CannotRetrySuccessfulMessage = 'RequeueErrorMessage:CannotRetrySuccessfulMessage'
    }

    export const enum CreateInvoice {
      /**
       * When creating an invoice it's required to specify CreditorOrganizationUnitID.
       */
      CreditorRequired = 'CreateInvoice:CreditorRequired'
    }

    export const enum InvoiceAdditionalAmountType {
      /**
       * InvoiceAdditionalAmountType with name `{0:string}` already exists
       */
      AlreadyExists = 'InvoiceAdditionalAmountType:AlreadyExists'
    }

    export const enum InvoiceDispute {
      /**
       * InvoiceDisputeReason with name `{0:string}` already exists
       */
      AlreadyExists = 'InvoiceDispute:AlreadyExists',
      /**
       * InvoiceDisputeReasons with AutoResolve require a LedgerClass
       */
      LedgerClassRequired = 'InvoiceDispute:LedgerClassRequired'
    }

    export const enum ListManualInvoices {
      /**
       * Use at least one filter.
       */
      InvalidRequestMessage = 'ListManualInvoices:InvalidRequestMessage'
    }

    export const enum ListShipmentsToInvoice {
      /**
       * Either ShipFromOrganizationUnitID or ShipToOrganizationUnitID must be specified.
       */
      OrganizationUnitFilterRequired = 'ListShipmentsToInvoice:OrganizationUnitFilterRequired'
    }

    export const enum UpdateInvoice {
      /**
       * When creating an invoice it's required to specify CreditorOrganizationUnitID.
       */
      CreditorRequired = 'UpdateInvoice:CreditorRequired'
    }

    export const enum ExternalFullStockCountService {
      /**
       * A product identifier is missing for line {0:number}.
       */
      MissingProductIdentifierForLine = 'ExternalFullStockCountService:MissingProductIdentifierForLine',
      /**
       * The product identifier for line {0:number} did not resolve to a valid product.
       */
      InvalidProductIdentifierForLine = 'ExternalFullStockCountService:InvalidProductIdentifierForLine',
      /**
       * The StockLabelID for line {0:number} is invalid.
       */
      InvalidStockLabelIDForLine = 'ExternalFullStockCountService:InvalidStockLabelIDForLine'
    }

    export const enum CashDeposit {
      /**
       * SignatureBlobID or SignatureBlobUrl is required
       */
      SignatureRequired = 'CashDeposit:SignatureRequired'
    }

    export const enum CashExpense {
      /**
       * SignatureBlobID is required
       */
      SignatureRequired = 'CashExpense:SignatureRequired',
      /**
       * Device type does not match CashExpenseType
       */
      DeviceTypeMismatch = 'CashExpense:DeviceTypeMismatch'
    }

    export const enum DeleteCashExpense {
      /**
       * Cannot delete cash expense because the cash journal has already been closed.
       */
      CashJournalClosed = 'DeleteCashExpense:CashJournalClosed',
      /**
       * Cannot delete cash expense because the financial period is not open.
       */
      FinancialPeriodClosed = 'DeleteCashExpense:FinancialPeriodClosed'
    }

    export const enum SetEmployeesForFinancialPeriod {
      /**
       * Cannot set commission for some employees and not for others. Either set commission for all employees or none.
       */
      CannotSetPartialCommission = 'SetEmployeesForFinancialPeriod:CannotSetPartialCommission',
      /**
       * The financial period is not pending, so employees cannot be changed.
       */
      FinancialPeriodNotPendingEmployees = 'SetEmployeesForFinancialPeriod:FinancialPeriodNotPendingEmployees',
      /**
       * The commission shares must add up to 100%.
       */
      CommissionMustAddUp = 'SetEmployeesForFinancialPeriod:CommissionMustAddUp'
    }

    export const enum SetLoyaltyProgramForFinancialPeriod {
      /**
       * The financial period is not pending, so the loyalty program cannot be changed.
       */
      FinancialPeriodNotPendingLoyaltyProgram = 'SetLoyaltyProgramForFinancialPeriod:FinancialPeriodNotPendingLoyaltyProgram'
    }

    export const enum CashCorrectionReasons {
      /**
       * A correction reason with this name already exists
       */
      CashCorrectionReasonWithNameAlreadyExists = 'CashCorrectionReasons:CashCorrectionReasonWithNameAlreadyExists',
      /**
       * A correction reason with this backendID already exists
       */
      CashCorrectionReasonWithBackendIDAlreadyExists = 'CashCorrectionReasons:CashCorrectionReasonWithBackendIDAlreadyExists'
    }

    export const enum ReplayEvents {
      /**
       * This event export configuration does not support replaying events
       */
      CannotReplayEvents = 'ReplayEvents:CannotReplayEvents',
      /**
       * This operation is not supported on a replay-configuration
       */
      NotSupportedOnReplay = 'ReplayEvents:NotSupportedOnReplay'
    }

    export const enum Currency {
      /**
       * Currencies are not mutable
       */
      Immutable = 'Currency:Immutable'
    }

    export const enum GetActiveShoppingCartService {
      /**
       * The current organization unit should be a webshop.
       */
      OrganizationUnitShouldBeWebshop = 'GetActiveShoppingCartService:OrganizationUnitShouldBeWebshop'
    }

    export const enum ValidateToken {
      /**
       * Cloud is currently not available
       */
      CloudUnavailable = 'ValidateToken:CloudUnavailable'
    }

    export const enum AddBoardingPassToOrder {
      /**
       * This boarding pass barcode does not match the expected format.
       */
      FormatInvalid = 'AddBoardingPassToOrder:FormatInvalid',
      /**
       * This boarding pass is not valid for this airport.
       */
      InvalidFlight = 'AddBoardingPassToOrder:InvalidFlight'
    }

    export const enum ApplyScriptEdits {
      /**
       * Invalid value for field {Field:string}, expected a string, number, boolean or null but got {ActualValue:string}
       */
      InvalidValue = 'ApplyScriptEdits:InvalidValue'
    }

    export const enum ScriptManager {
      /**
       * Could not load script {0:number}
       */
      CouldNotLoadScript = 'ScriptManager:CouldNotLoadScript'
    }

    export const enum CustomerReturn {
      /**
       * `OriginalOrderTimeStamp` is not allowed in the future
       */
      FutureTimeStampNotAllowed = 'CustomerReturn:FutureTimeStampNotAllowed'
    }

    export const enum CreateInStoreReturn {
      /**
       * This order cannot be returned through this service.
       */
      CannotBeReturned = 'CreateInStoreReturn:CannotBeReturned',
      /**
       * This order cannot be refunded.
       */
      CannotBeRefunded = 'CreateInStoreReturn:CannotBeRefunded'
    }

    export const enum PrintSecondChanceProductPriceLabelService {
      /**
       * No barcode found for product with ID {0:number}
       */
      ProductBarcodeNotFound = 'PrintSecondChanceProductPriceLabelService:ProductBarcodeNotFound'
    }

    export const enum Repairs {
      /**
       * Customer must be attached to case for deferred shipment repair.
       */
      DeferredShippingMustHaveAttachedCustomer = 'Repairs:DeferredShippingMustHaveAttachedCustomer',
      /**
       * Customer must have an email address.
       */
      DeferredShippingCustomerMustHaveEmailAddress = 'Repairs:DeferredShippingCustomerMustHaveEmailAddress',
      /**
       * Either a ProductID or an OrderLineID for a product is required.
       */
      EitherOrderLineIDOrProductIDIsRequired = 'Repairs:EitherOrderLineIDOrProductIDIsRequired',
      /**
       * EVAPay not loaded
       */
      EVAPayNotLoaded = 'Repairs:EVAPayNotLoaded',
      /**
       * EVAPay not configured
       */
      EVAPayNotConfigured = 'Repairs:EVAPayNotConfigured',
      /**
       * Cannot use EVAPay because order has no customer attached
       */
      EVAPayNoCustomer = 'Repairs:EVAPayNoCustomer',
      /**
       * UserTaskID or RepairID must be specified when printing repair thermal receipt
       */
      UserTaskOrRepairIDRequiredWhenPrintingReceipt = 'Repairs:UserTaskOrRepairIDRequiredWhenPrintingReceipt'
    }

    export const enum StockMovementFollowUp {
      /**
       * Invalid quantity
       */
      InvalidQuantity = 'StockMovementFollowUp:InvalidQuantity'
    }

    export const enum ShipFromStoreUserTaskComposer {
      /**
       * Station is required for this step.
       */
      StationRequired = 'ShipFromStoreUserTaskComposer:StationRequired',
      /**
       * Order is not paid and thus cannot be delivered.
       */
      OrderNotPaid = 'ShipFromStoreUserTaskComposer:OrderNotPaid',
      /**
       * Picked quantity is too much.
       */
      ExcessPickedQuantity = 'ShipFromStoreUserTaskComposer:ExcessPickedQuantity',
      /**
       * Can only have 1 line without a quantity for picking orderline {0:number}.
       */
      OnlyOnePickedLineWithoutQuantity = 'ShipFromStoreUserTaskComposer:OnlyOnePickedLineWithoutQuantity',
      /**
       * Can not have multiple picked lines with same product for orderline {0:number}.
       */
      ProductsHaveToBeUnique = 'ShipFromStoreUserTaskComposer:ProductsHaveToBeUnique',
      /**
       * Product {replacementProductID:number} is not a replacement product for {originalProductID:number}.
       */
      NotAReplacementProduct = 'ShipFromStoreUserTaskComposer:NotAReplacementProduct',
      /**
       * Shipped quantity is too much.
       */
      ExcessShippedQuantity = 'ShipFromStoreUserTaskComposer:ExcessShippedQuantity',
      /**
       * Cannot disable pick shipment for stock aggregate products.
       */
      CannotDisablePickShipmentForStockAggregateProducts = 'ShipFromStoreUserTaskComposer:CannotDisablePickShipmentForStockAggregateProducts',
      /**
       * OrderLine {orderLineID:number} is not part of Order {orderID:number} and cannot be shipped as part of it.
       */
      OrderLineNotPartOfOrder = 'ShipFromStoreUserTaskComposer:OrderLineNotPartOfOrder',
      /**
       * A shipment package on a shipment with multiple packages cannot be created without lines. Please add at least one line to the package.
       */
      ShipmentPackageWithoutLines = 'ShipFromStoreUserTaskComposer:ShipmentPackageWithoutLines'
    }

    export const enum ReturnToSupplierTaskErrors {
      /**
       * You can only have one active return to supplier task.
       */
      UserCanOnlyHaveOneActiveReturnToSupplierTask = 'ReturnToSupplierTaskErrors:UserCanOnlyHaveOneActiveReturnToSupplierTask',
      /**
       * Can not exclude more products for shipping then there are available on the shipment.
       */
      CanNotExcludeMoreProductThenPresentOnTheShipment = 'ReturnToSupplierTaskErrors:CanNotExcludeMoreProductThenPresentOnTheShipment',
      /**
       * Can not ship more products then present on the order.
       */
      CanNotShipMoreProductsThenPresentOnTheOrder = 'ReturnToSupplierTaskErrors:CanNotShipMoreProductsThenPresentOnTheOrder',
      /**
       * Task no longer has a linked shipment. You can complete this task.
       */
      NoLinkidShipmentOnTask = 'ReturnToSupplierTaskErrors:NoLinkidShipmentOnTask',
      /**
       * Can not finalize return to supplier order when other tasks are active.
       */
      CanNotFinalizeReturnToSupplierOrderWithOpenTasks = 'ReturnToSupplierTaskErrors:CanNotFinalizeReturnToSupplierOrderWithOpenTasks',
      /**
       * Selected return to supplier task is already started.
       */
      ReturnToSupplierTaskAlreadyStarted = 'ReturnToSupplierTaskErrors:ReturnToSupplierTaskAlreadyStarted'
    }

    export const enum SetLineForReturnToSupplierShipment {
      /**
       * Cannot provide more than one serial number
       */
      CannotProvideMoreThanOneSerialNumber = 'SetLineForReturnToSupplierShipment:CannotProvideMoreThanOneSerialNumber'
    }

    export const enum PriceLabelPrinter {
      /**
       * Product not found
       */
      ProductNotFound = 'PriceLabelPrinter:ProductNotFound'
    }

    export const enum OperationalTaskConfig {
      /**
       * Cannot combine TriggerOnFinancialPeriodClosed with a SchedulingConfig
       */
      CannotCombineTriggerOnFinancialPeriodClosedWithSchedulingConfig = 'OperationalTaskConfig:CannotCombineTriggerOnFinancialPeriodClosedWithSchedulingConfig',
      /**
       * TriggerStartDate cannot be after TriggerEndDate
       */
      TriggerStartDateCannotBeAfterEndDate = 'OperationalTaskConfig:TriggerStartDateCannotBeAfterEndDate',
      /**
       * Trigger dates can only be set when TriggerOnFinancialPeriodClosed is enabled
       */
      TriggerDatesCanOnlyBeSetWhenTriggerOnFinancialPeriodClosedIsEnabled = 'OperationalTaskConfig:TriggerDatesCanOnlyBeSetWhenTriggerOnFinancialPeriodClosedIsEnabled',
      /**
       * Personal tasks require at least one role to be specified
       */
      PersonalTasksRequireRoles = 'OperationalTaskConfig:PersonalTasksRequireRoles'
    }

    export const enum CreateCustomUserTaskType {
      /**
       * Can't create CustomUserTaskType because its name already exists
       */
      CustomUserTaskTypeAlreadyExists = 'CreateCustomUserTaskType:CustomUserTaskTypeAlreadyExists'
    }

    export const enum DeactivateAllUserTasks {
      /**
       * Could not deactivate all user tasks for this environment.
       */
      InvalidEnvironment = 'DeactivateAllUserTasks:InvalidEnvironment'
    }

    export const enum UserTaskNotCompletedReasonErrors {
      /**
       * Can't create UserTaskNotCompletedReason because its name already exists
       */
      UserTaskNotCompletedReasonAlreadyExists = 'UserTaskNotCompletedReasonErrors:UserTaskNotCompletedReasonAlreadyExists',
      /**
       * Cannot update a system UserTaskNotCompletedReason
       */
      CannotUpdateSystemUserTaskNotCompletedReason = 'UserTaskNotCompletedReasonErrors:CannotUpdateSystemUserTaskNotCompletedReason'
    }

    export const enum UserTaskPriorityServices {
      /**
       * This User Task Priority already exists
       */
      UserTaskPriorityAlreadyExists = 'UserTaskPriorityServices:UserTaskPriorityAlreadyExists',
      /**
       * Cannot modify the Default User Task Priority
       */
      CannotModifyDefaultPriority = 'UserTaskPriorityServices:CannotModifyDefaultPriority'
    }

    export const enum CompleteZonedCycleCounts {
      /**
       * Deviation Reason is required for zoned cycle count {0:number}
       */
      DeviationReasonRequired = 'CompleteZonedCycleCounts:DeviationReasonRequired',
      /**
       * There are still PreCount tasks that aren't yet completed for ZonedCycleCount {0:number}
       */
      PreCountsNotCompleted = 'CompleteZonedCycleCounts:PreCountsNotCompleted'
    }

    export const enum CreateZonedCycleCountService {
      /**
       * Cannot create cycle count for product {productID:number} in organization unit {ouID:number} because {reason:string}
       */
      CannotCreateCount = 'CreateZonedCycleCountService:CannotCreateCount'
    }

    export const enum CycleCountZoneGroup {
      /**
       * This name is already in use
       */
      DuplicateName = 'CycleCountZoneGroup:DuplicateName'
    }

    export const enum ZonedCycleCountSchedule {
      /**
       * Date needs to be at least one day in the future.
       */
      DateTooSoon = 'ZonedCycleCountSchedule:DateTooSoon',
      /**
       * Require at least a product query or filter to be set.
       */
      NoProductFilters = 'ZonedCycleCountSchedule:NoProductFilters',
      /**
       * Require at least a Date or CycleCountIntervalInDays set.
       */
      NoDateOrInterval = 'ZonedCycleCountSchedule:NoDateOrInterval'
    }

    export const enum SecondChangeProductRegistration {
      /**
       * Product does not match expected product for the given usertask.
       */
      ProductMismatch = 'SecondChangeProductRegistration:ProductMismatch',
      /**
       * MimeType {MimeType:string} for BlobID {BlobID:string} is an invalid MimeType for an image
       */
      InvalidMimeTypeForImage = 'SecondChangeProductRegistration:InvalidMimeTypeForImage'
    }

  }


  export interface AsyncRequestResponse {
    JobID: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ServiceError {
    /**
     * A human-readable message describing the error.
     */
    Message: string;
    /**
     * A short description of the error type.
     */
    Type: string;
    /**
     * A unique ID identifying this error.
     */
    Code: string;
    /**
     * A unique ID identifying the request. Please provide this ID when contacting support.
     */
    RequestID: string;
    Data?: any;
  }

  export interface ResponseMessageMetadata {
    /**
     * When using the `ExternalIDs` mode, this will hold the resolved external IDs.
     */
    ExternalIDs?: { [key: string]: { [key: string]: string } };
    /**
     * When using the `ExternalIDs` mode, this will hold the external IDs we couldn't resolve.
     */
    UnresolvedExternalIDs?: { [key: string]: string[] };
    /**
     * This is a flag indicating whether the async request is done. If it is `null`, it is not an async service. If it is `false`, the response is not yet available. Do not process the properties in that case. It is is `true` the properties are filled with the result of the call.
     */
    IsAsyncResultAvailable?: boolean;
  }

  export interface AsyncRequestResultRequest {
    JobID: string;
  }

  /**
   * Lists tax code mappings.
   */
  export interface ListTaxCodeMappings {
    InitialPageConfig?: PageTokenConfig<ListTaxCodeMappingsFilter>;
    PageToken?: string;
  }

  export interface PageTokenConfig<T = { [key: string]: string }> {
    Filter?: Partial<T>;
    /**
     * Min: 1
     */
    Limit?: number;
  }

  export interface ListTaxCodeMappingsFilter {
    TaxCodeID?: number;
    TaxProviderID?: number;
    BackendID?: string;
  }

  export interface ListTaxCodeMappingsResponse {
    Results?: TaxCodeMappingDto[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface TaxCodeMappingDto {
    /**
     * Entity type: TaxCodeMapping
     */
    ID: number;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID: number;
    /**
     * Entity type: TaxProvider
     */
    TaxProviderID: number;
    BackendID: string;
  }

  /**
   * Create a new TaxCodeMapping. Only one mapping per TaxCode & TaxProvider is allowed.
   */
  export interface CreateTaxCodeMapping {
    BackendID: string;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID: number;
    /**
     * Entity type: TaxProvider
     */
    TaxProviderID: number;
  }

  export interface CreateTaxCodeMappingResponse {
    /**
     * Entity type: TaxCodeMapping
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update an existing TaxCodeMapping. Only one mapping per TaxCode & TaxProvider is allowed.
   */
  export interface UpdateTaxCodeMapping {
    /**
     * Entity type: TaxCodeMapping
     */
    ID: number;
    BackendID?: string;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID?: number;
    /**
     * Entity type: TaxProvider
     */
    TaxProviderID?: number;
  }

  export interface EmptyResponseMessage {
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Delete a tax mapping.
   */
  export interface DeleteTaxCodeMapping {
    /**
     * Entity type: TaxCodeMapping
     */
    ID: number;
  }

  /**
   * Lists tax providers.
   */
  export interface ListTaxProviders {
    InitialPageConfig?: PageTokenConfig<ListTaxProvidersFilter>;
    PageToken?: string;
  }

  export interface ListTaxProvidersFilter {
    Name?: string;
    Type?: string;
  }

  export interface ListTaxProvidersResponse {
    Results?: TaxProviderDto[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface TaxProviderDto {
    /**
     * Entity type: TaxProvider
     */
    ID?: number;
    Name?: string;
    Type?: string;
    BackendID?: string;
    Description?: string;
    Configuration?: { [key: string]: any };
  }

  /**
   * Create a new TaxProvider
   */
  export interface CreateTaxProvider {
    Name: string;
    Type: string;
    BackendID?: string;
    Description?: string;
    Configuration?: any;
  }

  export interface CreateTaxProviderResponse {
    /**
     * Entity type: TaxProvider
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update an existing TaxProvider
   */
  export interface UpdateTaxProvider {
    /**
     * Entity type: TaxProvider
     */
    ID: number;
    Name?: string;
    Type?: string;
    Description?: string;
    BackendID?: string;
    /**
     * Updating a configuration means overwriting the previous one. If the update will contain a type change, the configuration will be reset to null unless otherwise specified.
     */
    Configuration?: any;
  }

  /**
   * Delete a TaxProvider
   */
  export interface DeleteTaxProvider {
    /**
     * Entity type: TaxProvider
     */
    ID: number;
  }

  /**
   * Get the available tax provider types.
   */
  export interface GetTaxProviderTypes {
  }

  export interface GetTaxProviderTypesResponse {
    Types: string[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get a tax provider by ID.
   */
  export interface GetTaxProvider {
    /**
     * Entity type: TaxProvider
     */
    ID: number;
  }

  export interface GetTaxProviderResponse {
    TaxProvider: TaxProviderDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Requests a magic login link, which will send an email to the user (if found).
   * 
   * - Setting `MagicLink:Enabled` must be enabled explicitly
   * - When using a `RedirectUrl`, configure setting `MagicLink:RedirectDomains` to whitelist supported redirect hosts (recommended!)
   * 
   * Using the returned `RequestToken`, you can either subscribe to the `/magicLink` SignalR hub, or poll the `CheckMagicLink` service. As soon as the emailed magic link is clicked, that hub and service
   * will return either a `TemporaryToken` you can call `Login` with for this user, or an `APIKey` that's already valid and ready to proceed with.
   * 
   * - The email sent contains a link that will work for 10 minutes
   * - When clicked, this will generate either a `TemporaryToken` that can be used to `Login` with for 3 minutes, or an `ApiKey` that can be used for 1 hour
   * - This data is additionally exposed through `CheckMagicLink` for 1 minute after clicking
   * - When using a `TemporaryToken` to log in with, the resulting `AuthenticationToken` is valid for 1 week (or `SessionDuration:MagicLink`) and will refresh every time when used
   * 
   * Finally, when specifying `IncludeManualCode`, the email sent will also contain a short code for the user to _manually_ input into your application - call `ConfirmMagicLink` with both the `RequestToken`
   * and that `ManualCode` to obtain either the `TemporaryToken` or `ApiKey` like above, when valid.
   */
  export interface SendMagicLink {
    EmailAddress: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    RedirectUrl?: string;
    IncludeManualCode?: boolean;
  }

  export interface SendMagicLinkResponse {
    RequestToken: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Confirms a magic login by `ManualCode`.
   */
  export interface ConfirmMagicLink {
    RequestToken: string;
    ManualCode?: string;
  }

  export interface ConfirmMagicLinkResponse {
    TemporaryToken?: string;
    ApiKey?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Checks if a magic login was confirmed already.
   */
  export interface CheckMagicLink {
    RequestToken: string;
  }

  export interface CheckMagicLinkResponse {
    TemporaryToken?: string;
    ApiKey?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get the AvailableGiftCardConfigurations taking into account the OrganizationUnitID from ClientContext.
   * 
   * `GiftCardConfiguration`: an item that describes the giftcard properties of a product with type GiftCard
   */
  export interface GetAvailableGiftCardConfigurations {
  }

  export interface GetAvailableGiftCardConfigurationsResponse {
    GiftCardConfigurations: GetAvailableGiftCardConfigurationsResponse.AvailableGiftCardConfigurationDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetAvailableGiftCardConfigurationsResponse {
    export interface AvailableGiftCardConfigurationDto {
      /**
       * Entity type: GiftCardConfiguration
       */
      ID: number;
      Name: string;
      Handler: string;
      CardType?: string;
      UsageType: GiftCardConfigurationUsageTypes;
      AllowRefundWithoutTransaction: boolean;
      AllowCurrencyConversion: boolean;
    }

  }

  export const enum GiftCardConfigurationUsageTypes {
    None = 0,
    Sale = 1,
    Payment = 2
  }

  /**
   * Gets the initialization state for the EVA environment.
   * Can either way be Created or Initialized.
   * If Created, the environment is not configured and can not be used.
   * If Initialized, the environment is configured and ready to be used.
   */
  export interface GetInitializationState {
  }

  export interface InitializationStateResponse {
    InitializationState: EnvironmentInitializationState;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum EnvironmentInitializationState {
    Created = 0,
    Initialized = 1
  }

  /**
   * Get the CheckoutOptions
   */
  export interface GetCheckoutOptions {
    Filters?: GetCheckoutOptionsFilter;
  }

  export interface GetCheckoutOptionsFilter {
    Name?: string;
    Handler?: string;
    IsActive?: boolean;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export interface GetCheckoutOptionsResponse {
    Options: CheckoutOptionDto[];
    Categories: CheckoutOptionCategoryDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface CheckoutOptionDto {
    /**
     * Entity type: CheckoutOption
     */
    ID: number;
    /**
     * Entity type: CheckoutOptionCategory
     */
    CategoryID?: number;
    CategoryName: string;
    CategoryDescription?: string;
    IsActive: boolean;
    Name: string;
    Description?: string;
    Handler: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    OrganizationUnitSetName?: string;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    ScriptName: string;
    Sequence: number;
    ConfigData?: { [key: string]: any };
  }

  export interface CheckoutOptionCategoryDto {
    /**
     * Entity type: CheckoutOptionCategory
     */
    ID: number;
    Name: string;
    Description?: string;
    Sequence: number;
  }

  export interface PageConfig<T = { [key: string]: string }> {
    Filter?: Partial<T>;
    /**
     * @default 0
     * Min: 0
     */
    Start?: number;
    /**
     * @default 50
     * Range: 1-10000
     */
    Limit?: number;
    SortProperty?: string;
    /**
     * @default Ascending
     */
    SortDirection?: SortDirection;
  }

  export const enum SortDirection {
    Ascending = 0,
    Descending = 1
  }

  export interface PagedResult<TModel> {
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
    Page?: TModel[];
    Offset?: number;
    Limit?: number;
    Total?: number;
    SortProperty?: string;
    SortDirection?: SortDirection;
    Filters?: { [key: string]: string };
    NumberOfPages?: number;
    CurrentPage?: number;
  }

  export const enum AuditingFieldDataType {
    String = 0,
    Bool = 1,
    Integer = 2,
    Decimal = 3
  }

  export interface ResourceResponseMessage {
    Url: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum AuditingFiscalIDValidationResult {
    Unknown = 0,
    Success = 1,
    Failure = -1
  }

  export interface ListBlobsForDocumentationFilter {
    Category?: string;
    OriginalName?: string;
  }

  export interface ListBlobsForStencilFilter {
    OriginalName?: string;
  }

  export interface ResourceInfo {
    Url: string;
    BlobID: string;
  }

  export const enum FinancialEventTypes {
    Sales = 10,
    SalesTax = 11,
    SalesDiscounts = 12,
    Purchase = 20,
    PurchaseTax = 21,
    PurchasePriceVariance = 22,
    PurchaseInvoiceDispute = 23,
    PurchaseInvoiceDisputeResolved = 24,
    PurchaseDiscounts = 25,
    CostOfGoods = 30,
    Payment = 40,
    PaymentEndRounding = 41,
    PaymentSettlement = 42,
    PaymentCapture = 43,
    PaymentRelease = 44,
    CashAdjustment = 50,
    StockMutation = 60,
    StockMutationAutomaticCorrection = 61,
    StockSold = 62,
    StockReceived = 63,
    Shipment = 70
  }

  export const enum UserTypes {
    None = 0,
    Employee = 1,
    Customer = 2,
    Anonymous = 4,
    Business = 8,
    System = 17,
    Debtor = 64,
    Tester = 512,
    RemovedByRequest = 1024,
    Api = 2048,
    Impersonated = 4096
  }

  export const enum FunctionalityScope {
    None = 0,
    Create = 1,
    Edit = 2,
    Delete = 4,
    View = 8,
    Manage = 31,
    Settings = 32,
    Scripting = 64,
    All = 127
  }

  export const enum ElevationType {
    None = 0,
    Elevation = 1,
    Verification = 2
  }

  export const enum AuditChainTypes {
    EventLedger = 0,
    InvoiceTotals = 1,
    FinancialPeriodTotals = 2,
    MonthlyFinancialReportingPeriodTotals = 3,
    YearlyFinancialReportingPeriodTotals = 4,
    InvoicePrint = 5,
    Invoice = 6,
    FinancialPeriodAudit = 7,
    InvoiceReprint = 8,
    TerminalTotals = 9,
    FinancialPeriod = 10,
    WorkingDocument = 11,
    TaxFreeForm = 12
  }

  export interface TOTPSecretWrapper {
    NextWeek: string;
    CurrentWeek: string;
    WeekNumber: number;
  }

  export interface AddressDataDto {
    FirstName?: string;
    LastName?: string;
    HouseNumber?: string;
    Address1?: string;
    Address2?: string;
    Remark?: string;
    ZipCode?: string;
    Subdistrict?: string;
    District?: string;
    City?: string;
    State?: string;
    Region?: string;
    /**
     * ISO 3166-2
     * Entity type: CountrySubdivision
     */
    CountrySubdivisionID?: string;
    CountrySubdivisionName?: string;
    /**
     * ISO 3166-1
     * Entity type: Country
     */
    CountryID?: string;
    Latitude?: number;
    Longitude?: number;
    PhoneNumber?: string;
    EmailAddress?: string;
  }

  export const enum TaxRateCategory {
    High = 0,
    Low = 1,
    Zero = 2,
    Exempt = 3,
    Intermediate = 4,
    Dynamic = 5
  }

  export const enum ReturnReasonType {
    OrganizationUnit = 0,
    Customer = 1
  }

  export const enum OrderBlobTypes {
    None = 0,
    Invoice = 1,
    InvoiceThermal = 2,
    ReturnLabel = 3,
    ReturnForm = 4,
    ShipmentLabel = 5,
    Identification = 6,
    PackingSlip = 7,
    PickSlip = 8,
    ThermalPrint = 9,
    PinReceipt = 10,
    Export = 11,
    ElectronicReceipt = 12,
    TaxFreeForm = 13,
    Offline = 14,
    AMLSurvey = 15,
    ThermalReceiptArchive = 16
  }

  export const enum InvoiceLineTypes {
    Default = 0,
    Discount = 1,
    Return = 2
  }

  export const enum InvoiceStatuses {
    Open = 0,
    Closed = 1
  }

  export const enum InvoiceTypes {
    Sales = 0,
    Purchase = 1,
    ControlDocument = 2,
    InitializationDocument = 3,
    ClosingDocument = 4,
    MonthlyControlDocument = 5,
    YearlyControlDocument = 6,
    IntegrityCheckDocument = 7,
    Offer = 8
  }

  export interface CompanyDto {
    /**
     * Entity type: Company
     */
    ID?: number;
    BackendID?: string;
    Name?: string;
    RegistrationNumber?: string;
    TaxRegistrationNumber?: string;
    TaxOfficeNumber?: string;
    FiscalID?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    RegistrationCountryID?: string;
    RegistrationCountrySubdivisionID?: string;
    TaxRecipientCode?: string;
    TaxRecipientEmail?: string;
    BillingAddress?: AddressDto;
    ShippingAddress?: AddressDto;
    SingleUse?: boolean;
    IsInvoicing?: boolean;
    /**
     * @deprecated Use `TaxRegistrationNumber` instead.
     */
    VatNumber?: string;
    /**
     * @deprecated Use `EmailAddress` instead.
     */
    ContactEmailAddress?: string;
    /**
     * @deprecated Use `PhoneNumber` instead.
     */
    ContactPhoneNumber?: string;
    /**
     * @deprecated Use `EmailAddress` instead.
     */
    InvoiceEmailAddress?: string;
    /**
     * @deprecated The property `RegistrationCity` will be obsolete
     */
    RegistrationCity?: string;
    /**
     * @deprecated The property `VisitorsAddress` will be obsolete
     */
    VisitorsAddress?: AddressDto;
    /**
     * @deprecated Use `BillingAddress` instead
     */
    InvoiceAddress?: AddressDto;
    /**
     * @deprecated The property `RegistrationAddress` will be obsolete
     */
    RegistrationAddress?: AddressDto;
    /**
     * @deprecated The property `EstablishedDate` will be obsolete
     */
    EstablishedDate?: string;
    /**
     * @deprecated The property `AccountHolderName` will be obsolete
     */
    AccountHolderName?: string;
    /**
     * @deprecated The property `IBAN` will be obsolete
     */
    IBAN?: string;
    /**
     * @deprecated The property `BIC` will be obsolete
     */
    BIC?: string;
    /**
     * @deprecated The property `LogoID` will be obsolete
     */
    LogoID?: string;
  }

  export interface AddressDto {
    /**
     * Entity type: Address
     */
    ID: number;
    FirstName?: string;
    LastName?: string;
    HouseNumber?: string;
    Address1?: string;
    Address2?: string;
    Remark?: string;
    ZipCode?: string;
    Subdistrict?: string;
    District?: string;
    City?: string;
    State?: string;
    Region?: string;
    /**
     * ISO 3166-2
     * Entity type: CountrySubdivision
     */
    CountrySubdivisionID?: string;
    CountrySubdivisionName?: string;
    /**
     * ISO 3166-1
     * Entity type: Country
     */
    CountryID?: string;
    Latitude?: number;
    Longitude?: number;
    PhoneNumber?: string;
    EmailAddress?: string;
  }

  export const enum InvoiceDocumentLedgerTypes {
    Physical = 0,
    Digital = 1
  }

  export interface InvoiceDocumentLedgerData {
    PaperProperties: PaperProperties;
  }

  export interface PaperProperties {
    WaitForNetworkIdle: boolean;
    WaitForJS: boolean;
    Size: PaperProperties.PaperSize;
    Format?: PaperFormats;
    Orientation?: PaperOrientations;
    Margin: PaperProperties.PaperMargin;
    ThermalPrinterTemplateType?: ThermalPrinterTemplateTypes;
  }

  export namespace PaperProperties {
    export interface PaperMargin {
      Top?: number;
      Left?: number;
      Bottom?: number;
      Right?: number;
    }

    export interface PaperSize {
      Width: string;
      Height: string;
      DeviceScaleFactor?: number;
    }

  }

  export const enum PaperFormats {
    A3 = 1,
    A4 = 2,
    A5 = 3,
    Legal = 4,
    Letter = 5,
    Tabloid = 6,
    Auto = 7,
    Ledger = 8,
    A0 = 9,
    A1 = 10,
    A2 = 11,
    A6 = 12
  }

  export const enum PaperOrientations {
    Portrait = 1,
    Landscape = 2
  }

  export const enum ThermalPrinterTemplateTypes {
    Xml = 0,
    Html = 1
  }

  export const enum InvoiceDocumentLedgerFormats {
    Receipt = 0,
    Invoice = 1
  }

  export const enum InvoiceCalculationMethod {
    InTax = 0,
    ExTax = 1,
    InTaxNew = 2,
    ExTaxNew = 3
  }

  export const enum TaskState {
    Scheduled = 1,
    Running = 2,
    Completed = 3
  }

  export interface WatchtowerLog {
    Date: string;
    Message: string;
  }

  export const enum OrganizationUnitStatus {
    Default = 0,
    Open = 1,
    Closed = 2,
    OpeningSoon = 4,
    TemporarilyClosed = 8,
    Sale = 16,
    Hidden = 32
  }

  /**
   * Generate a barcode image.
   * 
   * The `Format` is one of;
   * 
   * - QR = 0
   * - EAN = 1
   * - Code39 = 2
   * - Code128 = 3
   * 
   * :lock: This is the safer variant to our `/barcode` endpoint, because the data moves _inside_ the POST body instead of through GET query params
   * :bulb: You can use the returned `Data` in combination with `MimeType` to render the image directly, for example;
   * 
   * ```
   *   <img src='data:{MimeType};base64,{Data}' />
   * ```
   */
  export interface Barcode {
    /**
     * Range: 10-1000
     */
    Width?: number;
    /**
     * Range: 10-1000
     */
    Height?: number;
    Code?: string;
    Format?: Barcode.BarcodeFormat;
    BlobID?: string;
    NoMargin?: boolean;
    NoText?: boolean;
    BackgroundHex?: string;
    ForegroundHex?: string;
  }

  export namespace Barcode {
    export const enum BarcodeFormat {
      QR = 0,
      EAN = 1,
      Code39 = 2,
      Code128 = 3
    }

  }

  export interface BarcodeResponse {
    MimeType: string;
    Data: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for sending a contact form to the email set in settings called `ContactForm:MailTo`
   */
  export interface SendContactForm {
    Type?: string;
    Properties?: { [key: string]: string };
  }

  /**
   * Creates an API key for specified user
   */
  export interface CreateApiKey {
    /**
     * Requires a user of type API, unless `ApiKeyForNonAPIUsers` setting is enabled
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * To request a permanent key, set this to true. The key will not expire.
     */
    RequestPermanentApiKey?: boolean;
    /**
     * When set, the key will be locked to the organization unit, so the key can't be used to access different OrganizationUnits
     */
    LockApiKeyToOrganizationUnit?: boolean;
    /**
     * Strict API keys will not automatically identify as employees, and so have restricted access to only the functionalities assigned to it
     */
    Strict?: boolean;
    Description?: string;
    /**
     * Will default to setting `ApiKeyExpirationInDays` when null and `RequestPermanentApiKey` is false
     */
    ExpirationDate?: string;
  }

  export interface CreateApiKeyResponse {
    /**
     * Entity type: ApiKey
     */
    ID: number;
    ApiKey: string;
    ExpirationDate?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update an exisiting API key
   * 
   * All other properties need a new key to be created as these would influence the token authorization.
   */
  export interface UpdateApiKey {
    /**
     * Entity type: ApiKey
     */
    ID: number;
    Description?: string;
  }

  /**
   * List API keys, optionally filtered.
   */
  export interface ListApiKeys {
    InitialPageConfig?: PageTokenConfig<ListApiKeysFilter>;
    PageToken?: string;
  }

  export interface ListApiKeysFilter {
    /**
     * Entity type: User
     */
    UserID?: number;
  }

  export interface ListApiKeysResponse {
    Results?: ListKeysItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListKeysItem {
    /**
     * Entity type: ApiKey
     */
    ID: number;
    /**
     * Entity type: User
     */
    UserID: number;
    UserName: string;
    /**
     * Entity type: User
     */
    CreatedByUserID: number;
    CreatedByUserName: string;
    IsActive: boolean;
    ExpirationDate?: string;
    CreationTime: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OrganizationUnitName: string;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    Description: string;
    IsLockedToOrganizationUnit: boolean;
    IsStrict: boolean;
    LastAccessTime?: string;
  }

  /**
   * Deletes an API key
   */
  export interface DeleteApiKey {
    /**
     * Entity type: ApiKey
     */
    KeyID: number;
  }

  /**
   * Attaches an user to a consumer company.
   */
  export interface AttachUserToConsumerCompany {
    /**
     * Entity type: User
     */
    UserID: number;
    /**
     * Entity type: Company
     */
    CompanyID: number;
  }

  /**
   * Change the password of a user.
   * 
   * When invalid, the service will return a 400 BAD REQUEST;
   * 
   * - SecurityPolicy:UserOrPasswordInvalid
   * - SecurityPolicy:TooShort
   * - SecurityPolicy:TooLong
   * - SecurityPolicy.NewPasswordIsRequired
   * - SecurityPolicy.Pwned
   * - General
   */
  export interface ChangeUserPassword {
    NewPassword: string;
    OldPassword: string;
  }

  /**
   * Checks if the given EmailAddress is available to create an account for.
   * 
   * When creating Employee accounts, the `AsEmployee` property should be set to true.
   */
  export interface CheckEmailAddressAvailability {
    EmailAddress: string;
    AsEmployee?: boolean;
  }

  export interface CheckUsernameAvailabilityResponse {
    /**
     * Indicates if the username is available.
     */
    IsAvailable: boolean;
    /**
     * Indicates that the username is not available, but only exists in the external user provider.
     */
    IsExternal: boolean;
    /**
     * Indicates if the username is valid.
     */
    IsValid: boolean;
    /**
     * Indicates if a password reset is required.
     */
    PasswordResetRequired: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Checks if the given Nickname is available to create an account for.
   * 
   * When creating Employee accounts, the `AsEmployee` property should be set to true.
   */
  export interface CheckNicknameAvailability {
    Nickname: string;
    AsEmployee?: boolean;
  }

  /**
   * Creates a API user
   */
  export interface CreateApiUser {
    User: CreateApiUser.ApiUser;
  }

  export namespace CreateApiUser {
    export interface ApiUser {
      Name: string;
      Nickname: string;
    }

  }

  export interface CreateApiUserResponse {
    Result: CreateApiUserResults;
    /**
     * Entity type: User
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum CreateApiUserResults {
    CreatedApiUser = 0,
    NicknameInUse = 1
  }

  /**
   * Creates a customer.
   * 
   * This is allowed when you are an employee, or by anonymous if the CustomerCanRegister (default true) is enabled.
   * 
   * Be sure to handle errors for registering, which could be (amongst others);
   * 
   *   * InvalidEmailAddress
   *   * EmailAddressInUse
   *   * NicknameInUse
   *   * FiscalIDInUse
   */
  export interface CreateCustomer {
    User: CreateCustomer.Customer;
    /**
     * Is this a Standard/Basic/Incognito account?
     * @default Standard
     */
    AccountType?: UserAccountType;
    /**
     * Set to `true` to automatically authenticate as this new user.
     * @default false
     */
    AutoLogin?: boolean;
    /**
     * Automatically attach the new customer to the order identified by `OrderID`.
     * @default true
     */
    AttachToOrder?: boolean;
    /**
     * Identifier for the order to automatically attach the new customer to (see `AttachToOrder` parameter).
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Optional associations to other users, e.g. child, parent, neighbour, friend, colleague, ...
     */
    Associations?: CreateCustomer.UserAssociations;
  }

  export namespace CreateCustomer {
    export interface Customer {
      /**
       * Ignored if the user calling this service is not an employee
       */
      BackendID?: string;
      EmailAddress?: string;
      Gender?: string;
      Initials?: string;
      FirstName?: string;
      LastName?: string;
      PhoneNumber?: string;
      DateOfBirth?: string;
      PlaceOfBirth?: string;
      BankAccount?: string;
      Nickname?: string;
      Password?: string;
      /**
       * Entity type: Language
       */
      LanguageID?: string;
      /**
       * Entity type: Country
       */
      CountryID?: string;
      FiscalID?: string;
      SocialSecurityNumber?: string;
      /**
       * Entity type: UserOrigin
       */
      OriginID?: number;
      Title?: string;
      Salutation?: string;
      TimeZone?: string;
      ShippingAddress?: AddressDataDto;
      ShippingAddressDescription?: string;
      BillingAddress?: AddressDataDto;
      BillingAddressDescription?: string;
      Company?: CreateCustomer.CustomerCompany;
      /**
       * Entity type: OrganizationUnit
       */
      PreferredStoreID?: number;
      CustomID?: string;
      BackendRelationID?: string;
      /**
       * Optional additional custom fields
       */
      CustomFields?: CustomFieldKeyValue[];
      /**
       * Can only be set when used from an Employee or API type user, will be ignored otherwise
       */
      PricingGroupID?: string;
      IsSingleSignOnOnly?: boolean;
    }

    export interface CustomerCompany {
      /**
       * Entity type: Company
       */
      ID?: number;
      Name?: string;
      RegistrationNumber?: string;
      VatNumber?: string;
      FiscalID?: string;
    }

    export interface UserAssociations {
      /**
       * The new user is something *to* existing users, e.g. it is a parent to X
       */
      PrimaryAssociations?: UserAssociations.UserAssociation[];
      /**
       * The new user is something *of* existing users, e.g. it is the child of Y
       */
      RelatedAssociations?: UserAssociations.UserAssociation[];
    }

    export namespace UserAssociations {
      export interface UserAssociation {
        /**
         * Entity type: User
         */
        UserID: number;
        /**
         * Entity type: UserAssociationType
         */
        TypeID: number;
      }

    }

  }

  export interface CustomFieldKeyValue {
    /**
     * Identifier for the custom field
     * Entity type: CustomField
     */
    CustomFieldID: number;
    /**
     * Used for datatype String, Text and Enum
     */
    StringValue?: string;
    /**
     * Used for datatype Blob
     */
    BlobValue?: string;
    /**
     * Used for datatype Integer and Decimal
     */
    NumberValue?: number;
    /**
     * Used for datatype Bool
     */
    BoolValue?: boolean;
    /**
     * Used for datatype DateTime and Date
     */
    DateTimeValue?: string;
    /**
     * Used for multiple values
     */
    ArrayValues?: CustomFieldValue[];
  }

  export interface CustomFieldValue {
    /**
     * Used for datatype String, Text and Enum
     */
    StringValue?: string;
    /**
     * Used for datatype Blob
     */
    BlobValue?: string;
    /**
     * Used for datatype Integer and Decimal
     */
    NumberValue?: number;
    /**
     * Used for datatype Bool
     */
    BoolValue?: boolean;
    /**
     * Used for datatype DateTime and Date
     */
    DateTimeValue?: string;
    /**
     * Used for multiple values
     */
    ArrayValues?: CustomFieldValue[];
  }

  export const enum UserAccountType {
    Standard = 0,
    Basic = 1,
    Incognito = 2
  }

  export interface CreateCustomerResponse {
    User: LoggedInUserDto;
    Barcode: string;
    Result: CreateCustomerResults;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface LoggedInUserDto {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs: number[];
    /**
     * Entity type: VisibilityGroup
     */
    VisibilityGroupIDs: number[];
    /**
     * Entity type: OrganizationUnit
     */
    CurrentOrganizationID?: number;
    CurrentOrganizationName?: string;
    /**
     * Entity type: Currency
     */
    CurrentCurrencyID: string;
    AuthenticationToken: string;
    RefreshToken?: string;
    RefreshTokenExpireDate?: string;
    Functionalities: Record<'None' | 'Elevation' | 'Verification', { [key: string]: FunctionalityScope }>;
    CurrentOrganizationUnitType: OrganizationUnitTypes;
    /**
     * Entity type: Country
     */
    CurrentCountryID: string;
    /**
     * Entity type: Language
     */
    CurrentLanguageID: string;
    /**
     * Entity type: Assortment
     */
    CurrentAssortmentID: number;
    /**
     * Entity type: User
     */
    ID: number;
    BackendID: string;
    CustomID: string;
    EmployeeNumber: string;
    BackendRelationID: string;
    EmailAddress: string;
    EmailAddressValidated: boolean;
    Initials: string;
    FirstName: string;
    LastName: string;
    FullName: string;
    DateOfBirth?: string;
    PlaceOfBirth: string;
    Gender: string;
    Type: UserTypes;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    IsDeleted: boolean;
    AccountType: UserAccountType;
    SingleSignOnOnly: boolean;
    AllowPasswordLogin: boolean;
    Nickname: string;
    Company: CompanyDto;
    BankAccount: string;
    IsDebtor: boolean;
    PhoneNumber: string;
    GravatarHash: string;
    Data: { [key: string]: string };
    TimeZone: string;
    FiscalID: string;
    SocialSecurityNumber: string;
    Title: string;
    Salutation: string;
    CreationTime: string;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    CreatedByFullName: string;
    /**
     * Entity type: VisibilityGroup
     */
    VisibilityGroupID?: number;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions: { [key: number]: CustomFieldValueWithOptions };
    Barcode: string;
    LastSuccessfulLogin?: string;
  }

  export const enum OrganizationUnitTypes {
    None = 0,
    /**
     * A shop represents a physical store where products can be sold.
     */
    Shop = 1,
    /**
     * A WebShop represents an online channel that allows delivery and reservation orders, but no carry out sales.
     */
    WebShop = 2,
    /**
     * A container is an OrganizationUnit purely used to group some other OrganizationUnits, to allow easier configuration.
     */
    Container = 4,
    /**
     * Pickup can be combined with type Shop to allow reservation orders in the store.
     */
    Pickup = 8,
    /**
     * A warehouse represents an OrganizationUnit where delivery orders can be shipped. The stock of these organizationunits can be made available for delivery orders from (web)shops.
     */
    Warehouse = 16,
    /**
     * A Country is a special case of the Container type that represents a Country division in the OrganizationUnits structure.
     */
    Country = 36,
    /**
     * A shop can be flagged as franchiser to allow some special flows.
     */
    Franchise = 64,
    /**
     * The type EVA indicates that the shop is running EVA in the store. This will trigger Tasks etc that will not be generated for Shops that are not (yet) converted to running EVA. P/a non-EVA stores will receive an email for pickupordrs instead of a StockReservationTask.
     */
    EVA = 128,
    /**
     * TestOrganizationUnit can be used to test some things in a production environment. This is not advised :warning:. These stores will be excluded from a lot of processes.
     */
    TestOrganizationUnit = 256,
    /**
     * OrganizationUnits with DisableLogin cannot be selected in the Login process.
     */
    DisableLogin = 512,
    /**
     * @deprecated The Supplier naming was unclear, renamed to ExternalSupplier to better convey the meaning.
     * Suppliers are used to replenish warehouses or to export BackOrder/MTO-Products. These OrganizationUnits can have their own set of SupplierProducts, prices and stock.
     */
    Supplier = 1024,
    /**
     * An external supplier is an organization that is not part of your internal organization structure but that you would still like to have available in EVA to for example create purchase Orders for to replenish your warehouse or stores.
     */
    ExternalSupplier = 1024,
    /**
     * Some suppliers deliver their stock in consignment.
     */
    Consignment = 3072,
    /**
     * For Business-to-business orders this type can be set. Orders in these organizationunits will be ex-tax.
     */
    B2b = 4096,
    /**
     * A Region is a special case of the Container type that represents a subdivision under Country OrganizationUnits.
     */
    Region = 8196,
    /**
     * An OrganizationUnit that is meant to be used by customers for returning Orders.
     */
    ReturnsPortal = 16384,
    /**
     * An OrganizationUnit that is meant to be invoiced for restitutions.
     */
    Restitution = 32768,
    /**
     * An OrganizationUnit that also does repairs.
     */
    RepairCenter = 65536,
    /**
     * An OrganizationUnit that is mobile. This indicates that it might have a different address for every financial period.
     */
    Mobile = 131072,
    /**
     * An OrganizationUnit representing a Store-In-Store.
     */
    ConcessionStore = 262144,
    /**
     * A virtual organization unit used to create more flexible supplier hierarchies.
     */
    Virtual = 524288
  }

  export interface CustomFieldResponse {
    Options: CustomFieldOptions;
    Value?: any;
    IsEditableByUser: boolean;
    /**
     * Entity type: CustomField
     */
    CustomFieldID: number;
    Name: string;
    DisplayName?: string;
    DataType: string;
    DataTypeID: number;
    BackendID?: string;
    IsArray: boolean;
    EnumValues?: { [key: string]: string };
    Order: number;
  }

  export interface CustomFieldOptions {
    IsRequired?: boolean;
    MinimumValue?: number;
    MaximumValue?: number;
    MinimumLength?: number;
    MaximumLength?: number;
    MinimumDate?: string;
    MaximumDate?: string;
    Regex?: string;
    DefaultCustomFieldValue?: CustomFieldValue;
    IsEditable?: boolean;
    DefaultValue?: string;
  }

  export interface CustomFieldValueWithOptions {
    CustomFieldBackendID?: string;
    Value: CustomFieldValue;
    Options: CustomFieldOptions;
  }

  export const enum CreateCustomerResults {
    CreatedCustomer = 0,
    InvalidEmail = 1,
    EmailAlreadyInUse = 3,
    NicknameAlreadyInUse = 4,
    PhoneNumberAlreadyInUse = 5,
    AutoLoginFailed = 6,
    FiscalIDAlreadyInUse = 7
  }

  /**
   * Delete a User by it's ID.
   */
  export interface DeleteUser {
    /**
     * Entity type: User
     */
    ID: number;
  }

  /**
   * Delete multiple users by ID's.
   * This service is async only and only accepts 1000 ID's per request
   */
  export interface DeleteUsers {
    /**
     * Entity type: User
     */
    IDs: number[];
  }

  export interface DeleteUsersResponse {
    /**
     * Entity type: User
     */
    FailedUserIDs?: number[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Detaches an user from a consumer company.
   */
  export interface DetachUserFromConsumerCompany {
    /**
     * Entity type: User
     */
    UserID: number;
    /**
     * Entity type: Company
     */
    CompanyID: number;
  }

  /**
   * Creates a temporary, numeric password for specified user, overwriting his/her current password, intended for employees to be able to help resetting a user password.
   */
  export interface GenerateTemporaryPasswordForUser {
    /**
     * Entity type: User
     */
    UserID: number;
  }

  export interface GenerateTemporaryPasswordForUserResponse {
    Password: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Return identification info for the current employee.
   */
  export interface GetCurrentUserIdentificationInfo {
  }

  export interface GetCurrentUserIdentificationInfoResponse {
    HasPin: boolean;
    ResetDate?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Return the current user for the given Authorization header
   */
  export interface GetCurrentUser {
  }

  export interface GetCurrentUserResponse {
    User: LoggedInUserDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * This service returns a list of the most likely email address domains (so 'gmail.com', 'hotmail.com', etc) based on
   * your current context.
   */
  export interface GetEmailAddressDomainSuggestions {
    /**
     * The number of suggestions to return. Defaults to 5 and is limited to 10.
     * Range: 1-10
     */
    MaxSuggestions?: number;
  }

  export interface GetEmailAddressDomainSuggestionsResponse {
    /**
     * A list of the domain names, ordered by usage count. Each domain is returned in the form of `domain.tld`.
     */
    Domains: string[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Returns all organization units where this user can login
   */
  export interface GetLoginOrganizationUnitsForUser {
    /**
     * Filter by login type
     */
    UserTypeFilter?: UserTypes;
  }

  export interface GetLoginOrganizationUnitsForUserResponse {
    Result: GetLoginOrganizationUnitsForUserResponse.OrganizationUnit[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetLoginOrganizationUnitsForUserResponse {
    export interface OrganizationUnit {
      ID: number;
      Name: string;
    }

  }

  /**
   * Retrieve information about a temporary access token from specified `Authorization` parameter.
   */
  export interface GetTokenInfo {
    Authorization: string;
  }

  export interface GetTokenInfoResponse {
    /**
     * Entity type: User
     */
    UserID: number;
    ExpirationDate?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    TemporaryAccessType: string;
    TemporaryAccessData?: { [key: string]: any };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Return the current user associations for the given user
   */
  export interface GetUserAssociations {
    /**
     * Entity type: User
     */
    ID?: number;
  }

  export interface GetUserAssociationsResponse {
    PrimaryRelations: SingleUserAssociation[];
    RelatedRelations: SingleUserAssociation[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface SingleUserAssociation {
    User: UserDataForSingleUserAssociation;
    Type: AssociationTypeForSingleUserAssociation;
  }

  export interface UserDataForSingleUserAssociation {
    /**
     * Entity type: User
     */
    ID: number;
    FullName: string;
  }

  export interface AssociationTypeForSingleUserAssociation {
    /**
     * Entity type: UserAssociationType
     */
    ID: number;
    Name: string;
  }

  /**
   * Get a user by ID
   */
  export interface GetUser {
    /**
     * Entity type: User
     */
    ID?: number;
    AdditionalDataOptions?: GetUser.AdditionalUserDataOptions;
  }

  export namespace GetUser {
    export interface AdditionalUserDataOptions {
      IncludeLoyaltyPrograms: boolean;
      IncludeSubscriptions: boolean;
      IncludeCoupons: boolean;
      IncludeInquiries: boolean;
    }

  }

  export interface GetUserResponse {
    /**
     * Entity type: User
     */
    ID: number;
    BackendID: string;
    BackendSystemID: string;
    BackendRelationID: string;
    EmailAddress: string;
    EmailAddressValidated: boolean;
    Initials: string;
    FirstName: string;
    LastName: string;
    FullName: string;
    DateOfBirth?: string;
    PlaceOfBirth: string;
    Gender: string;
    Company: CompanyDto;
    Type: UserTypes;
    LanguageID: string;
    CountryID: string;
    IsIncognito: boolean;
    IsDeactivated: boolean;
    DeactivationDate?: string;
    LastSuccessfulLogin?: string;
    Nickname: string;
    BankAccount: string;
    IsDebtor: boolean;
    PhoneNumber: string;
    GravatarHash: string;
    Data: { [key: string]: string };
    TimeZone: string;
    FiscalID: string;
    SocialSecurityNumber: string;
    Title: string;
    Salutation: string;
    /**
     * Entity type: OrganizationUnit
     */
    PreferredStoreID?: number;
    PreferredStore?: GetUserResponse.OrganizationUnitDto;
    OriginatingOrganizationUnit?: GetUserResponse.OrganizationUnitDto;
    CustomID: string;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    CreatedByFullName: string;
    CreationTime: string;
    /**
     * Entity type: User
     */
    LastModifiedByID?: number;
    ModifiedByFullName?: string;
    LastModificationTime?: string;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    PricingGroupID?: string;
    AllowPasswordLogin: boolean;
    SingleSignOnOnly: boolean;
    AccountType: UserAccountType;
    HasOpenCases: boolean;
    /**
     * Entity type: VisibilityGroup
     */
    VisibilityGroupID: number;
    VisibilityGroupName: string;
    SingleSignOnID?: string;
    HasCompanies: boolean;
    AdditionalData?: GetUserResponse.AdditionalUserData;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetUserResponse {
    export interface AdditionalUserData {
      Coupons?: GetUserResponse.Coupon[];
      LoyaltySubscriptions?: UserSubscriptionDto[];
      Subscriptions?: UserSubscriptionDto[];
      Inquiries?: UserInquiryDto[];
    }

    export interface Coupon {
      /**
       * Entity type: DiscountCoupon
       */
      ID: number;
      Code: string;
      /**
       * Entity type: Discount
       */
      DiscountID: number;
      DiscountDescription: string;
      DiscountMarketingDescription: string;
      ValidFrom: string;
      ValidTill?: string;
    }

    export interface OrganizationUnitDto {
      /**
       * Entity type: OrganizationUnit
       */
      ID?: number;
      BackendID?: string;
      Name?: string;
    }

  }

  export interface GetUserLegacyResult {
    /**
     * Entity type: User
     */
    ID: number;
    BackendID: string;
    BackendSystemID: string;
    BackendRelationID: string;
    EmailAddress: string;
    EmailAddressValidated: boolean;
    Initials: string;
    FirstName: string;
    LastName: string;
    FullName: string;
    DateOfBirth?: string;
    PlaceOfBirth: string;
    Gender: string;
    Company: CompanyDto;
    Type: UserTypes;
    LanguageID: string;
    CountryID: string;
    IsDeleted: boolean;
    IsIncognito: boolean;
    IsDeactivated: boolean;
    DeactivationDate?: string;
    LastSuccessfulLogin?: string;
    Nickname: string;
    BankAccount: string;
    IsDebtor: boolean;
    PhoneNumber: string;
    GravatarHash: string;
    Data: { [key: string]: string };
    TimeZone: string;
    FiscalID: string;
    SocialSecurityNumber: string;
    Title: string;
    Salutation: string;
    /**
     * Entity type: OrganizationUnit
     */
    PreferredStoreID?: number;
    CustomID: string;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    CreatedByFullName: string;
    CreationTime: string;
    /**
     * Entity type: User
     */
    LastModifiedByID?: number;
    ModifiedByFullName?: string;
    LastModificationTime?: string;
    AllowPasswordLogin: boolean;
  }

  export interface UserSubscriptionDto {
    Status?: SubscriptionStatus;
    UserAgent?: string;
    SubscribeFromSourceOrganizationUnit?: UserSubscriptionDto.OrganizationUnitDto;
    SubscribeFromSourceUserAgent?: string;
    SubscribeFromSourceIdentifier?: string;
    SubscribedOn?: string;
    UnsubscribeFromSourceOrganizationUnit?: UserSubscriptionDto.OrganizationUnitDto;
    UnsubscribeFromSourceUserAgent?: string;
    UnsubscribeFromSourceIdentifier?: string;
    UnsubscribeFromSourceReason?: string;
    IsBlocked?: boolean;
    UserIdentifier?: string;
    IsUnsubscribeAllowed?: boolean;
    CreationTime?: string;
    LastModificationTime?: string;
    CreatedBy?: SubscriptionSimpleUserDto;
    LastModifiedBy?: SubscriptionSimpleUserDto;
    Subscription?: SubscriptionDto;
  }

  export namespace UserSubscriptionDto {
    export interface OrganizationUnitDto {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
      BackendID?: string;
    }

  }

  export const enum SubscriptionStatus {
    None = 0,
    Requested = 1,
    Subscribed = 2,
    Unsubscribed = 3
  }

  export interface SubscriptionSimpleUserDto {
    /**
     * Entity type: User
     */
    ID: number;
    FirstName: string;
    LastName: string;
    FullName: string;
  }

  export interface SubscriptionDto {
    /**
     * Entity type: Subscription
     */
    ID?: number;
    /**
     * Entity type: LoyaltyProgramGroup
     */
    LoyaltyProgramGroupID?: number;
    LoyaltyProgramGroupName?: string;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    LoyaltyProgramName?: string;
    LoyaltyProgramOptions?: LoyaltyProgramOptions;
    LoyaltyProgramPointUsageOptions?: LoyaltyPointUsageOptions;
    LoyaltyBalance?: UserLoyaltyPointBalance;
    BackendID?: string;
    Name?: string;
    Description?: string;
    ConfirmationRequired?: boolean;
    Default?: boolean;
    Hidden?: boolean;
    /**
     * Entity type: OrganizationUnit
     */
    OriginatingOrganizationUnitID?: number;
    Preferred?: boolean;
    UserIdentifierRequiredForSubscription?: boolean;
    HasCustomFieldIdentifier?: boolean;
    Inquiry?: InquiryDto;
    Priority?: number;
    IsExternal?: boolean;
    ResubscribeHandling?: ResubscribeHandlingType;
    AllowUnsubscribeBy?: AllowUnsubscribeByType;
  }

  export const enum LoyaltyProgramOptions {
    None = 0,
    EnablePaymentMethods = 1,
    EnableLoyaltyPoints = 2,
    EnableDiscounts = 4
  }

  export const enum LoyaltyPointUsageOptions {
    None = 0,
    AllowAwarding = 1,
    UsableAsPaymentMethod = 2,
    UsableForWithdraw = 4
  }

  export interface UserLoyaltyPointBalance {
    Points?: number;
    PointRegistrations?: UserLoyaltyPointBalance.Mutations[];
    PointRegistrationsPreviousPageToken?: string;
    PointRegistrationsNextPageToken?: string;
    CurrencyID: string;
    CurrencyValue: number;
  }

  export namespace UserLoyaltyPointBalance {
    export interface Mutations {
      Type: UserLoyaltyMutationType;
      Points: number;
      PendingTill?: string;
      ExpireAfter?: string;
      CreationTime: string;
    }

  }

  export const enum UserLoyaltyMutationType {
    Deposit = 0,
    Revoke = 1,
    Withdraw = 2,
    Refund = 3,
    Rebalance = 4
  }

  export interface InquiryDto {
    /**
     * Entity type: Inquiry
     */
    ID: number;
    Name: string;
    OneTimeUseOnly: boolean;
    CompletionTime?: string;
  }

  export const enum ResubscribeHandlingType {
    UpdateUserIdentifier = 0,
    KeepOriginalUserIdentifier = 1,
    Block = 2
  }

  export const enum AllowUnsubscribeByType {
    None = 0,
    Subscriber = 1,
    Employee = 2,
    All = 3
  }

  export interface UserInquiryDto {
    /**
     * Entity type: Inquiry
     */
    ID: number;
    /**
     * Entity type: Subscription
     */
    SubscriptionID?: number;
    Name: string;
    Description?: string;
    SubmittedOn?: string;
    PromptUser: boolean;
  }

  /**
   * List supported time zones with their IDs and country names.
   */
  export interface ListAvailableTimeZones {
  }

  export interface ListAvailableTimeZonesResponse {
    Result: ListAvailableTimeZonesResponse.Model[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListAvailableTimeZonesResponse {
    export interface Model {
      ID: string;
      CountryID: string;
      CountryName: string;
      Offset: number;
    }

  }

  export interface ListUserApiKeys {
    /**
     * Entity type: User
     */
    UserID: number;
    PageConfig?: PageConfig<ListApiKeysFilter>;
  }

  export interface ListUserApiKeysResponse {
    Result?: PagedResult<ListApiKeysItem>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListApiKeysItem {
    /**
     * Entity type: ApiKey
     */
    ID?: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    Description?: string;
    ExpirationDate?: string;
  }

  /**
   * Creates a UserPhoneNumber for the current user, or the UserID specified if you're allowed to do so.
   */
  export interface CreateUserPhoneNumber {
    /**
     * Entity type: User
     */
    UserID?: number;
    PhoneNumber: string;
    Type: PhoneNumberTypes;
    Description?: string;
    IsPrimary?: boolean;
  }

  export const enum PhoneNumberTypes {
    Unspecified = 0,
    Home = 1,
    Mobile = 2,
    Work = 3,
    Fax = 4,
    Other = 999
  }

  export interface CreateUserPhoneNumberResponse {
    /**
     * Entity type: UserPhoneNumber
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Updates a UserPhoneNumber based on its ID. This service allows you to change the PhoneNumber (required), Type, Description.
   *     If you want to change what number is the primary number, use the `MakeUserPhoneNumberPrimary` service.
   * 
   * This service only allows the number's own user or an employee to update it.
   */
  export interface UpdateUserPhoneNumber {
    /**
     * Entity type: UserPhoneNumber
     */
    ID: number;
    PhoneNumber: string;
    Type: PhoneNumberTypes;
    Description?: string;
  }

  /**
   * Get the requested user's phone numbers. If UserID is left null, this service will return the phone numbers for your current user.
   * Only employee users are allowed to access the phone numbers of other users.
   */
  export interface GetUserPhoneNumbers {
    /**
     * Entity type: User
     */
    UserID?: number;
  }

  export interface GetUserPhoneNumbersResponse {
    Result: UserPhoneNumberModel[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface UserPhoneNumberModel {
    /**
     * Entity type: UserPhoneNumber
     */
    ID: number;
    PhoneNumber: string;
    Description: string;
    Type: PhoneNumberTypes;
    IsPrimary: boolean;
  }

  /**
   * Delete a user's phone number based on the provided ID. If you're trying to delete a user's primary phone number and that user has
   * more than two phone numbers currently, this service will return a `CannotDeletePrimaryPhoneNumber` error,
   * because it cannot determine what number should now become the user's primary phone number. If the user has two numbers, the other number
   * will become the primary.
   * 
   * This service only allows the number's own user or an employee to delete it.
   */
  export interface DeleteUserPhoneNumber {
    /**
     * Entity type: UserPhoneNumber
     */
    ID: number;
  }

  /**
   * This service marks the provided phone number as the user's primary phone number,
   * which will be used for communication with the user.
   * 
   * This service only allows the number's own user or an employee to mark it as the primary number.
   */
  export interface MakeUserPhoneNumberPrimary {
    /**
     * Entity type: UserPhoneNumber
     */
    ID: number;
  }

  /**
   * Used to create or update a user from 3rd party system.
   */
  export interface PushUser {
    /**
     * ID of the EVA user
     * Entity type: User
     */
    ID?: number;
    /**
     * Code of the 3rd party system that wants to create this user
     */
    BackendSystemID?: string;
    /**
     * ID of the user in the 3rd party system
     */
    BackendID?: string;
    CustomID?: string;
    /**
     * Defaults to Customer
     */
    UserType?: UserTypes;
    /**
     * Defaults to Standard
     */
    AccountType?: UserAccountType;
    EmailAddress?: string;
    Nickname?: string;
    Initials?: string;
    FirstName?: string;
    LastName?: string;
    PhoneNumber?: string;
    DateOfBirth?: string;
    BackendRelationID?: string;
    FiscalID?: string;
    SocialSecurityNumber?: string;
    Title?: string;
    Salutation?: string;
    SingleSignOnID?: string;
    /**
     * Entity type: VisibilityGroup
     */
    VisibilityGroupID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    PreferredStoreID?: number;
    /**
     * Sets the originating organization unit when creating a customer. Ignored on updates.
     * Entity type: OrganizationUnit
     */
    OriginatingOrganizationUnitID?: number;
    /**
     * Gender of the user, either M or F
     */
    Gender?: string;
    /**
     * Language code of the user (ISO 639-1)
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Country code of the user (ISO 3166-1)
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Companies the user is attached to
     */
    Companies?: string[];
    ShippingAddress?: AddressDataDto;
    BillingAddress?: AddressDataDto;
    /**
     * With this property the whole address book can be mutated. When used ShippingAddress and BillingAddress will be ignored.
     */
    AddressBook?: PushUser.AddressBookData;
    /**
     * NOTE THAT Only subscriptions that allow for local storage can be pushed. Subscriptions fully depending on external services cannot be pushed.
     * NOTE THAT Balance can only be provided for loyalty subscriptions that have a EVA loyalty handler.
     */
    Subscriptions?: PushUser.UserSubscription[];
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
    PricingGroupID?: string;
    IsSingleSignOnOnly?: boolean;
    WishlistData?: WishlistData;
  }

  export namespace PushUser {
    export interface AddressBookData {
      /**
       * If this is set to true, all existing addresses will be removed from the addressbook
       */
      ReplaceAll: boolean;
      Addresses: PushUser.AddressBookItem[];
    }

    export interface AddressBookItem {
      /**
       * Entity type: AddressBook
       */
      ID?: number;
      BackendID?: string;
      Description?: string;
      Address?: AddressDataDto;
      UseAsDefaultShippingAddress: boolean;
      UseAsDefaultBillingAddress: boolean;
      UseAsDefaultPickupAddress: boolean;
    }

    export interface UserSubscription {
      /**
       * Entity type: Subscription
       */
      SubscriptionID?: number;
      Subscribed?: boolean;
      /**
       * Identifier for this user for the given Subscription. P/a: a loyaltyID
       */
      UserIdentifier?: string;
      /**
       * Identifier for the source of subscription.
       */
      SourceIdentifier?: string;
      /**
       * Reason for unsubscribing.
       */
      UnsubscribeReason?: string;
      Balance?: number;
      SubscribedOn?: string;
    }

    export interface UserFieldValues {
      /**
       * Entity type: UserField
       */
      UserFieldID?: number;
      Value?: any;
    }

  }

  export interface WishlistData {
    ReplaceAll: boolean;
    Wishlists: WishlistData.WishlistItem[];
  }

  export namespace WishlistData {
    export interface WishlistItem {
      BackendID?: string;
      BackendSystemID: string;
      Name: string;
      Description: string;
      /**
       * Entity type: Product
       */
      ProductIDs: number[];
    }

  }

  export interface PushUserResponse {
    /**
     * Entity type: User
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Use this to push multiple users at once. This is more efficient than pushing them one by one. Please get in touch with your contact at New Black if you plan on pushing a lot of users. This service follows the "all-or-nothing" approach, either everything is imported, or nothing is imported. There is a limit (100) on the number of users that can be pushed at once.
   */
  export interface PushUsers {
    /**
     * Enabling this will try to suppress as many eventexports as possible that might result from this call.
     */
    DisableEventExports?: boolean;
    /**
     * Will ignore any faulty users. Everything that looks right is imported and a 200 OK is always returned.
     */
    IgnoreErrors?: boolean;
    Users: PushUser[];
  }

  export interface PushUsersResponse {
    Success: boolean;
    /**
     * Will be empty if the import was not successful
     */
    ValidUsers: ValidUser[];
    InvalidUsers: InvalidUser[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ValidUser {
    /**
     * Entity type: User
     */
    ID: number;
    BackendID: string;
    Addresses: ValidUser.Address[];
  }

  export namespace ValidUser {
    export interface Address {
      /**
       * Entity type: AddressBook
       */
      AddressBookID: number;
      AddressBookBackendID: string;
    }

  }

  export interface InvalidUser {
    BackendID: string;
    Reason: string;
  }

  /**
   * Reactivates an User that was deactivated due to no login
   */
  export interface ReactivateUser {
    /**
     * Entity type: User
     */
    ID: number;
  }

  /**
   * Recovers an employee account by changing the email address and optionally generating a temporary password.
   *   This is intended as last resort for when an employee has lost access to their emailaddress.
   */
  export interface RecoverEmployeeAccount {
    /**
     * Entity type: User
     */
    UserID: number;
    NewEmailAddress?: string;
    GenerateTemporaryPassword?: boolean;
  }

  export interface RecoverEmployeeAccountResponse {
    Password: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Send a reset token to EmailAddress. Optional context customizes the email template.
   */
  export interface RequestPasswordResetToken {
    EmailAddress: string;
    AsEmployee?: boolean;
    /**
     * Some identifier to use in the mailtemplate (admin, checkout, website, ...)
     */
    Context?: string;
  }

  /**
   * Reset a user's password using a valid Token and new password, returning the affected email address.
   */
  export interface ResetUserPassword {
    Token: string;
    NewPassword: string;
  }

  export interface ResetUserPasswordResponse {
    EmailAddress: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Execute a search through the users
   * 
   * Filtering is possible on all kinds of properties. By default the search results will be restricted to users in the current country.
   */
  export interface SearchUsers {
    IncludeCustomers?: boolean;
    IncludeEmployees?: boolean;
    /**
     * By default the search will only return users from the same Country as the current OrganizationUnit.
     * Optionally an extensive search can be performed by enabling this option. But keep in mind this will take some time in real production scenario's.
     * It is advised to only show this option in the frontend after an intial search has been done in the current country.
     */
    IncludeAllCountries?: boolean;
    /**
     * Entity type: User
     */
    UserIDs?: number[];
    EmailAddress?: string;
    Name?: string;
    SearchQuery?: string;
    Types?: UserTypes;
    ZipCode?: string;
    /**
     * When provided, the `ZipCode` will be required as well.
     */
    HouseNumber?: string;
    PhoneNumber?: string;
    EmployeeNumber?: string;
    /**
     * Ignored when `IncludeAllCountries` is set to `true`. Overwrite the Country from the current OrganizationUnit.
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    PrimaryOrganizationUnitID?: number;
    /**
     * Entity type: User
     */
    AssignedEmployeeID?: number;
    VatNumber?: string;
    SocialSecurityNumber?: string;
    DateOfBirth?: string;
    FiscalID?: string;
    /**
     * Entity type: Role
     */
    RoleIDs?: number[];
    PricingGroupID?: string;
    Data?: { [key: string]: string };
    /**
     * Entity type: CustomField
     */
    CustomFields?: { [key: number]: string };
    /**
     * When source is set to External the search will be performed on the external user provider.
     */
    Source?: SearchUsers.SearchUserSources;
    /**
     * Entity type: Company
     */
    CompanyIDs?: number[];
    /**
     * Entity type: Subscription
     */
    SubscriptionID?: number;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export namespace SearchUsers {
    export const enum SearchUserSources {
      Internal = 1,
      External = 2
    }

  }

  export interface SearchUsersResponse {
    Result?: PagedResult<SearchUsersResponse.UserSearchDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace SearchUsersResponse {
    export interface UserSearchDto {
      /**
       * Entity type: User
       */
      ID?: number;
      CompanyName?: string;
      BackendID?: string;
      BackendSystemID?: string;
      BackendRelationID?: string;
      EmailAddress?: string;
      FirstName?: string;
      LastName?: string;
      FullName?: string;
      DateOfBirth?: string;
      CountryID?: string;
      ShippingAddress?: AddressDataDto;
      BillingAddress?: AddressDataDto;
      Type?: UserTypes;
      AccountType?: UserAccountType;
      IsDeactivated?: boolean;
      DeactivationDate?: string;
      LastSuccessfulLogin?: string;
      PhoneNumber?: string;
      GravatarHash?: string;
      Data?: { [key: string]: string };
      CustomFields?: { [key: string]: string };
      EmployeeNumber?: string;
      /**
       * Entity type: OrganizationUnit
       */
      PrimaryOrganizationUnitID?: number;
      PrimaryOrganizationUnitName?: string;
      HasCompanies?: boolean;
    }

  }

  /**
   * Update user custom data
   */
  export interface SetCustomUserData {
    /**
     * Entity type: User
     */
    ID: number;
    CustomFields?: CustomFieldKeyValue[];
  }

  /**
   * Update a user login to single sign on only
   */
  export interface SetUserToSingleSignOnOnly {
    /**
     * Entity type: User
     */
    ID: number;
  }

  /**
   * This service is used to change the AccountType of a Customer.
   * 
   * When changing the AccountType from Standard to Incognito or Basic, all credentials and roles are removed.
   * 
   * When changing the AccountType from Incognito or Basic to Standard:
   * - Uniqueness checks are done for the EmailAddress and Nickname
   * - Default customer roles are generated
   * - When no password is provided, one is generated and returned in the response
   * - If configured, the user will receive an `welcome to EVA` email. If no valid password is provided, the email will also contain a generated password.
   */
  export interface UpdateUserAccountType {
    /**
     * Entity type: User
     */
    UserID?: number;
    AccountType: UserAccountType;
    Password?: string;
  }

  export interface UpdateUserAccountTypeResponse {
    Password?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update properties on an existing User. Will throw an exception if one of the properties are invalid.
   * 
   * Properties not specified in the request will be ignored.
   */
  export interface UpdateUser {
    /**
     * Entity type: User
     */
    ID: number;
    BackendRelationID?: string;
    BackendID?: string;
    BackendSystemID?: string;
    Initials?: string;
    FirstName?: string;
    LastName?: string;
    DateOfBirth?: string;
    PlaceOfBirth?: string;
    Gender?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    Nickname?: string;
    EmailAddress?: string;
    BankAccount?: string;
    PhoneNumber?: string;
    TimeZone?: string;
    FiscalID?: string;
    SocialSecurityNumber?: string;
    Title?: string;
    Salutation?: string;
    /**
     * Entity type: OrganizationUnit
     */
    PreferredStoreID?: number;
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
    PricingGroupID?: string;
  }

  /**
   * This service is used to change the VisibilityGroup of a User.
   * 
   * To change the VisibilityGroup of a User, the following conditions must be met:
   * - The User must be visable and editable by the current User
   * - The VisibilityGroup must be visible for Users by the current User, the service GetUsersVisibilityGroups can be used to get a list of all available VisibilityGroups for the current User.
   * - If the User is a standard account, there must be no duplicate standard account in the new VisibilityGroup.
   */
  export interface UpdateUserVisibilityGroup {
    /**
     * Entity type: User
     */
    UserID: number;
    /**
     * Entity type: VisibilityGroup
     */
    VisibilityGroupID: number;
  }

  /**
   * Get all visibility groups that the current user can see.
   */
  export interface GetAvailableVisibilityGroups {
  }

  export interface GetAvailableVisibilityGroupsResponse {
    UserVisibilityGroups: VisibilityGroupModel[];
    OrganizationUnitVisibilityGroups: VisibilityGroupModel[];
    OrderVisibilityGroups: VisibilityGroupModel[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface VisibilityGroupModel {
    /**
     * Entity type: VisibilityGroup
     */
    ID: number;
    Name: string;
    Description: string;
    AllowCustomerStandardAccounts: boolean;
  }

  /**
   * Create an association between two users identified by their IDs.
   */
  export interface CreateUserAssociation {
    /**
     * Entity type: User
     */
    PrimaryUserID: number;
    /**
     * Entity type: User
     */
    RelatedUserID: number;
    /**
     * Entity type: UserAssociationType
     */
    TypeID: number;
  }

  export interface CreateUserAssociationResponse {
    /**
     * Entity type: UserAssociation
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update an existing user association specified by ID.
   */
  export interface UpdateUserAssociation {
    /**
     * Entity type: UserAssociation
     */
    ID: number;
    /**
     * Entity type: User
     */
    PrimaryUserID?: number;
    /**
     * Entity type: User
     */
    RelatedUserID?: number;
    /**
     * Entity type: UserAssociationType
     */
    TypeID?: number;
  }

  /**
   * Delete a user association by ID.
   */
  export interface DeleteUserAssociation {
    /**
     * Entity type: UserAssociation
     */
    ID: number;
  }

  export interface CreateUserAssociationType {
    Name: string;
    Description?: string;
    BackendID?: string;
  }

  export interface CreateUserAssociationTypeResponse {
    /**
     * Entity type: UserAssociationType
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface UpdateUserAssociationType {
    /**
     * Entity type: UserAssociationType
     */
    ID: number;
    Name: string;
    Description?: string;
    BackendID?: string;
  }

  export interface DeleteUserAssociationType {
    /**
     * Entity type: UserAssociationType
     */
    ID: number;
  }

  export interface GetUserAssociationTypeByID {
    /**
     * Entity type: UserAssociationType
     */
    ID: number;
  }

  export interface GetUserAssociationTypeByIDResponse {
    UserAssociationType: UserAssociationTypeModel;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface UserAssociationTypeModel {
    /**
     * Entity type: UserAssociationType
     */
    ID: number;
    Name: string;
    Description: string;
    BackendID: string;
    IsDeleted: boolean;
  }

  export interface GetUserAssociationTypes {
  }

  export interface GetUserAssociationTypesResponse {
    UserAssociationTypes: UserAssociationTypeModel[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get the user Consignment property.
   */
  export interface GetUserConsignment {
    /**
     * Entity type: User
     */
    UserID: number;
  }

  export interface GetUserConsignmentResponse {
    UseConsignment: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Set the user Consignment property.
   */
  export interface SetUserConsignment {
    /**
     * Entity type: User
     */
    UserID: number;
    UseConsignment?: boolean;
  }

  /**
   * Retrieve debtor-related information for the specified UserID.
   */
  export interface GetUserDebtorData {
    /**
     * Entity type: User
     */
    UserID: number;
  }

  export interface GetUserDebtorDataResponse {
    PaymentTerms: string;
    CreditLimit?: number;
    ColloPrice?: number;
    PalletPrice?: number;
    OversizedPrice?: number;
    AssignedToUser: AssignedToUser;
    IsTaxExempt: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface AssignedToUser {
    /**
     * Entity type: User
     */
    ID: number;
    FullName: string;
    EmailAddress: string;
  }

  /**
   * Update debtor details such as credit limits for a user.
   */
  export interface UpdateUserDebtorData {
    /**
     * Entity type: User
     */
    UserID: number;
    PaymentTerms?: string;
    CreditLimit?: number;
    /**
     * Entity type: User
     */
    AssignedToUserID?: number;
    ColloPrice?: number;
    PalletPrice?: number;
    OversizedPrice?: number;
    IsTaxExempt?: boolean;
  }

  /**
   * Check provided user details for validity. Returns IsValid with a list of issues if any.
   */
  export interface ValidateUser {
    /**
     * Entity type: User
     */
    UserID?: number;
    IsEmployee?: boolean;
    FirstName?: string;
    Initials?: string;
    LastName?: string;
    Nickname?: string;
    EmailAddress?: string;
    Gender?: string;
    PhoneNumber?: string;
    DateOfBirth?: string;
    LanguageID?: string;
    CountryID?: string;
    ShowValidDetails?: boolean;
  }

  export interface ValidateUserResponse {
    IsValid: boolean;
    ValidationDetails: ValidateUserResponse.ValidationDetail[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ValidateUserResponse {
    export interface ValidationDetail {
      Field: string;
      Message: string;
      IsValid: boolean;
    }

  }

  /**
   * Share a wishlist.
   */
  export interface ShareWishlist {
    /**
     * Description to identify the share with
     */
    Description: string;
    /**
     * Entity type: Wishlist
     */
    WishlistID: number;
    CanEdit?: boolean;
    /**
     * Emailadresses to send the share token to. Can provide a maximum of 50 email adresses.
     */
    EmailAddresses?: string[];
  }

  export interface ShareWishlistResponse {
    Token: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Revoke the wishlist share.
   */
  export interface RevokeWishlistShare {
    /**
     * Entity type: Wishlist
     */
    WishlistID: number;
  }

  /**
   * Get the shared wishlist by token. Requires the share token.
   */
  export interface GetSharedWishlist {
    Token: string;
  }

  export interface GetSharedWishlistResponse {
    Name: string;
    Description: string;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    FirstProduct?: any;
    Products: any[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Links the shared wishlist to the user. Requires the share token. When linked the wishlist is returned in the users overview.
   */
  export interface LinkSharedWishlist {
    Token: string;
  }

  /**
   * Unlinks the shared wishlist from the user. Will also remove it from the users overview. Shared wishlist can still be retrieved by the token.
   */
  export interface UnlinkSharedWishlist {
    /**
     * Entity type: Wishlist
     */
    WishlistID: number;
  }

  /**
   * Get an anonymous wishlist by token.
   */
  export interface GetAnonymousWishlist {
    Token: string;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProperties?: string[];
  }

  export interface GetAnonymousWishlistResponse {
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    Products: any[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Create an anonymous wishlist.
   */
  export interface CreateAnonymousWishlist {
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
  }

  export interface CreateAnonymousWishlistResponse {
    Token: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update an anonymous wishlist.
   */
  export interface UpdateAnonymousWishlist {
    Token: string;
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
  }

  /**
   * Deletes an anonymous wishlist.
   */
  export interface DeleteAnonymousWishlist {
    Token: string;
  }

  /**
   * Add product(s) to an anonymous wishlist.
   */
  export interface AddProductsToAnonymousWishlist {
    Token: string;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
  }

  /**
   * Removes product(s) from an anonymous wishlist.
   */
  export interface RemoveProductsFromAnonymousWishlist {
    Token: string;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
  }

  /**
   * If the wishlist is created by anonymous, but the user logs in afterwards, this service can be used to attach the anonymous wishlist to the logged in user.
   * The service requires a unique name.
   */
  export interface AttachAnonymousWishlistToUser {
    Token: string;
    Name: string;
    Description?: string;
  }

  /**
   * List the users wishlists.
   */
  export interface ListUserWishlists {
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProperties?: string[];
    InitialPageConfig?: PageTokenConfig<ListUserWishlistsFilter>;
    PageToken?: string;
  }

  export interface ListUserWishlistsFilter {
    Name?: string;
    /**
     * Entity type: Product
     */
    ProductID?: number;
  }

  export interface ListUserWishlistsResponse {
    Results?: ListUserWishlistsResponse.Wishlist[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListUserWishlistsResponse {
    export interface Wishlist {
      /**
       * Entity type: Wishlist
       */
      ID: number;
      Name: string;
      Description: string;
      FirstProduct?: any;
      ItemCount: number;
      SharedByMe: boolean;
      SharedWithMe: boolean;
      CanEdit: boolean;
    }

  }

  /**
   * Get the user wishlist by ID.
   */
  export interface GetUserWishlist {
    /**
     * Entity type: Wishlist
     */
    ID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProperties?: string[];
  }

  export interface GetUserWishlistResponse {
    /**
     * Entity type: Wishlist
     */
    ID: number;
    Name: string;
    Description: string;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    FirstProduct?: any;
    Products?: any[];
    SharedByMe: boolean;
    SharedWithMe: boolean;
    CanEdit: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Creates a user wishlist.
   */
  export interface CreateUserWishlist {
    /**
     * Entity type: User
     */
    UserID?: number;
    Name: string;
    Description?: string;
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
    /**
     * When `HideForUser` is set to true, only employees can see this wishlist. The name must be unique within this context, but a user can potentially create a wishlist with the same name.
     */
    HideFromUser?: boolean;
  }

  export interface CreateUserWishlistResponse {
    /**
     * Entity type: Wishlist
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update the user wishlist.
   */
  export interface UpdateUserWishlist {
    /**
     * Entity type: Wishlist
     */
    ID: number;
    Name?: string;
    Description?: string;
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
    /**
     * When `HideForUser` is set to true, only employees can see this wishlist. The name must be unique within this context, but a user can potentially create a wishlist with the same name.
     */
    HideFromUser?: boolean;
  }

  /**
   * Deletes the user wishlist.
   */
  export interface DeleteUserWishlist {
    /**
     * Entity type: Wishlist
     */
    ID: number;
  }

  /**
   * Add product(s) to the user wishlist.
   */
  export interface AddProductsToUserWishlist {
    /**
     * Entity type: Wishlist
     */
    ID: number;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
  }

  /**
   * Removes product(s) from the user wishlist.
   */
  export interface RemoveProductsFromUserWishlist {
    /**
     * Entity type: Wishlist
     */
    ID: number;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
  }

  /**
   * Fetch user information from an external API based on the social security number. This can be used to enrich the user in the frontend.
   * Depending on the SSN provider, this may require Customer or Employee rights.
   */
  export interface GetUserInfoBySocialSecurityNumber {
    /**
     * Entity type: Country
     */
    CountryID: string;
    SocialSecurityNumber: string;
  }

  export interface GetUserInfoResponse {
    Data: GetUserInfoResponse.UserData;
    Address: GetUserInfoResponse.UserAddress;
    ExistingUsers: GetUserInfoResponse.ExistingUser[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetUserInfoResponse {
    export interface UserData {
      ID: number;
      SocialSecurityNumber: string;
      FirstName: string;
      LastName: string;
      DateOfBirth?: string;
      PhoneNumber: string;
      Company: GetUserInfoResponse.UserCompany;
      BillingAddress: GetUserInfoResponse.UserAddress;
    }

    export interface UserCompany {
      Name: string;
    }

    export interface UserAddress {
      AddressedTo: string;
      Street: string;
      HouseNumber: string;
      ZipCode: string;
      City: string;
      CountryID: string;
    }

    export interface ExistingUser {
      ID: number;
      FirstName: string;
      LastName: string;
      DateOfBirth?: string;
    }

  }

  /**
   * Fetch user information from an external API based on the phone number. This can be used to enrich the user in the frontend.
   * Depending on the phone number provider, this may require Customer or Employee rights.
   */
  export interface GetUserInfoByPhoneNumber {
    /**
     * Entity type: Country
     */
    CountryID: string;
    PhoneNumber: string;
  }

  /**
   * Find an User by their SocialSecurityNumber. This service only returns an UserID.
   * When more info is needed, additional data can be fetched with the `GetUser` service.
   */
  export interface GetUserBySocialSecurityNumber {
    SocialSecurityNumber: string;
    AsEmployee?: boolean;
  }

  export interface GetUserBySocialSecurityNumberResponse {
    UserID?: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * List the user loyalty transactions.
   */
  export interface ListUserLoyaltyTransactions {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    InitialPageConfig?: PageTokenConfig<ListUserLoyaltyMutationFilter>;
    PageToken?: string;
  }

  export interface ListUserLoyaltyMutationFilter {
    Type?: UserLoyaltyMutationType;
  }

  export interface ListUserLoyaltyTransactionsResponse {
    Results?: ListUserLoyaltyTransactionsResponse.LoyaltyTransaction[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListUserLoyaltyTransactionsResponse {
    export interface LoyaltyTransaction {
      Type: UserLoyaltyMutationType;
      Points: number;
      PendingTill?: string;
      ExpireAfter?: string;
      CreationTime: string;
    }

  }

  /**
   * Get the user loyalty balance.
   */
  export interface GetUserLoyaltyBalance {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    /**
     * Entity type: User
     */
    UserID?: number;
  }

  export interface GetUserLoyaltyBalanceResponse {
    LoyaltyProgramID: number;
    LoyaltyProgramName: string;
    CurrentBalance: number;
    IsExternalProvider: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetUserLoyaltyBalanceResponse {
    export interface Mutation {
      Type: UserLoyaltyMutationType;
      Points: number;
      PendingTill?: string;
      ExpireAfter?: string;
      CreationTime: string;
    }

  }

  /**
   * Confirm a Subscription with a Token
   * 
   * The service returns the status of the subscription
   */
  export interface ConfirmSubscription {
    Token: string;
  }

  export interface ConfirmSubscriptionResponse {
    /**
     * Entity type: Subscription
     */
    ID: number;
    Status: SubscriptionStatus;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get all available subscriptions
   */
  export interface GetAvailableSubscriptions {
  }

  export interface GetAvailableSubscriptionsResponse {
    Subscriptions: GetAvailableSubscriptionsResponse.SubscriptionDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetAvailableSubscriptionsResponse {
    export interface SubscriptionDto {
      /**
       * Entity type: Subscription
       */
      ID?: number;
      /**
       * Entity type: LoyaltyProgram
       */
      LoyaltyProgramID?: number;
      BackendID?: string;
      Name?: string;
      Description?: string;
      ConfirmationRequired?: boolean;
      SubscriptionConfirmation?: SubscriptionConfirmation;
      Default?: boolean;
      Hidden?: boolean;
      Preferred?: boolean;
      UserIdentifierRequiredForSubscription?: boolean;
      HasCustomFieldIdentifier?: boolean;
      /**
       * Entity type: Inquiry
       */
      InquiryID?: number;
      InquiryName?: string;
      Priority?: number;
      IsExternal?: boolean;
    }

  }

  export const enum SubscriptionConfirmation {
    None = 0,
    Email = 1,
    Webhook = 2
  }

  /**
   * Get all User subscriptions, this takes into account the OU this request is done on and will only show subscriptions available in that OU.
   */
  export interface GetUserSubscriptions {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Setting this to true will also include the subscriptions in the response that are available, but where the user has no Subscription status
     */
    IncludeAvailableSubscriptions?: boolean;
    /**
     * Setting this to true will also include the subscriptions in the response that are not available to subscribe the user to anymore, such as those that are already unsubscribed and resubscription is blocked.
     */
    IncludeHiddenSubscriptions?: boolean;
    /**
     * Setting this will filter subscriptions based on who can unsubscribe from it.
     */
    AllowUnsubscribeBy?: AllowUnsubscribeByType;
    /**
     * Entity type: User
     */
    LoyaltyProgramGroupID?: number;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    Name?: string;
    LoyaltyProgramOptions?: LoyaltyProgramOptions;
  }

  export interface GetUserSubscriptionsResponse {
    UserAgent: string;
    Subscriptions: UserSubscriptionDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get all user loyalty subscriptions, this takes into account the OU this request is done on and will only show subscriptions available in that OU.
   */
  export interface GetUserLoyaltySubscriptions {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Setting this to true will also include the subscriptions in the response that are available, but where the user has no Subscription status
     */
    IncludeAvailableSubscriptions?: boolean;
    /**
     * Setting this to true will also include the subscriptions in the response that are not available to subscribe the user to anymore, such as those that are already unsubscribed and resubscription is blocked.
     */
    IncludeHiddenSubscriptions?: boolean;
    /**
     * Setting this will filter subscriptions based on who can unsubscribe from it.
     */
    AllowUnsubscribeBy?: AllowUnsubscribeByType;
    /**
     * Entity type: LoyaltyProgramGroup
     */
    LoyaltyProgramGroupID?: number;
    /**
     * Entity type: Company
     */
    CompanyID?: number;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    Name?: string;
    LoyaltyProgramOptions?: LoyaltyProgramOptions;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface GetUserLoyaltySubscriptionsResponse {
    Result?: PagedResult<UserSubscriptionDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get all User subscriptions for all OUs.
   */
  export interface GetAllSubscriptionsByUserID {
    /**
     * Entity type: User
     */
    UserID: number;
  }

  /**
   * Subscribe an User to a Subscription
   * 
   * The service returns the status of the subscription
   */
  export interface SubscribeUser {
    /**
     * Entity type: User
     */
    UserID?: number;
    Subscriptions: SubscribeUser.SubscriptionWithIdentifier[];
  }

  export namespace SubscribeUser {
    export interface SubscriptionWithIdentifier {
      /**
       * Entity type: Subscription
       */
      SubscriptionID?: number;
      /**
       * Entity type: LoyaltyProgram
       */
      LoyaltyProgramID?: number;
      /**
       * Identifier for this user for the given Subscription. P/a: UserSubscriptionIdentifier or a LoyaltyID
       */
      UserIdentifier?: string;
      /**
       * Identifier for the source the user is being subscribed by.
       */
      SourceIdentifier?: string;
      /**
       * If the user is already subscribed, but the UserIdentifier is different, the UserIdentifier will be updated.
       * NOTE THAT the old UserIdentifier will be overwritten and when the given UserIdentifier is already used, subscribing the user will fail.
       */
      UpdateUserIdentifierWhenChanged?: boolean;
    }

  }

  export interface SubscribeUserResponse {
    Subscriptions?: SubscribeUserResponse.SubscriptionWithStatus[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace SubscribeUserResponse {
    export interface SubscriptionWithStatus {
      /**
       * Entity type: UserSubscription
       */
      ID?: number;
      /**
       * Entity type: Subscription
       */
      SubscriptionID?: number;
      /**
       * Entity type: LoyaltyProgram
       */
      LoyaltyProgramID?: number;
      /**
       * Identifier for this user for the given Subscription. P/a: UserSubscriptionIdentifier or a LoyaltyID
       */
      UserIdentifier?: string;
      Status?: SubscriptionStatus;
    }

  }

  /**
   * Unsubscribes an User from a Subscription
   * 
   * The service returns the status of the subscription
   */
  export interface UnsubscribeUser {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Subscription
     */
    SubscriptionID?: number;
    /**
     * Identifier for the source the user is being unsubscribed by.
     */
    SourceIdentifier?: string;
    /**
     * Reason for unsubscribing.
     */
    UnsubscribeReason?: string;
  }

  export interface UnsubscribeUserResponse {
    Status: SubscriptionStatus;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update the user identifier on a user subscription
   */
  export interface UpdateSubscriptionUserIdentifier {
    /**
     * Entity type: User
     */
    UserID: number;
    /**
     * Entity type: Subscription
     */
    SubscriptionID: number;
    UserIdentifier: string;
  }

  /**
   * Fetches the user by its BackendID from the configured external provider. This service is usually used in combination with a call to SearchUsers. This service will create a user in EVA based on the details returned by the external provider if we don't already have a user with the same BackendID. Passing in the OrderID will attach the (created) user to the given order directly as well.
   */
  export interface FetchUserFromExternalProvider {
    /**
     * BackendID that is returned from the `SearchUsers` with the source set to external
     */
    BackendID: string;
  }

  export interface FetchUserFromExternalProviderResponse {
    /**
     * Entity type: User
     */
    ID?: number;
    BackendID?: string;
    BackendSystemID?: string;
    BackendRelationID?: string;
    EmailAddress?: string;
    EmailAddressValidated?: boolean;
    Initials?: string;
    FirstName?: string;
    LastName?: string;
    FullName?: string;
    DateOfBirth?: string;
    PlaceOfBirth?: string;
    Gender?: string;
    Company?: CompanyDto;
    Type?: UserTypes;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    IsDeactivated?: boolean;
    DeactivationDate?: string;
    LastSuccessfulLogin?: string;
    Nickname?: string;
    BankAccount?: string;
    IsDebtor?: boolean;
    PhoneNumber?: string;
    TimeZone?: string;
    FiscalID?: string;
    SocialSecurityNumber?: string;
    Title?: string;
    Salutation?: string;
    /**
     * Entity type: OrganizationUnit
     */
    PreferredStoreID?: number;
    CustomID?: string;
    /**
     * Entity type: User
     */
    CreatedByID?: number;
    CreatedByFullName?: string;
    CreationTime?: string;
    /**
     * Entity type: User
     */
    LastModifiedByID?: number;
    ModifiedByFullName?: string;
    LastModificationTime?: string;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    PricingGroupID?: string;
    AllowPasswordLogin?: boolean;
    SingleSignOnOnly?: boolean;
    AccountType?: UserAccountType;
    HasOpenCases?: boolean;
    /**
     * Entity type: VisibilityGroup
     */
    VisibilityGroupID?: number;
    VisibilityGroupName?: string;
    SingleSignOnID?: string;
    ShippingAddress?: AddressDataDto;
    BillingAddress?: AddressDataDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Sends an email validation code to your current user's email address.
   */
  export interface ValidateUserEmailAddress {
  }

  /**
   * Confirms an email address validation by entering the code that was sent through `ValidateUserEmailAddress`.
   */
  export interface ConfirmUserEmailAddressValidation {
    Code: string;
  }

  /**
   * Create and attach a new company to an User
   * 
   * Only Name is required.
   */
  export interface CreateCompanyForUser {
    /**
     * Entity type: User
     */
    UserID?: number;
    Name?: string;
    RegistrationNumber?: string;
    RegistrationCity?: string;
    /**
     * Entity type: Country
     */
    RegistrationCountryID?: string;
    VatNumber?: string;
    FiscalID?: string;
    EstablishedDate?: string;
    ContactEmailAddress?: string;
    ContactPhoneNumber?: string;
    AccountHolderName?: string;
    IBAN?: string;
    BIC?: string;
  }

  /**
   * Remove the company association from the specified UserID.
   */
  export interface DetachCompanyFromUser {
    /**
     * Entity type: User
     */
    UserID: number;
  }

  /**
   * Return the Company attached to the given User
   */
  export interface GetCompanyForUser {
    /**
     * Entity type: User
     */
    UserID: number;
  }

  export interface GetCompanyForUserResponse {
    Result: CompanyDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Updates the current Company on specified `UserID`, or the current user when omitted.
   * 
   * :no_entry: Requires employee rights when using a `UserID` different than the current user.
   * :warning: Will overwrite *all* company fields, those fields omitted in your request will be removed! Except for FiscalID, that will be kept if not provided.
   */
  export interface UpdateCompanyForUser {
    /**
     * Entity type: User
     */
    UserID?: number;
    Name?: string;
    RegistrationNumber?: string;
    RegistrationCity?: string;
    RegistrationCountryID?: string;
    VatNumber?: string;
    FiscalID?: string;
    EstablishedDate?: string;
    ContactEmailAddress?: string;
    ContactPhoneNumber?: string;
    AccountHolderName?: string;
    IBAN?: string;
    BIC?: string;
    VisitorsAddress?: AddressDataDto;
    InvoiceAddress?: AddressDataDto;
  }

  /**
   * List borrowed products based on the given filter
   */
  export interface ListUserBorrowedProducts {
    PageConfig?: PageConfig<ListUserBorrowedProductsFilter>;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProductProperties?: string[];
  }

  export interface ListUserBorrowedProductsFilter {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    States?: BorrowedState[];
  }

  export const enum BorrowedState {
    Open = 0,
    Returned = 1,
    Purchased = 2
  }

  export interface ListUserBorrowedProductsResponse {
    UserProductOpenQuantities: ListUserBorrowedProductsResponse.UserProductQuantity[];
    Result?: PagedResult<ListUserBorrowedProductsResponse.Model>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListUserBorrowedProductsResponse {
    export interface Model {
      /**
       * Entity type: User
       */
      UserID: number;
      UserFullName: string;
      /**
       * Entity type: Product
       */
      ProductID: number;
      ProductName: string;
      ProductBackendID: string;
      Product: any;
      State: BorrowedState;
      /**
       * Entity type: Order
       */
      OrderID?: number;
      CreatedByUser: ListUserBorrowedProductsResponse.UserModel;
      CreationTime: string;
      ModifiedByUser: ListUserBorrowedProductsResponse.UserModel;
      ModificationTime?: string;
    }

    export interface UserModel {
      /**
       * Entity type: User
       */
      ID: number;
      FullName: string;
    }

    export interface UserProductQuantity {
      /**
       * Entity type: User
       */
      UserID: number;
      /**
       * Entity type: Product
       */
      ProductID: number;
      Quantity: number;
    }

  }

  /**
   * Register user borrowed products
   */
  export interface RegisterUserBorrowedProducts {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Min: 0
     */
    Quantity?: number;
    SerialNumber?: string;
  }

  /**
   * Return user borrowed products. When IsDamaged is set to true, the stock will be moved to Damaged. Otherwise, the stock will be moved to Sellable.
   */
  export interface ReturnUserBorrowedProducts {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Min: 0
     */
    Quantity?: number;
    IsDamaged?: boolean;
    SerialNumber?: string;
  }

  /**
   * Add user borrowed products to order. When no quantity is given, all borrowed products with the given product ID are added to the order.
   */
  export interface AddUserBorrowedProductToOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: User
     */
    UserID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Min: 0
     */
    Quantity?: number;
  }

  export interface AddUserBorrowedProductToOrderResponse {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Created OrderLineIDs
     * Entity type: OrderLine
     */
    OrderLineIDs: number[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Render a UserInteraction of Type Communication in something that can be displayed.
   * 
   * This can be used to view the send emails in a webview/iframe.
   */
  export interface PreviewUserInteractionCommunication {
    /**
     * Entity type: Interaction
     */
    ID: number;
  }

  export interface PreviewUserInteractionCommunicationResponse {
    Content?: string;
    ToName?: string;
    ToAddress?: string;
    FromName?: string;
    FromAddress?: string;
    Attachments?: PreviewUserInteractionCommunicationResponse.Attachment[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace PreviewUserInteractionCommunicationResponse {
    export interface Attachment {
      ID: string;
      Name: string;
      MediaType: string;
    }

  }

  /**
   * Prepare an attachment of an UserInteraction to be downloaded, will return an url that is valid for 5min.
   */
  export interface DownloadUserInteractionCommunicationAttachment {
    /**
     * Entity type: Interaction
     */
    ID: number;
    AttachmentID: string;
  }

  export interface ResourceWithBlobIDResponseMessage {
    ResourceInfo: ResourceInfo;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Resend a UserInteraction of Type Communication
   * 
   * When no EmailAddress is supplied, the original recipient will be used.
   */
  export interface ResendUserInteractionCommunication {
    /**
     * Entity type: Interaction
     */
    ID?: number;
    EmailAddress?: string;
  }

  /**
   * Get a UserInteration by its ID. A UserInteraction logs an interaction between an employee and a customer, for example the fact the customer was called.
   */
  export interface GetUserInteractionByID {
    /**
     * Entity type: Interaction
     */
    ID: number;
  }

  export interface GetUserInteractionByIDResponse {
    /**
     * Entity type: Interaction
     */
    ID: number;
    /**
     * Entity type: User
     */
    UserID: number;
    User: GetUserInteractionByIDResponse.UserDto;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    CreatedBy: GetUserInteractionByIDResponse.UserDto;
    /**
     * Entity type: User
     */
    LastModifiedByID?: number;
    LastModifiedBy: GetUserInteractionByIDResponse.UserDto;
    Text?: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
    InteractionType: InteractionType;
    Subject?: string;
    CreationTime: string;
    /**
     * Entity type: Interaction
     */
    OriginalUserInteractionID?: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetUserInteractionByIDResponse {
    export interface UserDto {
      FirstName: string;
      LastName: string;
      EmailAddress: string;
      FullName: string;
    }

  }

  export const enum UserInteractionTypes {
    /**
     * @deprecated Use InteractionType.PrivateNote instead
     */
    Manual = 0,
    /**
     * @deprecated Use InteractionType.Email instead
     */
    Communication = 1
  }

  export const enum InteractionType {
    /**
     * @deprecated Use InteractionType.PublicNote instead
     */
    Communication = 0,
    PublicNote = 0,
    /**
     * @deprecated Use InteractionType.PrivateNote instead
     */
    Note = 1,
    PrivateNote = 1,
    Ledger = 2,
    Email = 3
  }

  /**
   * Creates a UserInteraction. A UserInteraction logs an interaction between an employee and a customer, for example the fact the customer was called.
   * 
   * UserID is optional but only if OrderID is also provided and the given Order is attached to a customer. If so then the UserInteraction is attached to the Order.Customer.
   */
  export interface CreateUserInteraction {
    /**
     * Entity type: User
     */
    UserID?: number;
    Text: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
  }

  export interface CreateUserInteractionResponse {
    /**
     * Entity type: Interaction
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Updates a UserInteraction. A UserInteraction logs an interaction between an employee and a customer, for example the fact the customer was called.
   * 
   * UserID is optional but only if OrderID is also provided and the given Order is attached to a customer. If so then the UserInteraction is attached to the Order.Customer.
   */
  export interface UpdateUserInteraction {
    /**
     * Entity type: Interaction
     */
    ID: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    Text: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
  }

  /**
   * Deletes a UserInteraction.
   */
  export interface DeleteUserInteraction {
    /**
     * Entity type: Interaction
     */
    ID: number;
  }

  export interface ListUserInteractions {
    PageConfig?: PageConfig<ListUserInteractionsFilter>;
  }

  export interface ListUserInteractionsFilter {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
    Text?: string;
    InteractionType?: InteractionType;
    IncludeResends?: boolean;
  }

  export interface ListUserInteractionsResponse {
    Result?: PagedResult<ListUserInteractionsResponse.UserInteractionDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListUserInteractionsResponse {
    export interface UserInteractionDto {
      /**
       * Entity type: Interaction
       */
      ID?: number;
      /**
       * Entity type: User
       */
      UserID?: number;
      User?: UserInteractionDto.UserDto;
      /**
       * Entity type: User
       */
      CreatedByID?: number;
      CreatedBy?: UserInteractionDto.UserDto;
      /**
       * Entity type: User
       */
      LastModifiedByID?: number;
      LastModifiedBy?: UserInteractionDto.UserDto;
      Text?: string;
      /**
       * Entity type: Order
       */
      OrderID?: number;
      /**
       * Entity type: UserTask
       */
      UserTaskID?: number;
      InteractionType?: InteractionType;
      CreationTime?: string;
      OriginalUserInteraction?: ListUserInteractionsResponse.UserInteractionDto;
      /**
       * Entity type: MessageTemplate
       */
      MessageTemplateID?: number;
    }

    export namespace UserInteractionDto {
      export interface UserDto {
        FullName: string;
        FirstName: string;
        LastName: string;
        EmailAddress: string;
      }

    }

  }

  export interface PushUserInteractionContent {
    /**
     * Entity type: Interaction
     */
    ID: number;
    ToEmailAddress: string;
    ToName?: string;
    FromEmailAddress: string;
    FromName?: string;
    Subject: string;
    BodyHTML: string;
  }

  /**
   * @deprecated Specialized services are available.
   * Service for listing transput jobs
   */
  export interface ListTransputJobs {
    InitialPageConfig?: PageTokenConfig<ListTransputJobsFilter>;
    PageToken?: string;
  }

  export interface ListTransputJobsFilter {
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
    Status: number[];
    /**
     * Entity type: TransputJobType
     */
    Types: number[];
    Identifier: string;
    Name: string;
    StartTimeBefore?: string;
    StartTimeOnOrAfter?: string;
    EndTimeBefore?: string;
    EndTimeOnOrAfter?: string;
    CreationTimeBefore?: string;
    CreationTimeOnOrAfter?: string;
    /**
     * Entity type: OrganizationUnit
     */
    ShipFromOrganizationUnit?: number;
    /**
     * Entity type: OrganizationUnit
     */
    ShipToOrganizationUnit?: number;
  }

  export interface ListTransputJobsResponse {
    Results?: TransputJobWithRelatedExportDataDto[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface TransputJobWithRelatedExportDataDto {
    /**
     * Entity type: TransputJob
     */
    ID: number;
    Status: TransputJobStatuses;
    TypeID: number;
    Identifier: string;
    CreationTime: string;
    StartTime?: string;
    EndTime?: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: OrderExport
     */
    OrderExportID?: number;
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    /**
     * Entity type: ShipmentExport
     */
    ShipmentExportID?: number;
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
    /**
     * Entity type: InvoiceExport
     */
    InvoiceExportID?: number;
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    /**
     * Entity type: FinancialPeriodExport
     */
    FinancialPeriodExportID?: number;
    Name: string;
    /**
     * Entity type: OrganizationUnit
     */
    ShipFromOrganizationUnit?: number;
    ShipFromOrganizationUnitName?: string;
    /**
     * Entity type: OrganizationUnit
     */
    ShipToOrganizationUnit?: number;
    ShipToOrganizationUnitName?: string;
    Type: EnumDto;
  }

  export const enum TransputJobStatuses {
    New = 0,
    Running = 1,
    Finished = 2,
    Failed = -1
  }

  export interface EnumDto {
    /**
     * Entity type: Enum
     */
    ID: number;
    /**
     * Usually an internal & unchangable code - for display, use `Description`
     */
    Name: string;
    Description: string;
  }

  /**
   * Creates an EntityTranslation if one does not exist yet, otherwise it replaces the current one.
   */
  export interface ReplaceEntityTranslation {
    /**
     * The Identifier of the object you are translating, in case of a Discount this would be the DiscountID
     */
    EntityID: string;
    /**
     * The name of the object you are translating, in case of a Discount this would be 'Discount'
     */
    EntityType: string;
    /**
     * The name of the property you are translating, in case of translating the Description of a Discount this would be 'Description'
     */
    EntityField: string;
    LanguageID: string;
    CountryID?: string;
    /**
     * The translated value for the property you are translating
     */
    Value: string;
  }

  /**
   * Service for retrieving a list of `EntityTranslation`
   */
  export interface ListEntityTranslations {
    PageConfig?: PageConfig<ListEntityTranslationsFilter>;
  }

  export interface ListEntityTranslationsFilter {
    EntityID: string;
    EntityType: string;
    EntityField: string;
    LanguageID: string;
    CountryID: string;
    Value: string;
  }

  export interface ListEntityTranslationsResponse {
    Result?: PagedResult<ListEntityTranslation>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListEntityTranslation {
    EntityID: string;
    EntityType: string;
    EntityField: string;
    LanguageID: string;
    CountryID: string;
    Value: string;
  }

  /**
   * Service for deleting an existing `EntityTranslation`
   */
  export interface DeleteEntityTranslation {
    EntityID: string;
    EntityType: string;
    EntityField: string;
    LanguageID: string;
    CountryID?: string;
  }

  /**
   * Copies EntityTranslations from one entity to another. Replaces any existing translations of the target entity.
   */
  export interface CopyEntityTranslations {
    /**
     * The Identifier of the object you are translating from, in case of a Discount this would be the DiscountID
     */
    SourceEntityID: string;
    /**
     * The Identifier of the object you are translating to, in case of a Discount this would be the DiscountID
     */
    TargetEntityID: string;
    /**
     * The name of the object you are translating, in case of a Discount this would be 'Discount'
     */
    EntityType: string;
    /**
     * When provided, will only copy the translations for the given language.
     */
    LanguageID?: string;
    /**
     * When provided, will only copy the translations for the given country.
     */
    CountryID?: string;
  }

  /**
   * Service for retrieving an existing `EntityTranslation`
   */
  export interface GetEntityTranslation {
    EntityID: string;
    EntityType: string;
    EntityField: string;
    LanguageID: string;
    CountryID?: string;
  }

  export interface GetEntityTranslationResponse {
    EntityID: string;
    EntityType: string;
    EntityField: string;
    LanguageID: string;
    CountryID: string;
    Value: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Creates an StringTranslation if one does not exist yet, otherwise it replaces the current one.
   */
  export interface ReplaceStringTranslation {
    Key: string;
    LanguageID: string;
    CountryID: string;
    Value: string;
  }

  /**
   * Service for retrieving a list of `StringTranslation`
   */
  export interface ListStringTranslations {
    PageConfig?: PageConfig<ListStringTranslationsFilter>;
  }

  export interface ListStringTranslationsFilter {
    Key: string;
    LanguageID: string;
    CountryID: string;
    Value: string;
  }

  export interface ListStringTranslationsResponse {
    Result?: PagedResult<ListStringTranslation>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListStringTranslation {
    Key: string;
    LanguageID: string;
    CountryID: string;
    Value: string;
  }

  /**
   * Service for deleting an existing `StringTranslation`
   */
  export interface DeleteStringTranslation {
    Key: string;
    LanguageID: string;
    CountryID: string;
  }

  /**
   * Service for retrieving a `StringTranslation`
   */
  export interface GetStringTranslation {
    Key: string;
    LanguageID: string;
    CountryID: string;
  }

  export interface GetStringTranslationResponse {
    Key: string;
    LanguageID: string;
    CountryID: string;
    Value: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * To continue with a suspended order, use the `ResumeSuspendedOrder` service.
   */
  export interface ListSuspendedOrders {
    PageConfig?: PageConfig<ListSuspendedOrdersFilter>;
  }

  export interface ListSuspendedOrdersFilter {
    IsPaid?: boolean;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    Description: string;
  }

  export interface ListSuspendedOrdersResponse {
    Result?: PagedResult<ListSuspendedOrdersResponse.SuspendedOrderDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListSuspendedOrdersResponse {
    export interface SuspendedOrderDto {
      /**
       * Entity type: Order
       */
      OrderID: number;
      OrderDisplayID: string;
      Description: string;
      TotalAmount: number;
      TotalAmountInTax: number;
      CurrencyID: string;
      CustomerName: string;
      SuspendedByName: string;
      SuspensionTime: string;
    }

  }

  /**
   * When you would like to temporarily suspend an order, you can use `SuspendOrder` to do so.
   * 
   * - To identify your suspended order it is possible to supply a `Description`
   * - To print a receipt of the suspended order, to make it easier to continue later on, supply `PrintReceipt` (and optionally a `StationID`)
   * - To retreive the suspended orders, see the `ListSuspendedOrders` service
   */
  export interface SuspendOrder {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    Description?: string;
    /**
     * Entity type: Station
     */
    StationID?: number;
    PrintReceipt?: boolean;
  }

  /**
   * When you would like to resume a suspended order, you can use `ResumeSuspendedOrder` to do so. This will remove the suspended state from the order.
   */
  export interface ResumeSuspendedOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Service for retrieving a list of `OrganizationUnitSupplier` by `OrganizationUnit`
   */
  export interface GetSuppliersForOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetSuppliersForOrganizationUnitResponse {
    Result: GetSuppliersForOrganizationUnitResponse.Model[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetSuppliersForOrganizationUnitResponse {
    export interface Model {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Service for creating a `OrganizationUnitSupplier`
   */
  export interface CreateOrganizationUnitSupplier {
    /**
     * This will be the OrganizationUnit that will be supplied to by the supplier.
     * 
     * If neither OrganizationUnitID or OrganizationUnitSetID or OrganizationUnitIDs are specified then all children of the supplier are automatically supplied to.
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * The OrganizationUnits in this set will be the OrganizationUnits that will be supplied to by the supplier.
     * Adding OrganizationUnits to this set in the future will not result in those OrganizationUnits being automatically added to this collection.
     * 
     * If neither OrganizationUnitID or OrganizationUnitSetID or OrganizationUnitIDs are specified then all children of the supplier are automatically supplied to.
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * These will be the OrganizationUnits that will be supplied to by the supplier.
     * 
     * If neither OrganizationUnitID or OrganizationUnitSetID or OrganizationUnitIDs are specified then all children of the supplier are automatically supplied to.
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    Target?: OrganizationUnitSupplierTargets;
    /**
     * This will be the OrganizationUnit that becomes the supplier in this supplier relationship.
     * 
     * Either SupplierOrganizationUnitID or SupplierOrganizationUnitSetID or SupplierOrganizationUnitIDs must be specified to be a valid request.
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID?: number;
    /**
     * The OrganizationUnits in this set will be the OrganizationUnits that will be the suppliers
     * 
     * Either SupplierOrganizationUnitID or SupplierOrganizationUnitSetID or SupplierOrganizationUnitIDs must be specified to be a valid request.
     * Entity type: OrganizationUnitSet
     */
    SupplierOrganizationUnitSetID?: number;
    /**
     * These will be the OrganizationUnits that becomes the suppliers in this supplier relationship.
     * 
     * Either SupplierOrganizationUnitID or SupplierOrganizationUnitSetID or SupplierOrganizationUnitIDs must be specified to be a valid request.
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitIDs?: number[];
  }

  export const enum OrganizationUnitSupplierTargets {
    Default = 0,
    Replenishment = 1,
    SupplierReturns = 2,
    Pickup = 3
  }

  export const enum OrganizationUnitSupplierTypes {
    Internal = 0,
    External = 1
  }

  export interface CreateOrganizationUnitSupplierResponse {
    /**
     * Entity type: OrganizationUnitSupplier
     */
    OrganizationUnitSupplierIDs: number[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for updating a existing `OrganizationUnitSupplier`
   */
  export interface UpdateOrganizationUnitSupplier {
    /**
     * Entity type: OrganizationUnitSupplier
     */
    ID: number;
    Target?: OrganizationUnitSupplierTargets;
  }

  export interface DeleteOrganizationUnitSupplier {
    /**
     * Entity type: OrganizationUnitSupplier
     */
    ID: number;
  }

  /**
   * Service for retrieving a list of `OrganizationUnitSupplier`
   */
  export interface ListOrganizationUnitSuppliers {
    PageConfig?: PageConfig<ListOrganizationUnitSuppliersFilter>;
  }

  export interface ListOrganizationUnitSuppliersFilter {
    /**
     * Entity type: OrganizationUnitSupplier
     */
    ID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OrganizationUnitName?: string;
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID?: number;
    SupplierOrganizationUnitName?: string;
    Target?: OrganizationUnitSupplierTargets;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
  }

  export interface ListOrganizationUnitSuppliersResponse {
    Result?: PagedResult<ListOrganizationUnitSuppliersModel>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListOrganizationUnitSuppliersModel {
    /**
     * Entity type: OrganizationUnitSupplier
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID: number;
    SupplierOrganizationUnitName: string;
    Target: OrganizationUnitSupplierTargets;
  }

  /**
   * Book a set of Adjustments to modify stock.
   * 
   * An Adjustment should have a `ProductID` to identify the product, an `OrganizationUnitID` to identify the stock keeping organization, a `StockLabelID` (see `GetEnumValues` with type `StockLabel`),
   * a `StockMutationReasonID` (see `GetEnumValues` with type `StockMutationReasons`) and of course a `Quantity` to actually book.
   * 
   * Supply a `BackendSystemID` on the request and `BackendID`'s on the Adjustments to make the request idempotent (optional). When one adjustment in your request fails, all of them will fail. Duplicate
   * keys will not be processed again and yield a warning (but thus will not block!).
   * 
   * Optionally supports a `Remark` for each Adjustment.
   * 
   * When specifying a `SerialNumber`, please note the `Quantity` of this adjustment then should either be -1 or 1!
   * 
   * Set `Adjustment.Absolute` to `true` to specify an absolute quantity instead of a delta.
   */
  export interface AdjustStock {
    /**
     * Optional, unique identifier for the system that owns the `Adjustment.BackendID` as key for the mutation
     */
    BackendSystemID?: string;
    Adjustments: AdjustStock.Adjustment[];
  }

  export namespace AdjustStock {
    export interface Adjustment {
      /**
       * Optional, unique identifier for the mutation, combined with the root `BackendSystemID`
       */
      BackendID?: string;
      /**
       * Required product identifier (use the `EVA-IDs-Mode` header to switch identifier keys (`Product.ID`, `Product.BackendID`, ...)
       * Entity type: Product
       */
      ProductID: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      /**
       * Entity type: StockLabel
       */
      StockLabelID: number;
      /**
       * Entity type: StockMutationReasons
       */
      StockMutationReasonID: number;
      Quantity: number;
      /**
       * Indicates if `Quantity` is a absolute
       * @default false
       */
      Absolute?: boolean;
      Remark?: string;
      SerialNumber?: string;
    }

  }

  /**
   * This service allows you to manually commit the stock for the given OrderLineIDs.
   * The response contains whether or not the commitment was successful, per OrderLine.
   * 
   * Commitment can be unsucessful for two reasons:
   * 
   * - No commitment is necessary. This is because it's an OrderLine that can't be committed, for example one without a stock product, or because the order type doesn't allow commitments.
   * - Insufficient stock. This service only allows creating a commitment when there's sufficient available stock. Use the MoveCommitments or UncommitOrderLines services to create available stock.
   */
  export interface CommitOrderLines {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    OrderLines?: CommitOrderLines.CommitOrderLine[];
    CommitmentStatus?: OrderLineCommitmentStatus;
  }

  export namespace CommitOrderLines {
    export interface CommitOrderLine {
      /**
       * Entity type: OrderLine
       */
      ID: number;
      /**
       * If specified as non-null and less than the open quantity on the OrderLine this will causse the OrderLine to be split into two.
       * The ID of the new OrderLine will be returned in the response and the object will have a reference to the OriginalOrderLineID, which is the ID that was specified in the request.
       */
      QuantityToCommit?: number;
    }

  }

  export const enum OrderLineCommitmentStatus {
    Uncommitted = 0,
    SoftCommit = 1,
    HardCommit = 2,
    ManualCommit = 5,
    ForcedCommit = 10
  }

  export interface CommitOrderLinesResponse {
    Results: CommitOrderLinesResponse.CommitmentResultForOrderLine[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace CommitOrderLinesResponse {
    export interface CommitmentResultForOrderLine {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      IsCommitted: boolean;
      /**
       * Entity type: OrderLine
       */
      OriginalOrderLineID?: number;
    }

  }

  /**
   * This service allows you to move stock commitments from one OrderLine (`SourceOrderLineID`) to another OrderLine (`DestinationOrderLineID`).
   * 
   * - If the Source and Destination do not share the same ProductID, a `CannotMoveCommitment` error is returned.
   * - If the Source does not have a commitment, a `CannotMoveCommitment` error is returned.
   */
  export interface MoveCommitments {
    Movements?: MoveCommitments.CommitmentMovement[];
  }

  export namespace MoveCommitments {
    export interface CommitmentMovement {
      /**
       * Entity type: OrderLine
       */
      SourceOrderLineID: number;
      /**
       * Entity type: OrderLine
       */
      DestinationOrderLineID: number;
    }

  }

  /**
   * This service allows you to undo a commitment on the given OrderLineIDs, making the committed stock available to other orders again.
   */
  export interface UncommitOrderLines {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineIDs?: number[];
  }

  /**
   * Creates a stock mutation for the given organization unit and product. Note that this service supports creating delta's as well as modifying in absolute quantities based on the `Delta` property.'
   */
  export interface CreateStockMutations {
    OrganizationUnitBackendID?: string;
    Mutations: CreateStockMutations.StockMutation[];
  }

  export namespace CreateStockMutations {
    export interface StockMutation {
      ProductBackendID: string;
      Timestamp: string;
      Quantity: number;
      Reason: string;
      Remark: string;
      Delta: boolean;
      SerialNumber?: string;
    }

  }

  /**
   * This service returns information about product availability.
   */
  export interface GetProductAvailability {
    Products?: GetProductAvailability.Product[];
    /**
     * By default the availability is calculated from the perspective of your current OrganizationUnit, which determines which warehouse(s) stock is sourced
     * from, among other things. You can override the default with an OrganizationUnitID of your choosing and calculate availability from that
     * OrganizationUnit's perspective.
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Contains options that let you influence the availability calculation.
     */
    Options?: GetProductAvailabilityOptions;
  }

  export namespace GetProductAvailability {
    export interface Product {
      /**
       * Entity type: Product
       * 
       * Allows missing/invalid values when using EVA-IDs-Mode: ExternalIDs.
       */
      ID?: number;
      /**
       * Required when `ID` is omitted.
       */
      BackendID?: string;
      /**
       * @default 1
       */
      QuantityRequested?: number;
      /**
       * Entity type: ShippingMethod
       */
      ShippingMethodID?: number;
    }

  }

  export interface GetProductAvailabilityOptions {
    /**
     * Contains options that let you influence if and how delivery availability is calculated. If not specified at all then no delivery availability is
     * calculated and returned.
     */
    Delivery?: GetProductAvailabilityOptions.DeliveryAvailability;
    /**
     * Contains options that let you influence if and how pickup availability is calculated. If not specified at all then no pickup availability is
     * calculated and returned.
     */
    Pickup?: GetProductAvailabilityOptions.PickupAvailability;
    CarryOut?: GetProductAvailabilityOptions.CarryOutAvailability;
    /**
     * If set to true then the QuantityAvailable is returned. By default this information is only accessible to Employee-type users.
     */
    QuantityAvailable?: boolean;
    /**
     * In addition to the normal data, additional detailed information can be returned for the provided OrganizationUnits and Products.
     * 
     * This information includes the entire supplier hierarchy for each OrganizationUnit, telling you where stock originates from, where it's currently committed.
     * 
     * Also includes information about expected future stock and allocation assignments.
     * 
     * Providing this field as an empty object is interpreted as a request to include this information for all organizations and products.
     */
    ProductAvailabilityDetails?: GetProductAvailabilityOptions.ProductAvailabilityDetailsOptions;
    /**
     * If set to true then the availability of related stock replacing products is returned.
     */
    IncludeRelatedStockReplacingProducts?: boolean;
    /**
     * Contains options that allow you to influence how bundle availability is calculated.
     */
    Bundles?: GetProductAvailabilityOptions.ProductBundleAvailabilityOptions;
  }

  export namespace GetProductAvailabilityOptions {
    export interface ProductAvailabilityDetailsOptions {
      /**
       * Which organization(s) to get the details for, defaults to the OrganizationUnitID provided in the request or to your current organization.
       * Entity type: OrganizationUnit
       * 
       * Allows missing/invalid values when using EVA-IDs-Mode: ExternalIDs.
       */
      OrganizationUnitIDs?: number[];
      /**
       * Entity type: Product
       * 
       * Allows missing/invalid values when using EVA-IDs-Mode: ExternalIDs.
       */
      ProductIDs?: number[];
      /**
       * Determines whether or not the detailed information for the requested organization(s) recursively includes the stock details of their suppliers as well.
       * Defaults to false if both OrganizationUnitIDs and ProductIDs is left empty, otherwise it defaults to true.
       * Setting this to false limits the response size in case you only care about the stock details of the specific requested organization(s).
       */
      IncludeSuppliers?: boolean;
    }

    export interface ProductBundleAvailabilityOptions {
      /**
       * Determines how bundle availability is calculated. By default the bundle is said to be available when all required lines of the bundle have at least
       * one option that has stock. The alternative is that the bundle is only considered available when the default product for each line has stock.
       * 
       * If not provided then the value of the `ProductBundleAvailabilityCalculationMethod` EVA setting is used.
       */
      AvailabilityCalculationMethod?: ProductBundleAvailabilityCalculationMethods;
      /**
       * When the availability of a bundle is calculated it means that all the products that are part of the bundle become part of the output of
       * GetProductAvailability. If this option is turned on, the service will also return information about the bundle to make sense of those extra products.
       */
      IncludeBundleInformation?: boolean;
    }

    export const enum PickupTypes {
      /**
       * Returns the shop that has the earliest availability date for each product.
       */
      FastestShop = 0,
      /**
       * Returns the pickup availability date for your current shop.
       */
      CurrentShop = 1
    }

    export const enum CarryOutTypes {
      /**
       * Returns the shop that has the most stock available for each product.
       */
      MostStock = 0,
      /**
       * Returns the carry-out availability date for your current shop.
       */
      CurrentShop = 1
    }

    export interface IAvailabilityRequestOptions {
      InRadius: GetProductAvailabilityOptions.PickupRadius;
    }

    export interface CarryOutAvailability {
      /**
       * If specified as true then all relevant shop OrganizationUnits are returned, whether they have available stock or not.
       * 
       * Defaults to false and only has effect if `IncludeCarryOutOrganizationUnits` is set to `true`.
       */
      IncludeOrganizationUnitsWithoutStock?: boolean;
      /**
       * If specified as true the response will contain the pickup organizations. Which organizations are included depends on the rest of the request:
       * 
       * - If a rectangular area is specified through `InArea` it will contain the organizations within the area.
       * - If the radius is specified through `InRadius` it will contain the organizations within the radius of the given center co-ordinates.
       * - If an explicit list of organizations is specified through `OrganizationUnitIDs` then those are returned.
       * 
       * In all cases, whether or not all of them are returned or only those that contain stock is determined by `IncludeOrganizationUnitsWithoutStock`. By
       * default only organizations with stock are returned.
       * 
       * If the request specifies more than one product, the organization will only be returned if *all* products have stock (unless
       * `IncludeOrganizationUnitsWithoutStock` is `true`).
       */
      IncludeCarryOutOrganizationUnits?: boolean;
      /**
       * This can be optionally used to provide a list of shops for which you would like to check carry-out availability.
       * Entity type: OrganizationUnit
       */
      OrganizationUnitIDs?: number[];
      /**
       * Select the organizations that are considered for carry-out based on a rectangular area defined by the top-left and bottom-right co-ordinates.
       */
      InArea?: GetProductAvailabilityOptions.PickupArea;
      /**
       * Select the organizations that are considered for carry-out based on a circular area defined by the center co-ordinate and a radius (specified in km).
       */
      InRadius?: GetProductAvailabilityOptions.PickupRadius;
      /**
       * When the carry-out organizations are returned, this determines what returned opening-hours are returned. See each value of the enum for details.
       */
      OpeningHoursType?: GetProductAvailabilityOptions.PickupOrganizationUnitOpeningHoursType;
      Type?: GetProductAvailabilityOptions.CarryOutTypes;
    }

    export interface PickupAvailability {
      /**
       * Include the expected date on which the provided products can be picked-up from a shop.
       */
      AvailabilityDate?: boolean;
      /**
       * This field lets you specify whether the pickup availability date you get back (in case you requested it) for each product should be based on your
       * current OrganizationUnit, or whether it should be the OrganizationUnit that has the earliest availability for the product. Defaults to FastestShop.
       */
      Type?: GetProductAvailabilityOptions.PickupTypes;
      OrganizationUnitType?: OrganizationUnitTypes;
      /**
       * If specified as true then all relevant pick-up OrganizationUnits are returned, whether they have available stock or not.
       * 
       * Defaults to false and only has effect if `IncludePickupOrganizationUnits` is set to `true`.
       */
      IncludeOrganizationUnitsWithoutStock?: boolean;
      /**
       * If specified as true the response will contain the pickup organizations. Which organizations are included depends on the rest of the request:
       * 
       * - If a rectangular area is specified through `InArea` it will contain the organizations within the area.
       * - If the radius is specified through `InRadius` it will contain the organizations within the radius of the given center co-ordinates.
       * - If an explicit list of organizations is specified through `OrganizationUnitIDs` then those are returned.
       * 
       * In all cases, whether or not all of them are returned or only those that contain stock is determined by `IncludeOrganizationUnitsWithoutStock`. By
       * default only organizations with stock are returned.
       * 
       * If the request specifies more than one product, the organization will only be returned if *all* products have stock (unless
       * `IncludeOrganizationUnitsWithoutStock` is `true`).
       */
      IncludePickupOrganizationUnits?: boolean;
      /**
       * This can be optionally used to provide a list of shops for which you would like to check pick-up availability.
       * Entity type: OrganizationUnit
       */
      OrganizationUnitIDs?: number[];
      /**
       * Select the organizations that are considered for pickup based on a rectangular area defined by the top-left and bottom-right co-ordinates.
       */
      InArea?: GetProductAvailabilityOptions.PickupArea;
      /**
       * Select the organizations that are considered for pickup based on a circular area defined by the center co-ordinate and a radius (specified in km).
       */
      InRadius?: GetProductAvailabilityOptions.PickupRadius;
      /**
       * When the pickup organizations are returned, this determines what returned opening-hours are returned. See each value of the enum for details.
       */
      OpeningHoursType?: GetProductAvailabilityOptions.PickupOrganizationUnitOpeningHoursType;
    }

    export const enum PickupOrganizationUnitOpeningHoursType {
      /**
       * Openinghours are not returned.
       */
      None = 0,
      /**
       * Openinghours for the next seven days are returned. Each result will contain the date and day-of-week. This will take into account any special
       * upcoming openinghours.
       */
      NextSevenDays = 1,
      /**
       * Openinghours for the current week are returned. Similar to NextSevenDays with the difference that the first item will always be Monday.
       */
      CurrentWeek = 2,
      /**
       * The regular openinghours for each day of the week will be returned without taking into account any special openinghours or holidays.
       */
      Regular = 3
    }

    export interface Coordinate {
      Latitude: number;
      Longitude: number;
    }

    export interface PickupRadius {
      RadiusInKm?: number;
      /**
       * Defaults to the coordinates of the selected OrganizationUnit when not set, but a RadiusInKm is set.
       */
      Center?: GetProductAvailabilityOptions.Coordinate;
      /**
       * Limit OrganizationUnits within the radius to those with the provided country. Optional.
       */
      CountryID?: string;
    }

    export interface PickupArea {
      TopLeft: GetProductAvailabilityOptions.Coordinate;
      BottomRight: GetProductAvailabilityOptions.Coordinate;
      /**
       * Limit OrganizationUnits within the area to those with the provided country. Optional.
       */
      CountryID?: string;
    }

    export interface DeliveryAvailability {
      /**
       * Include the expected date on which the provided products can be home-delivered.
       */
      AvailabilityDate?: boolean;
    }

  }

  export const enum ProductBundleAvailabilityCalculationMethods {
    AnyOptionHasStock = 0,
    DefaultOptionHasStock = 1
  }

  export interface GetProductAvailabilityResponse {
    Products: ProductAvailabilityResult[];
    PickupOrganizationUnits: ProductAvailabilityPickupOrganizationUnit[];
    CarryOutOrganizationUnits: ProductAvailabilityCarryOutOrganizationUnit[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ProductAvailabilityResult {
    /**
     * Entity type: Product
     */
    ProductID?: number;
    ProductStatus?: ProductStatus;
    Delivery?: ProductAvailabilityResult.DeliveryAvailabilityResult;
    Pickup?: ProductAvailabilityResult.PickupAvailabilityResult;
    CarryOut?: ProductAvailabilityResult.CarryOutAvailabilityResult;
    /**
     * Contains the lines and option that this bundle consists of (if the product is a bundle product).
     */
    BundleInformation?: ProductAvailabilityResult.ProductAvailabilityResultBundleInformation;
    StockReplacementInformation?: ProductAvailabilityResult.ProductStockReplacementInformation;
    AvailabilityDetails?: ProductAvailabilityResult.ProductAvailabilityDetails[];
  }

  export namespace ProductAvailabilityResult {
    export interface ProductAvailabilityDetails {
      OrganizationUnit: ProductAvailabilityDetails.OrganizationUnitModel;
      /**
       * The quantity of stock that the OrganizationUnit physically has.
       */
      QuantityOnHand: number;
      /**
       * The quantity that has been committed to this OrganizationUnit.
       */
      QuantityCommitted: number;
      /**
       * The quantity of stock that is still available for the OrganizationUnit, so the amount of physical stock minus its commitments.
       */
      QuantityAvailable: number;
      /**
       * The total quantity of orders that are currently have a fulfillment status of WaitingForStock, meaning that they are waiting until stock becomes available on this OrganizationUnit.
       */
      OrdersWaitingForStockQuantity: number;
      /**
       * The quantity of the physical stock that is available to the OrganizationUnit for which this OrganizationUnit is a supplier.
       * 
       * This can differ from the QuantityOnHand when it comes to stock allocation. It's possible that the supplier reserves stock for certain other OrganizationUnits, meaning
       * that only a portion of the QuantityOnHand is available.
       * 
       * Example: you request stock details for the website, which is supplied by the warehouse organization. There is a stock allocation rule that 80% of the warehouse stock
       * is reserved to shops, so not available to the website. In that case, the website organization will have a stock detail with warehouse as a supplier and the stock detail
       * for the warehouse will (for example) have a QuantityOnHand of 100 but only an EffectiveQuantityOnHand of 20.
       */
      EffectiveQuantityOnHand?: number;
      /**
       * See EffectiveQuantityOnHand, but here the commitments are subtracted from the on hand stock. So if physical stock is 100, 80% is allocated to other organizations and there is a commitment of 11 then EffectiveQuantityAvailable will be 9.
       */
      EffectiveQuantityAvailable?: number;
      /**
       * The quantity committed on all suppliers of this organization
       */
      SupplierQuantityCommitted: number;
      /**
       * The quantity that all suppliers have on hand as far as we know from the perspective of the organization that is supplied by them.
       * 
       * The actual supplier might have more stock physically on hand, but due to allocation rules this might not be available to this organization.
       */
      SupplierQuantityOnHand: number;
      /**
       * The SupplierQuantityOnHand minus the SupplierQuantityCommitted
       */
      SupplierQuantityAvailable: number;
      /**
       * The sum of all StockReservations, meaning the quantities that were reserved on this supplier for other organizations.
       */
      QuantityReservedForOtherOrganizationUnits: number;
      /**
       * The date that this organization is expected to have stock.
       */
      ExpectedAvailabilityDate?: string;
      /**
       * The earliest date that one of the suppliers of this organization has stock.
       */
      ExpectedSupplierAvailabilityDate?: string;
      /**
       * The suppliers for this organization.
       */
      Suppliers?: ProductAvailabilityResult.ProductAvailabilityDetails[];
      /**
       * The stock that is reserved for other organizations that is not available to this organization.
       */
      StockReservations?: ProductAvailabilityDetails.StockReservation[];
      /**
       * The stock that is expected to be received in the future.
       */
      ExpectedStock?: ProductAvailabilityDetails.ExpectedStockItem[];
      /**
       * Details of the individual stock products.
       */
      StockProducts?: ProductAvailabilityDetails.StockProduct[];
    }

    export namespace ProductAvailabilityDetails {
      export interface StockProduct {
        /**
         * The ID of the stock product.
         * Entity type: Product
         */
        ProductID: number;
        /**
         * The quantity of stock that the OrganizationUnit physically has.
         */
        QuantityOnHand: number;
        /**
         * The quantity that has been committed to this OrganizationUnit.
         */
        QuantityCommitted: number;
        /**
         * The quantity of stock that is still available for the OrganizationUnit, so the amount of physical stock minus its commitments.
         */
        QuantityAvailable: number;
        /**
         * The quantity committed on all suppliers of this organization
         */
        SupplierQuantityCommitted: number;
        /**
         * The quantity that all suppliers have on hand as far as we know from the perspective of the organization that is supplied by them.
         * 
         * The actual supplier might have more stock physically on hand, but due to allocation rules this might not be available to this organization.
         */
        SupplierQuantityOnHand: number;
        /**
         * The SupplierQuantityOnHand minus the SupplierQuantityCommitted
         */
        SupplierQuantityAvailable: number;
      }

      export interface StockReservation {
        /**
         * The organization unit for which the stock is reserved.
         */
        ReservedForOrganizationUnit: ProductAvailabilityDetails.OrganizationUnitModel;
        /**
         * The quantity that is reserved, so this is the quantity that is not available to our organization
         */
        Quantity: number;
      }

      export interface ExpectedStockItem {
        /**
         * The OrderID that the expected stock is expected to be received on.
         * Entity type: Order
         */
        OrderID: number;
        /**
         * The date on which the stock is expected to be received.
         */
        ExpectedOnStockDate: string;
        /**
         * The quantity that is expected to be received.
         */
        Quantity: number;
        /**
         * How much of this expected stock is already spoken for by orders.
         */
        QuantityCommitted: number;
      }

      export interface OrganizationUnitModel {
        /**
         * Entity type: OrganizationUnit
         */
        ID: number;
        Name: string;
        Description: string;
        BackendID: string;
        Type: OrganizationUnitTypes;
      }

    }

    export interface ProductStockReplacementInformation {
      StockReplacementProducts: ProductStockReplacementInformation.StockReplacementProduct[];
    }

    export namespace ProductStockReplacementInformation {
      export interface StockReplacementProduct {
        /**
         * Entity type: Product
         */
        ProductID: number;
      }

    }

    export interface ProductStockAggregateInformation {
      StockReplacementProducts: ProductStockAggregateInformation.StockProduct[];
    }

    export namespace ProductStockAggregateInformation {
      export interface StockProduct {
        /**
         * Entity type: Product
         */
        ProductID: number;
      }

    }

    export interface ProductAvailabilityResultBundleInformation {
      Lines: ProductAvailabilityResultBundleInformation.ProductBundleLine[];
    }

    export namespace ProductAvailabilityResultBundleInformation {
      export interface ProductBundleLine {
        /**
         * Entity type: ProductBundleLine
         */
        ID: number;
        Type: ProductBundleLineTypes;
        /**
         * Entity type: Product
         */
        DefaultProductID?: number;
        /**
         * Entity type: Product
         */
        OptionProductIDs: number[];
        Description: string;
        MaxSelectedOptionsCount?: number;
      }

    }

    export interface PickupAvailabilityResult {
      AvailabilityDate?: string;
      IsAvailable: boolean;
      QuantityAvailable?: number;
      /**
       * Indicates whether or not there is currently stock available for pick-up.
       */
      HasStock: boolean;
      EstimatedPickupTime?: string;
    }

    export interface DeliveryAvailabilityResult {
      AvailabilityDate?: string;
      IsAvailable: boolean;
      QuantityAvailable?: number;
      /**
       * Indicates whether or not there is currently stock available for home-delivery.
       */
      HasStock: boolean;
    }

    export interface CarryOutAvailabilityResult {
      IsAvailable: boolean;
      QuantityAvailable?: number;
      /**
       * Indicates whether or not there is currently stock available for pick-up.
       */
      HasStock: boolean;
    }

  }

  export const enum ProductStatus {
    None = 0,
    PreRelease = 1,
    DeliveryOnly = 4,
    DisableDelivery = 8,
    DisablePickup = 16,
    DisableBackorder = 32,
    UseUp = 34,
    NonSellable = 64
  }

  export const enum ProductBundleLineTypes {
    Required = 0,
    Optional = 1,
    OptionalIncludedInPrice = 2
  }

  export interface ProductAvailabilityPickupOrganizationUnit {
    /**
     * HasStock will be true if the OrganizationUnit has stock for *all* requested products.
     */
    HasStock: boolean;
    Products: ProductAvailabilityPickupOrganizationUnit.PickupOrganizationProductQuantity[];
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
    BackendID: string;
    Name: string;
    Description: string;
    Type: OrganizationUnitTypes;
    IsPickup: boolean;
    Status: OrganizationUnitStatus;
    Address: AddressDto;
    Latitude?: number;
    Longitude?: number;
    EmailAddress: string;
    PhoneNumber: string;
    TimeZone: string;
    DistanceInKm?: number;
    OpeningHours: OpeningHoursInfo[];
  }

  export namespace ProductAvailabilityPickupOrganizationUnit {
    export interface PickupOrganizationProductQuantity {
      /**
       * Entity type: Product
       */
      ProductID: number;
      QuantityAvailable: number;
      AvailabilityDate?: string;
    }

  }

  export interface OpeningHoursInfo {
    DayOfWeek: DayOfWeek;
    OpeningTime?: string;
    ClosingTime?: string;
    Date?: string;
    Closed: boolean;
  }

  export const enum DayOfWeek {
    Sunday = 0,
    Monday = 1,
    Tuesday = 2,
    Wednesday = 3,
    Thursday = 4,
    Friday = 5,
    Saturday = 6
  }

  export interface ProductAvailabilityCarryOutOrganizationUnit {
    /**
     * HasStock will be true if the OrganizationUnit has stock for *all* requested products.
     */
    HasStock: boolean;
    Products: ProductAvailabilityCarryOutOrganizationUnit.CarryOutOrganizationProductQuantity[];
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
    BackendID: string;
    Name: string;
    Description: string;
    Type: OrganizationUnitTypes;
    IsPickup: boolean;
    Status: OrganizationUnitStatus;
    Address: AddressDto;
    Latitude?: number;
    Longitude?: number;
    EmailAddress: string;
    PhoneNumber: string;
    TimeZone: string;
    DistanceInKm?: number;
    OpeningHours: OpeningHoursInfo[];
  }

  export namespace ProductAvailabilityCarryOutOrganizationUnit {
    export interface CarryOutOrganizationProductQuantity {
      /**
       * Entity type: Product
       */
      ProductID: number;
      QuantityAvailable: number;
    }

  }

  /**
   * Calculates the run-rates for the provided products for the provided warehouse OrganizationUnit, based on a date (`Since`).
   * 
   * The run-rates are returned per SoldFromOrganizationUnit.
   */
  export interface GetProductRunRates {
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    /**
     * Entity type: OrganizationUnit
     */
    WarehouseOrganizationUnitID: number;
    Since: string;
  }

  export interface GetProductRunRatesResponse {
    TotalQuantity: number;
    DailyRunRate: number;
    MonthlyRunRate: number;
    RunRates: GetProductRunRatesResponse.RunRate[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetProductRunRatesResponse {
    export interface RunRate {
      ProductID: number;
      TotalQuantity: number;
      DailyRunRate: number;
      MonthlyRunRate: number;
      SoldFromOrganizationUnitID: number;
      SoldFromOrganizationUnitName: string;
    }

  }

  /**
   * Calculate and return the current `QuantityOnHand` for supplied `ProductID`s on given organization unit.
   * 
   * Returns a dictionary with `ProductID` as key, and the `QuantityOnHand` as value.
   */
  export interface GetQuantityOnHandForProducts {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
  }

  export interface GetQuantityOnHandForProductsResponse {
    Result: { [key: number]: number };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Calculates the stock availability for the provided OrderLines that are part of the provided Order.
   * 
   * The return value of this service is a list that contains, per OrderLine, whether or not it can be fulfilled (`CanBeFulfilled`) on the `RequestedDate`.
   * 
   * When an OrderLine doesn't already have a RequestedDate, a RequestedDate of tomorrow is used.
   * 
   * Additionally, a list of AlternativeDates is returned per OrderLine with dates on which it is expected that the OrderLine can be fulfilled.
   * 
   * When OrderLineIDs is left empty, this service will return an estimate for all unshipped lines of the order.
   * 
   * Doesn't work for orders with more than 25 lines.
   */
  export interface GetStockAvailabilityEstimateForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    OrderLines?: GetStockAvailabilityEstimateForOrder.OrderLine[];
  }

  export namespace GetStockAvailabilityEstimateForOrder {
    export interface OrderLine {
      /**
       * Entity type: OrderLine
       */
      ID: number;
      RequestedDate?: string;
    }

  }

  export interface GetStockAvailabilityEstimateForOrderResponse {
    OrderLines: GetStockAvailabilityEstimateForOrderResponse.OrderLine[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetStockAvailabilityEstimateForOrderResponse {
    export interface OrderLine {
      OrderLineID: number;
      ProductID: number;
      RequestedDate: string;
      QuantityAvailable?: number;
      IsCommitted: boolean;
      ShipmentDate?: string;
      CanBeFulfilled: boolean;
      AlternativeDates: GetStockAvailabilityEstimateForOrderResponse.SuggestedAlternativeDate[];
      ExpectedFulfillmentDate?: string;
      AvailabilityStatus: OrderLineAvailabilityStatus;
      CommitmentDate?: string;
      ExportDate?: string;
      MadeToOrderStatus: GetStockAvailabilityEstimateForOrderResponse.OrderLineMadeToOrderStatus;
      DependsOnPurchaseOrderLines: GetStockAvailabilityEstimateForOrderResponse.DependsOnPurchaseOrderLine[];
      ShouldBeSplit: boolean;
      ExportStatus: OrderExportStatuses;
      CommitmentStatus: OrderLineCommitmentStatus;
      IsBlocked: boolean;
    }

    export interface DependsOnPurchaseOrderLine {
      ID: number;
      BackendID: string;
      ProductID: number;
      OrderID: number;
      QuantityToShip: number;
      QuantityShipped: number;
      QuantityDelivered: number;
      RequestedDate: string;
      CreationTime: string;
    }

    export interface OrderLineMadeToOrderStatus {
      PurchaseOrderLine: OrderLineMadeToOrderStatus.MadeToOrderPurchaseOrderLine;
      HasBeenRequested: boolean;
      HasBeenCompleted: boolean;
    }

    export namespace OrderLineMadeToOrderStatus {
      export interface MadeToOrderPurchaseOrderLine {
        ID: number;
        OrderID: number;
        RequestedDate?: string;
        IsOverdue: boolean;
        BackendID: string;
        QuantityToShip: number;
        QuantityShipped: number;
        QuantityDelivered: number;
        IsConfirmed: boolean;
        ShipFromOrganizationUnit: OrderLineMadeToOrderStatus.MadeToOrderShipFromOrganizationUnit;
      }

      export interface MadeToOrderShipFromOrganizationUnit {
        ID: number;
        Name: string;
      }

    }

    export interface PurchaseOrderLine {
      ID: number;
      OrderID: number;
      RequestedDate: string;
      Quantity: number;
    }

    export interface SuggestedAlternativeDate {
      Date: string;
      QuantityAvailable?: number;
      PurchaseOrderLines: GetStockAvailabilityEstimateForOrderResponse.PurchaseOrderLine[];
    }

  }

  export const enum OrderLineAvailabilityStatus {
    Unknown = 0,
    Blocked = 5,
    CannotFulfill = 10,
    CannotFulfillOnTime = 12,
    CanFulfill = 15
  }

  export const enum OrderExportStatuses {
    NotExported = 0,
    ShouldBeExported = 1,
    Exporting = 2,
    Exported = 3,
    WillNotBeExported = 4
  }

  /**
   * Given a set of products this service returns a detailed estimate for each product when it's expected to be available.
   */
  export interface GetStockAvailabilityEstimateForProducts {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    Products: GetStockAvailabilityEstimateForProducts.Product[];
    /**
     * No longer supported.
     */
    IncludeReservedOrders?: boolean;
    /**
     * If set to true the service will also return purchase OrderLines meant for shops
     */
    IncludeShopReplenishments?: boolean;
  }

  export namespace GetStockAvailabilityEstimateForProducts {
    export interface Product {
      /**
       * Entity type: Product
       */
      ID: number;
      RequestedDate?: string;
    }

  }

  export interface GetStockAvailabilityEstimateForProductsResponse {
    Products: GetStockAvailabilityEstimateForProductsResponse.Product[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetStockAvailabilityEstimateForProductsResponse {
    export interface Product {
      ID: number;
      AvailabilityDates: GetStockAvailabilityEstimateForProductsResponse.AvailabilityDate[];
      WarehouseQuantityOnHand: number;
      WarehouseQuantityCommitted: number;
      WarehouseQuantityAvailable: number;
      QuantityToShipOnOrder: number;
      SalesOrderLines: GetStockAvailabilityEstimateForProductsResponse.SalesOrderLine[];
      PurchaseOrderLines: GetStockAvailabilityEstimateForProductsResponse.PurchaseOrderLine[];
      ShopReplenishments: GetStockAvailabilityEstimateForProductsResponse.ShopReplenishment[];
      WarehouseStock: GetStockAvailabilityEstimateForProductsResponse.WarehouseStock[];
      /**
       * No longer supported.
       */
      ReservedOrderLines: GetStockAvailabilityEstimateForProductsResponse.ReservedOrderLine[];
    }

    export interface AvailabilityDate {
      Date: string;
      QuantityAvailable?: number;
      PurchaseOrderLines: GetStockAvailabilityEstimateForProductsResponse.PurchaseOrderLine[];
    }

    export interface PurchaseOrderLine {
      ID: number;
      OrderID: number;
      RequestedDate: string;
      Quantity: number;
      IsOverdue: boolean;
      QuantityAvailable: number;
      IsConfirmed: boolean;
    }

    export interface SalesOrderLine {
      OrderLineID: number;
      OrderID: number;
      Quantity: number;
      ExportStatus: OrderExportStatuses;
      CommitmentStatus: OrderLineCommitmentStatus;
      CommitmentDate?: string;
      FulfillmentStatus: OrderLineAvailabilityStatus;
      ExportDate?: string;
      RequestedDate: string;
      OrderType: OrderTypes;
    }

    export interface ShopReplenishment {
      OrderLineID: number;
      OrderID: number;
      Quantity: number;
      RequestedDate: string;
      IsConfirmed: boolean;
    }

    export interface ReservedOrderLine {
      OrderLineID: number;
      OrderID: number;
      QuantityReserved: number;
      ShopName: string;
    }

    export interface WarehouseStock {
      StockLabel: EnumDto;
      QuantityOnHand: number;
      WarehouseID: number;
      WarehouseName: string;
    }

  }

  export const enum OrderTypes {
    Sales = 0,
    Purchase = 1
  }

  /**
   * Returns the expected availability timeline for the provided `ProductIDs`, from the perspective of the provided `OrganizationUnitID` (optional, defaults to the user's current OrganizationUnitID).
   * 
   * The timeline is ordered chronologically and includes all events that are relevant to the availability of the requested products, including events that happen on the suppliers of the requested OrganizationUnit (such as PurchaseOrder receipts).
   * 
   * Additionally, a `FromDate` (inclusive) and `ToDate` (exclusive) can be used to filter the response by date and a `Type` can be provided to only return timeline items of a certain type.
   */
  export interface GetStockAvailabilityTimeline {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    FromDate?: string;
    ToDate?: string;
    Type?: AvailabilityTimelineItemTypes;
  }

  export const enum AvailabilityTimelineItemTypes {
    CurrentAvailability = 0,
    ExpectedCommitment = 1,
    ExpectedReplenishment = 2,
    ExpectedShipment = 3
  }

  export interface GetStockAvailabilityTimelineResponse {
    TimelineItems: GetStockAvailabilityTimelineResponse.TimelineItem[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetStockAvailabilityTimelineResponse {
    export interface TimelineItem {
      OrganizationUnitID: number;
      OrganizationUnitName: string;
      Type: AvailabilityTimelineItemTypes;
      Date: string;
      OrderID?: number;
      OrderLineID?: number;
      ProductID: number;
      DeltaQuantityOnHand: number;
      DeltaQuantityCommitted: number;
      CumulativeSumQuantityCommitted: number;
      CumulativeSumQuantityOnHand: number;
      CumulativeSumQuantityAvailable: number;
      RequestedDate?: string;
      OrderBackendID: string;
    }

  }

  /**
   * Requests the stock per stock label, per product for the given organization unit. If there is no stock at all for a product the product is not
   * returned in the response.
   */
  export interface GetStockByStockLabelForProducts {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    /**
     * Entity type: StockLabel
     */
    StockLabelIDs: number[];
  }

  export interface GetStockByStockLabelForProductsResponse {
    /**
     * Entity type: Product
     */
    Stock: { [key: number]: GetStockByStockLabelForProductsResponse.StockLabelStock[] };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetStockByStockLabelForProductsResponse {
    export interface StockLabelStock {
      /**
       * Entity type: StockLabel
       */
      StockLabelID: number;
      QuantityOnHand: number;
    }

  }

  /**
   * Get Stock Details For Product
   */
  export interface GetStockDetailsForProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: OrganizationUnit
     */
    ShowWarehousesForOrganizationUnitID?: number;
  }

  export interface GetStockDetailsForProductResponse {
    PromisedDeliveryDate?: string;
    PromisedDeliveryStatus: ProductPromisedDeliveryStatuses;
    QuantityOnHand: number;
    SellableQuantityAvailable: number;
    /**
     * Entity type: StockLabel
     */
    StockPerLabel: { [key: number]: number };
    SellableStockInStoresWithinApplication: number;
    SellableStockInWarehouses: OrganizationUnitWithStock[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum ProductPromisedDeliveryStatuses {
    Unknown = 0,
    KnownUnSure = 1,
    KnownQuiteSure = 2,
    KnownSure = 3,
    OnDay = 4,
    Stock = 5
  }

  export interface OrganizationUnitWithStock {
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
    Name: string;
    SellableStock: number;
  }

  /**
   * This service lists the OrderLines for the given ProductID that currently have committed Stock.
   */
  export interface ListCommittedOrderLines {
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListCommittedOrderLinesResponse {
    Result?: PagedResult<CommittedOrderLine>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface CommittedOrderLine {
    /**
     * Entity type: OrderLine
     */
    ID: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrganizationUnit
     */
    SoldFromOrganizationUnitID: number;
    SoldFromOrganizationUnitName: string;
    Description: string;
    TotalQuantityToShip: number;
    CommitmentStatus: OrderLineCommitmentStatus;
    QuantityCommitted: number;
    RequestedDate?: string;
    CreationTime: string;
  }

  /**
   * The page size `Limit` has a maximum value of `1.000` for this service.
   */
  export interface ListStockMutations {
    PageConfig?: PageConfig<ListStockMutationsFilter>;
  }

  export interface ListStockMutationsFilter {
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    CreationTime?: string;
    /**
     * Entity type: StockLabel
     */
    SourceStockLabelID?: number;
    /**
     * Entity type: StockLabel
     */
    DestinationStockLabelID?: number;
    /**
     * Entity type: StockMutationReasons
     */
    ReasonID?: number;
    StartDateTime?: string;
    EndDateTime?: string;
    MutationQuantity?: number;
  }

  export interface ListStockMutationsResponse {
    FullStockCountInProgress: boolean;
    FullStockCountIsExternal: boolean;
    Result: PagedResult<StockMutationDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface StockMutationDto {
    /**
     * Entity type: StockMutation
     */
    ID: number;
    CreationTime: string;
    OrganizationUnit: OrganizationUnitDto;
    /**
     * Entity type: StockLabel
     */
    SourceStockLabelID: number;
    /**
     * Entity type: StockLabel
     */
    SourceStockLabel: number;
    /**
     * Entity type: StockLabel
     */
    DestinationStockLabelID: number;
    /**
     * Entity type: StockLabel
     */
    DestinationStockLabel: number;
    /**
     * Entity type: StockMutationReasons
     */
    ReasonID: number;
    Reason: EnumDto;
    /**
     * Entity type: Product
     */
    ProductID: number;
    Product: ProductDto;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    OrderLine: OrderLineDto;
    MutationQuantity: number;
    Remark: string;
    UnitCost: number;
    AutomaticCorrectionQuantity: number;
    SerialNumber?: string;
    SerialNumberID?: number;
  }

  export interface OrganizationUnitDto {
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
    BackendID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    ParentID?: number;
    Name: string;
    Description?: string;
    /**
     * Entity type: Company
     */
    CompanyID?: number;
    /**
     * Entity type: Address
     */
    AddressID?: number;
    Address?: AddressDto;
    EmailAddress?: string;
    PhoneNumber?: string;
    Type: OrganizationUnitTypes;
    Status: OrganizationUnitStatus;
    OpeningHours: OpeningHoursDto[];
    ExtendedOpeningHours: ExtendedOpeningHours[];
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    Latitude?: number;
    Longitude?: number;
    /**
     * Entity type: Country
     */
    CountryID: string;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * Entity type: Currency
     */
    CostPriceCurrencyID: string;
    Subnet?: string;
    Website?: string;
    BIC?: string;
    EstablishmentNumber?: string;
  }

  export interface OpeningHoursDto {
    /**
     * Entity type: OpeningHours
     */
    ID: number;
    /**
     * Entity type: OpeningHoursType
     */
    TypeID?: number;
    TypeName?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Only set when returned outside OrganizationUnit context
     */
    OrganizationUnitName?: string;
    DayOfWeek?: DayOfWeek;
    StartTime?: string;
    EndTime?: string;
    Date?: string;
    Description?: string;
    IsSpecial?: boolean;
    IsClosed?: boolean;
    IsActive?: boolean;
  }

  export interface ExtendedOpeningHours {
    /**
     * Entity type: OpeningHoursType
     */
    TypeID: number;
    TypeName: string;
    TypeBackendID?: string;
    Sunday: DayOpeningHours;
    Monday: DayOpeningHours;
    Tuesday: DayOpeningHours;
    Wednesday: DayOpeningHours;
    Thursday: DayOpeningHours;
    Friday: DayOpeningHours;
    Saturday: DayOpeningHours;
    SpecialOpeningHours: SpecialOpeningHours[];
  }

  export interface DayOpeningHours {
    Description?: string;
    IsClosed: boolean;
    TimeSlots?: TimeSlot[];
  }

  export interface TimeSlot {
    StartTime: string;
    EndTime: string;
  }

  export interface SpecialOpeningHours {
    Date: string;
    Description?: string;
    IsClosed: boolean;
    TimeSlots?: TimeSlot[];
  }

  export interface ProductDto {
    /**
     * Entity type: Product
     */
    ID: number;
    BackendID: string;
    CustomID: string;
    BrandID?: number;
    BrandName: string;
    PrimitiveName: string;
    Type: ProductTypes;
    CatalogID?: number;
    LedgerClassID: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    StockAggregateProductID?: number;
    Properties: any;
  }

  export const enum ProductTypes {
    None = 0,
    Stock = 1,
    Insurance = 2,
    Marketing = 4,
    GiftCard = 8,
    Service = 16,
    GreetingCard = 32,
    CustomPricing = 64,
    External = 128,
    OrderCosts = 256,
    SystemGenerated = 512,
    ProductSet = 1024,
    BundleProduct = 2048,
    VirtualProduct = 4096,
    MadeToOrder = 8192,
    Configurable = 16384,
    SupplierProduct = 32768,
    Template = 65536,
    SecondChance = 131072,
    NotReturnable = 262144,
    StockAggregate = 524289,
    SubscriptionProduct = 1048576
  }

  export interface OrderLineDto {
    /**
     * Entity type: OrderLine
     */
    ID: number;
    BackendReference: string;
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderLine
     */
    ParentID?: number;
    Children?: OrderLineDto[];
    Type: OrderLineTypes;
    /**
     * Entity type: StockLabel
     */
    StockLabel: number;
    Description: string;
    AdditionalDescription: string;
    /**
     * This is the quantity that was ordered. Make sure you really need this property, the total of the line is TotalQuantityToShip.
     */
    QuantityOrdered: number;
    QuantityOpen: number;
    QuantityCommitted: number;
    CommitmentStatus: OrderLineCommitmentStatus;
    QuantityShipped: number;
    QuantityDelivered: number;
    QuantityReserved: number;
    QuantityBackordered: number;
    QuantityReturned: number;
    QuantityCancelled: number;
    QuantityInvoiced: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    Product?: ProductDto;
    StockProduct?: ProductDto;
    UnitPrice: number;
    UnitPriceBeforeCorrection?: number;
    UnitPriceBeforeCorrectionInTax?: number;
    UnitPriceCorrectionReason?: EnumDto;
    TaxRate: number;
    TaxCode: EnumDto;
    ShowTaxInfo: boolean;
    SerialNumber?: string;
    UnitPriceInTax: number;
    IsCancelled: boolean;
    TotalQuantityToShip: number;
    TotalAmountInTax: number;
    TotalAmount: number;
    NetTotalAmountInTax: number;
    NetTotalAmount: number;
    TotalTaxAmount: number;
    NetTotalTaxAmount: number;
    OriginalTotalAmountInTax?: number;
    OriginalTotalAmount?: number;
    EcoTaxInTax?: number;
    TotalEcoTaxInTax?: number;
    DisplayPriceInTax?: number;
    DisplayPrice?: number;
    ModificationAllowed: boolean;
    Remark: string;
    Reference: string;
    LineActionType: LineActionTypes;
    /**
     * Entity type: Order
     */
    ReturnedOrderID?: number;
    /**
     * Entity type: OrderLine
     */
    ReturnedOrderLineID?: number;
    ExportStatus: OrderExportStatuses;
    ContractNumber: string;
    IsCompleted: boolean;
    IsShipped: boolean;
    IsInvoiced: boolean;
    ExpectedAvailabilityDate?: string;
    RequestedDate?: string;
    CreationTime: string;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    LastModificationTime?: string;
    IsDigitalGiftCard: boolean;
    /**
     * Entity type: Discount
     */
    DiscountID?: number;
    DiscountBackendID: string;
    DiscountCouponCode: string;
    DiscountCampaignName: string;
    DiscountAmount: number;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    ShippingMethod?: ShippingMethodDto;
    ExternalModificationStatus: ExternalModificationStatuses;
    CustomOrderLineType: string;
    /**
     * Entity type: OrderLine
     */
    RelatedOrderLineID?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    ProductVariation: { [key: string]: string };
    /**
     * Entity type: ProductBundleLine
     */
    ProductBundleLineID?: number;
    TaxExemptionCode: string;
    TaxExemptionReason: string;
    TaxExemptionVerification: string;
    FulfillmentStatus: OrderLineFulfillmentStatuses;
    AvailabilityStatus?: OrderLineAvailabilityStatus;
    ReturnReason?: EnumWithBackendIDDto;
    RefundCorrectionReason?: RefundCorrectionReasonDto;
    /**
     * Entity type: User
     */
    SoldByID?: number;
    /**
     * Properties that should be used for display in the frontends to keep a matching experience in all apps.
     */
    DisplayProperties: OrderLineDisplayProperties;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    /**
     * Entity type: PriceList
     */
    UnitPricePriceListID?: number;
    Discounts: OrderLineDiscount[];
    LoyaltyWithdrawals?: OrderLineLoyaltyMutation[];
    LoyaltyDeposits?: OrderLineLoyaltyMutation[];
    GroupID?: string;
    ImageBlobID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    FulfillmentOrganizationUnitID?: number;
    FulfillmentOrganizationUnitName?: string;
    FulfillmentOrganizationUnitBackendID?: string;
    IsPricedByLoyaltyProgram?: boolean;
    IsLimitedByLoyaltyProgram?: boolean;
    PreSaleDate?: string;
    ProductSubscription?: ProductSubscriptionDto;
    /**
     * Entity type: Product
     */
    StockProductID?: number;
  }

  export const enum OrderLineTypes {
    NormalProduct = 0,
    Discount = 1,
    ExtraCosts = 2,
    ShippingCosts = 5,
    ReturnCosts = 6,
    PriceCorrection = 7,
    Service = 8,
    GiftWrappingCosts = 9,
    DownPayment = 10
  }

  export const enum LineActionTypes {
    None = 0,
    ReserveLine = 1,
    OrderLine = 2,
    ShipLine = 3,
    Delivery = 4
  }

  export interface ShippingMethodDto {
    /**
     * Entity type: ShippingMethod
     */
    ID: number;
    /**
     * Entity type: Carrier
     */
    CarrierID: number;
    Carrier: CarrierDto;
    Name: string;
    Description: string;
    Code: string;
    Priority: number;
    PaymentHandledByCarrier: boolean;
    DeliveryType: ShippingMethodDeliveryTypes;
    CustomFieldValues: { [key: number]: CustomFieldValue };
  }

  export interface CarrierDto {
    /**
     * Entity type: Carrier
     */
    ID: number;
    Name: string;
    Code: string;
  }

  export const enum ShippingMethodDeliveryTypes {
    None = 0,
    Default = 1,
    ShipFromStore = 2,
    Interbranch = 4
  }

  export const enum ExternalModificationStatuses {
    None = 0,
    CancellationRequested = 1,
    QuantityChangeRequested = 2,
    CancellationRequestDenied = 4,
    CancellationRequestApproved = 8,
    QuantityChangeRequestDenied = 16,
    QuantityChangeRequestApproved = 32
  }

  export const enum OrderLineFulfillmentStatuses {
    None = 0,
    WaitingForStock = 300,
    Pending = 400,
    InProgress = 500,
    Cancelled = 800,
    Completed = 1000
  }

  export interface EnumWithBackendIDDto {
    BackendID: string;
    /**
     * Entity type: Enum
     */
    ID: number;
    /**
     * Usually an internal & unchangable code - for display, use `Description`
     */
    Name: string;
    Description: string;
  }

  export interface RefundCorrectionReasonDto {
    /**
     * Entity type: RefundCorrectionReason
     */
    ID?: number;
    BackendID?: string;
    Name?: string;
    Description?: string;
  }

  export interface OrderLineDisplayProperties {
    TotalAmountInTax?: number;
    TotalAmount?: number;
    OriginalAmountInTax?: number;
    OriginalAmount?: number;
    UnitPriceInTax?: number;
    UnitPrice?: number;
    OriginalUnitPrice?: number;
    OriginalUnitPriceInTax?: number;
    IsFree?: boolean;
    EcoTaxInTax?: number;
    TotalEcoTaxInTax?: number;
    PriceListDiscountPercentage?: number;
  }

  export interface OrderLineDiscount {
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    DiscountAmount: number;
    Description: string;
    PromotionLabel: string;
  }

  export interface OrderLineLoyaltyMutation {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    BackendID: string;
    Name: string;
    Points: number;
    /**
     * Entity type: Discount
     */
    DiscountID?: number;
    /**
     * Entity type: PointAwardingRule
     */
    PointAwardingRuleID?: number;
  }

  export const enum OrderLineHoldStatus {
    None = 0,
    SerialNumberValidationRequired = 1
  }

  export interface ProductSubscriptionDto {
    /**
     * Entity type: ProductSubscription
     */
    ID: number;
    BackendID?: string;
    Name: string;
  }

  /**
   * Returns a paginated list of all stock, optionally filtered.
   */
  export interface ListStock {
    InitialPageConfig?: PageTokenConfig<ListStockFilter>;
    PageToken?: string;
  }

  export interface ListStockFilter {
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: StockLabel
     */
    StockLabelIDs?: number[];
  }

  export interface ListStockResponse {
    Results?: ListStockResponse.ListStockItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListStockResponse {
    export interface ListStockItem {
      Product: ListStockItem.ProductInfo;
      OrganizationUnit: ListStockItem.OrganizationUnitInfo;
      StockLabel: EnumDto;
      QuantityOnHand: number;
      QuantityCommitted: number;
    }

    export namespace ListStockItem {
      export interface ProductInfo {
        /**
         * Entity type: Product
         */
        ID?: number;
        BackendID?: string;
        CustomID?: string;
      }

      export interface OrganizationUnitInfo {
        /**
         * Entity type: OrganizationUnit
         */
        ID: number;
        BackendID?: string;
        Name: string;
        Type: OrganizationUnitTypes;
      }

    }

  }

  /**
   * Books a set of Movements.
   * 
   * A Movement should have a `ProductID` to identify the product, an `OrganizationUnitID` to identify the stock keeping
   * organization, a `SourceStockLabelID` and `DestinationStockLabelID` (see `GetEnumValues` with type `StockLabel`) and (of course) a `Quantity`
   * to actually book.
   * 
   * Supply a `BackendSystemID` on the request and `BackendID`'s on the Movements to make the request idempotent.
   * 
   * Optionally supports a `StockMutationReasonID` and `Remark` for each Movement.
   */
  export interface MoveStock {
    BackendSystemID?: string;
    Movements?: MoveStock.Movement[];
  }

  export namespace MoveStock {
    export interface Movement {
      BackendID?: string;
      /**
       * Entity type: Product
       */
      ProductID?: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      /**
       * Entity type: StockLabel
       */
      SourceStockLabelID: number;
      /**
       * Entity type: StockLabel
       */
      DestinationStockLabelID: number;
      /**
       * Entity type: StockMutationReasons
       */
      StockMutationReasonID?: number;
      Quantity: number;
      Remark?: string;
      ProductBackendID?: string;
      SerialNumber?: string;
      /**
       * Entity type: Product
       */
      DestinationProductID?: number;
    }

  }

  /**
   * Processes a (delta)stock mutation file.
   * 
   * Expected format of the file is JSON with the following markup:
   * 
   * ```
   * [
   *   {
   *     "ProductID": [Optional, int],
   *     "ProductBackendID": [Optional, string],
   *     "QuantityOnHand": [Required, int, value >= 0],
   *     "StockMutationReasonID": [Optional, int],
   *     "Remark": [Optional, string]
   *   },
   *   ...
   * ]
   * ```
   * 
   * Mutation will only be processed for valid ProductIDs or ProductBackendIDs. In case ProductID and ProductBackendID are provided,
   * ProductBackendID will be selected as the search parameter.
   */
  export interface ProcessStockMutationFile {
    FileBlobID: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    /**
     * Entity type: StockMutationReasons
     */
    StockMutationReasonID?: number;
    /**
     * The `BackendSystemID` that belongs to the `ProductBackendID`s
     */
    BackendSystemID?: string;
    /**
     * If set to false (default), only the stock for the products that are present in the file will be updated (delta).
     * 
     * If set to true, all the products will be updated - products not present in the file will be updated to quantity 0.
     * @default false
     */
    IsFullStockMutationFile?: boolean;
    /**
     * An email address to mail the processing result to. When left empty, the logged in user context will be used
     */
    EmailAddress?: string;
  }

  /**
   * Download a template format for the stock file to upload.
   */
  export interface DownloadStockExcelFileTemplate {
  }

  /**
   * Upload stock Excel (delta)file. The service processes the data async. This service is intended for small files (up to 5MB). Please view the documentation for processing larger files.
   */
  export interface UploadAndProcessStockExcelFile {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    /**
     * Entity type: StockMutationReasons
     */
    StockMutationReasonID?: number;
    /**
     * If set to false (default), only the stock for the products that are present in the file will be updated (delta).
     * 
     * If set to true, all the products will be updated - products not present in the file will be updated to quantity 0.
     * @default false
     */
    IsFullStockMutationFile?: boolean;
    Data: string;
    /**
     * The `BackendSystemID` that belongs to the `ProductBackendID`s
     */
    BackendSystemID?: string;
    /**
     * An email address to mail the processing result to. When left empty, the logged in user context will be used
     */
    EmailAddress?: string;
  }

  /**
   * Upload stock JSON (delta)file. The service processes the data async.This service is intended for small files (up to 5MB). Please view the documentation for processing larger files.
   */
  export interface UploadAndProcessStockJSONFile {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    /**
     * Entity type: StockMutationReasons
     */
    StockMutationReasonID?: number;
    /**
     * If set to false (default), only the stock for the products that are present in the file will be updated (delta).
     * 
     * If set to true, all the products will be updated - products not present in the file will be updated to quantity 0.
     * @default false
     */
    IsFullStockMutationFile?: boolean;
    /**
     * Should be a JSON formatted array of object with these 3 properties;
     * 
     * - `ProductID` (optional, int)
     * - `ProductBackendID` (optional, string)
     * - `QuantityOnHand` (required, int, value >= 0)
     * - `StockMutationReasonID` (optional, int)
     * - `Remark` (optional, string)
     * 
     * Mutation will only be processed for valid ProductID's or ProductBackendID's. In case ProductID and ProductBackendID are provided,
     * ProductBackendID will be selected as the search parameter.
     */
    Data: string;
    /**
     * The `BackendSystemID` that belongs to the `ProductBackendID`s
     */
    BackendSystemID?: string;
    /**
     * An email address to mail the processing result to. When left empty, the logged in user context will be used
     */
    EmailAddress?: string;
  }

  /**
   * Get stock labels
   */
  export interface GetStockLabels {
  }

  export interface GetStockLabelsResponse {
    StockLabels: GetStockLabelsResponse.StockLabelDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetStockLabelsResponse {
    export interface StockLabelDto {
      /**
       * Entity type: StockLabel
       */
      ID: number;
      Name: string;
      DisplayName: string;
      Description: string;
    }

  }

  /**
   * Returns all stocklabels with the configured setting for a single organizationunit.
   */
  export interface GetStockLabelsForFeature {
    Feature: StockLabelFeature;
    /**
     * Optional organizationunit to filter by. If not set, the stocklabels for the current organizationunit will be returned.
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export const enum StockLabelFeature {
    Sellable = 0,
    Movable = 1,
    Adjustable = 2,
    Returnable = 3,
    CycleCountable = 4,
    FullStockCountable = 5,
    ReturnToSupplierable = 6
  }

  export interface GetStockLabelsForFeatureResponse {
    StockLabels: GetStockLabelsForFeatureResponse.StockLabelDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetStockLabelsForFeatureResponse {
    export interface StockLabelDto {
      /**
       * Entity type: StockLabel
       */
      ID: number;
      Name: string;
      DisplayName: string;
      Description: string;
      IsDefault: boolean;
    }

  }

  /**
   * Returns all stocklabels with the configured setting for a single organizationunit.
   */
  export interface GetStockLabelsForFeatures {
    /**
     * Optional organizationunit to filter by. If not set, the stocklabels for the current organizationunit will be returned.
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export interface GetStockLabelsForFeaturesResponse {
    Sellable: GetStockLabelsForFeaturesResponse.StockLabelDto[];
    Movable: GetStockLabelsForFeaturesResponse.StockLabelDto[];
    Adjustable: GetStockLabelsForFeaturesResponse.StockLabelDto[];
    Returnable: GetStockLabelsForFeaturesResponse.StockLabelDto[];
    CycleCountable: GetStockLabelsForFeaturesResponse.StockLabelDto[];
    FullStockCountable: GetStockLabelsForFeaturesResponse.StockLabelDto[];
    ReturnToSupplierable: GetStockLabelsForFeaturesResponse.StockLabelDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetStockLabelsForFeaturesResponse {
    export interface StockLabelDto {
      /**
       * Entity type: StockLabel
       */
      ID: number;
      Name: string;
      DisplayName: string;
      Description: string;
      IsDefault: boolean;
    }

  }

  /**
   * Returns all organizationunits with the configured setting for a single stocklabel.
   * 
   * Every organizationunit that has any setting set for the stocklabel will be returned.
   * If an organizationunit has no setting for a specific feature, it will inherit the setting from it’s parent, this is indicated by the `IsInherited` property.
   */
  export interface GetStockLabelSettingsForLabel {
    /**
     * Entity type: StockLabel
     */
    StockLabelID: number;
  }

  export interface GetStockLabelSettingsForLabelResponse {
    StockLabelSettings: GetStockLabelSettingsForLabelResponse.StockLabelSettingDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetStockLabelSettingsForLabelResponse {
    export interface StockLabelSettingDto {
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      /**
       * The name of the organizationunit.
       */
      OrganizationUnitName: string;
      /**
       * Indicates that these are the default settings for the stocklabel. These cannot be changed.
       */
      IsDefault: boolean;
      Sellable: GetStockLabelSettingsForLabelResponse.InheritedValue<boolean>;
      Movable: GetStockLabelSettingsForLabelResponse.InheritedValue<boolean>;
      Adjustable: GetStockLabelSettingsForLabelResponse.InheritedValue<boolean>;
      Returnable: GetStockLabelSettingsForLabelResponse.InheritedValue<boolean>;
      CycleCountable: GetStockLabelSettingsForLabelResponse.InheritedValue<boolean>;
      FullStockCountable: GetStockLabelSettingsForLabelResponse.InheritedValue<boolean>;
      ReturnToSupplierable: GetStockLabelSettingsForLabelResponse.InheritedValue<boolean>;
    }

    export interface InheritedValue<T> {
      Value: T;
      IsDefault: boolean;
      /**
       * Whether this value is inherited from a parent organization unit.
       */
      IsInherited: boolean;
    }

  }

  /**
   * Change the settings for a specific OU/StockLabel combination. Use a value of null to make it inherit from it’s parent.
   */
  export interface SetStockLabelSettings {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID: number;
    Movable?: boolean;
    Adjustable?: boolean;
    CycleCountable?: boolean;
    FullStockCountable?: boolean;
    Sellable?: boolean;
    IsDefaultSellable?: boolean;
    Returnable?: boolean;
    IsDefaultReturnable?: boolean;
    ReturnToSupplierable?: boolean;
    IsDefaultReturnToSupplierable?: boolean;
  }

  /**
   * Retrieve a StockNotification for a product and organization, for an EmailAddress - will return its ID, or null when it does not exist.
   */
  export interface GetStockNotification {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    EmailAddress: string;
  }

  export interface StockNotificationResponse {
    /**
     * Entity type: StockNotification
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Retrieve a StockNotification for a product and organization, for the current user - will return its ID, or null when it does not exist.
   */
  export interface GetStockNotificationForCurrentUser {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  /**
   * Creates a StockNotification for a product and organization, for specified EmailAddress - will return its ID.
   */
  export interface CreateStockNotification {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    EmailAddress: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
  }

  /**
   * Creates a StockNotification for a product and organization (or current when null), for the current user - will return its ID.
   */
  export interface CreateStockNotificationForCurrentUser {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
  }

  /**
   * Deletes a StockNotification by ID. When it was created with an EmailAddress, repeat that in this request by means of authentication.
   */
  export interface DeleteStockNotification {
    /**
     * Entity type: StockNotification
     */
    ID: number;
    EmailAddress?: string;
  }

  /**
   * Updates the Sellable stock of the given products for specified `OrganizationUnitID`, or when omitted, your current organization unit.
   * 
   * Specify the new, absolute quantities as values in the `Products` list. Products that are not mentioned will not be modified.
   */
  export interface UpdateStock {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    Products: UpdateStock.ProductDto[];
  }

  export namespace UpdateStock {
    export interface ProductDto {
      /**
       * Entity type: Product
       * 
       * Allows missing/invalid values when using EVA-IDs-Mode: ExternalIDs.
       */
      ID: number;
      Quantity: number;
    }

    export const enum UpdateStockIdentifier {
      ID = 0,
      BackendID = 1
    }

  }

  /**
   * Cancels shipments without receipt of goods, also removing stock in transit.
   */
  export interface CancelShipments {
    /**
     * Entity type: Shipment
     */
    ShipmentIDs: number[];
  }

  export interface CancelShipmentsResponse {
    Total: number;
    Errors: number;
    Message: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Create a new shipment
   * 
   * It is required to specify an Order. This can be done with `OrderID` or by sending `OrderBackendID` and `OrderBackendSystemID`.
   * 
   * To create a pending Shipment, set `IsPending` to true. A pending shipment has to be shipped with the ShipShipment service.
   */
  export interface CreateShipment {
    /**
     * ID of the order that is being shipped - required when `OrderBackendID` and `OrderBackendSystemID` are omitted
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: OrderFulfillment
     */
    OrderFulfillmentID?: number;
    /**
     * Reference to the order that is being shipped - required when `OrderID` is omitted
     */
    OrderBackendID?: string;
    /**
     * Reference to the system from which the order originated - required when `OrderID` is omitted
     */
    OrderBackendSystemID?: string;
    /**
     * Optional, will be determined based on the Order
     * Entity type: OrganizationUnit
     */
    ShippedFromOrganizationUnitID?: number;
    ShipmentDate?: string;
    ExpectedDeliveryDate?: string;
    /**
     * Optional. When only lines are provided, the PackageID can be used to create a package for all lines.
     * Entity type: Package
     */
    PackageID?: number;
    Lines?: CreateShipment.ShipmentLine[];
    Packages?: CreateShipment.ShipmentPackage[];
    BackendID?: string;
    BackendSystemID?: string;
    TrackingCode?: string;
    TrackingLink?: string;
    ReceiveMethod?: ShipmentReceiveMethods;
    IsPending?: boolean;
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
    ShipmentIdentifiers?: CreateShipment.ShipmentIdentifier[];
  }

  export namespace CreateShipment {
    export interface ShipmentIdentifier {
      /**
       * Entity type: ShipmentIdentifier
       */
      ID: number;
      Value: string;
    }

    export interface ShipmentPackage {
      /**
       * Entity type: Package
       */
      PackageID: number;
      Lines: CreateShipment.ShipmentLine[];
    }

    export interface ShipmentLine {
      /**
       * Entity type: Order
       */
      OrderID?: number;
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      /**
       * Entity type: OrderFulfillmentLine
       */
      OrderFulfillmentLineID?: number;
      OrderLineBackendID?: string;
      /**
       * When not provided, the QuantityOpen of the OrderLine will be used
       */
      Quantity?: number;
      BackendReference: string;
      /**
       * Entity type: Product
       */
      StockProductID?: number;
    }

  }

  export const enum ShipmentReceiveMethods {
    Manual = 0,
    Automatic = 1,
    UserDefined = 2
  }

  export interface CreateShipmentResponse {
    /**
     * Entity type: Shipment
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Delete an existing shipment that has status Pending.
   * 
   * Works only for SalesOrders at this moment.
   */
  export interface DeleteShipment {
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    BackendID?: string;
    BackendSystemID?: string;
  }

  /**
   * Delivers an undelivered SalesOrder shipment. This will give both the shipment and the orderline the status that they have been delivered.
   */
  export interface DeliverShipment {
    /**
     * Either this or ShipmentBackendID is required.
     * Entity type: Shipment
     */
    ShipmentID?: number;
    /**
     * Either this or ShipmentID is required. If ShipmentBackendID is specified, ShipmentBackendSystem is also required.
     */
    ShipmentBackendID?: string;
    /**
     * Required if ShipmentBackendID is specified.
     */
    ShipmentBackendSystemID?: string;
  }

  /**
   * Retrieve shipment details for the given ShipmentID.
   */
  export interface GetPurchaseOrderShipment {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
  }

  export interface GetPurchaseOrderShipmentResponse {
    Shipment: PurchaseOrderShipmentDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface PurchaseOrderShipmentDto {
    /**
     * Entity type: Shipment
     */
    ID: number;
    IsDeleted: boolean;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    ShipmentDate?: string;
    OriginalDeliveryDate?: string;
    ExpectedDeliveryDate?: string;
    BackendID: string;
    BackendSystemID: string;
    TrackingCode: string;
    TrackingLink: string;
    CreationTime: string;
    TotalQuantityShipped: number;
    TotalQuantityDelivered: number;
    NetTotalQuantityShipped: number;
    NetTotalQuantityDelivered: number;
    IsCompleted: boolean;
    StatusID: number;
    TotalPackageCountIndication: number;
    Orders: PurchaseOrderShipmentDto.OrderDto[];
    ReceiveMethodID?: number;
    ReceiptCreatedBy: string;
    ReceiptCreatedOn?: string;
    /**
     * Indicates that this shipment has lines where the delivered quantity and the shipped quantity differ.
     */
    HasDeviations: boolean;
    ShipmentIdentifiers: PurchaseOrderShipmentDto.ShipmentIdentifier[];
    /**
     * Entity type: OrganizationUnit
     */
    ShippedFromOrganizationUnitID?: number;
    ShippedFromOrganizationUnitName?: string;
  }

  export namespace PurchaseOrderShipmentDto {
    export interface ShipmentIdentifier {
      /**
       * Entity type: ShipmentIdentifier
       */
      ID: number;
      Name: string;
      Value: string;
      Type: ShipmentIdentifierTypes;
    }

    export interface OrderDto {
      /**
       * Entity type: Order
       */
      ID: number;
      BackendID: string;
      DisplayID?: string;
    }

  }

  export const enum ShipmentIdentifierTypes {
    Crate = 0,
    Seal = 1
  }

  /**
   * Get a Shipment by its ID, returning information about where it came from, where it's shipped to, its shipping or delivery status and payment status
   * of the order(s) contained in the shipment.
   */
  export interface GetShipment {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
  }

  export interface GetShipmentResponse {
    /**
     * Entity type: Shipment
     */
    ID: number;
    ShippedToOrganizationUnit: GetShipmentResponse.OrganizationUnit;
    ShippedFromOrganizationUnit?: GetShipmentResponse.OrganizationUnit;
    ShipmentDate?: string;
    OriginalDeliveryDate?: string;
    ExpectedDeliveryDate?: string;
    BackendID: string;
    BackendSystemID: string;
    TrackingCode: string;
    TrackingLink: string;
    TotalQuantityShipped: number;
    NetTotalQuantityShipped: number;
    TotalQuantityDelivered: number;
    NetTotalQuantityDelivered: number;
    LastDeliveryDate?: string;
    Packages: GetShipmentResponse.ShipmentPackage[];
    ReceiveMethod?: ShipmentReceiveMethods;
    Status: ShipmentStatuses;
    IsCompleted: boolean;
    IsDelivered: boolean;
    IsExported: boolean;
    CompletionTime?: string;
    OrderType: OrderTypes;
    OrdersInShipment: GetShipmentResponse.OrderInShipment[];
    PaymentHandledByCarrier: boolean;
    LineCount: number;
    IsDeleted: boolean;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    ShipmentIdentifiers: GetShipmentResponse.ShipmentIdentifier[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetShipmentResponse {
    export interface ShipmentIdentifier {
      /**
       * Entity type: ShipmentIdentifier
       */
      ID: number;
      Name: string;
      Value: string;
      RequiredFor: ShipmentIdentifierRequiredFor;
      Type: ShipmentIdentifierTypes;
    }

    export interface OrganizationUnit {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
      Type: OrganizationUnitTypes;
    }

    export interface ShipmentPackage {
      ID: number;
      Description: string;
      Quantity: number;
      Length: number;
      Width: number;
      Height: number;
      Weight: number;
    }

    export interface OrderInShipment {
      /**
       * Entity type: Order
       */
      OrderID?: number;
      OrderDisplayID?: string;
      TotalAmountInTax?: number;
      PaidAmount?: number;
      OpenAmount?: number;
    }

  }

  export const enum ShipmentStatuses {
    Open = 0,
    Completed = 10,
    Cancelled = 11,
    Pending = -1
  }

  export const enum ShipmentIdentifierRequiredFor {
    None = 0,
    RTS = 1,
    PurchaseOrder = 2
  }

  /**
   * Paged listing of purchase order shipments filtered by the provided PageConfig.
   */
  export interface ListPurchaseOrderShipments {
    PageConfig?: PageConfig<ListPurchaseOrderShipmentsFilter>;
  }

  export interface ListPurchaseOrderShipmentsFilter {
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    OrderBackendID?: string;
    OrderBackendIDs?: string[];
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    IncludeChildOrganizationUnits: boolean;
    BackendID?: string;
    ShipmentBackendIDs?: string[];
    TrackingCode: string;
    IsCompleted?: boolean;
    StatusID?: number;
    StatusIDs: number[];
    /**
     * Only return shipments that have deviations. That is: shipments where the delivered quantity and the shipped quantity differ on any line.
     */
    HasDeviations?: boolean;
    ReceiveMethod?: ShipmentReceiveMethods;
  }

  export interface ListPurchaseOrderShipmentsResponse {
    Result?: PagedResult<PurchaseOrderShipmentDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Retrieves a paged list of Shipment Ledgers for specified ShipmentID.
   */
  export interface ListShipmentLedgerForShipment {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
    PageConfig?: PageConfig<ListShipmentLedgerFilter>;
  }

  export interface ListShipmentLedgerFilter {
    /**
     * Entity type: ShipmentLedgerType
     */
    TypeIDs: number[];
  }

  export interface ListShipmentLedgerForShipmentResponse {
    Result?: PagedResult<ListShipmentLedgerForShipmentResponse.ShipmentLedgerDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListShipmentLedgerForShipmentResponse {
    export interface ShipmentLedgerDto {
      /**
       * Entity type: ShipmentLedger
       */
      ID: number;
      /**
       * Entity type: Shipment
       */
      ShipmentID: number;
      Type: EnumDto;
      /**
       * Entity type: ShipmentLedgerType
       */
      TypeID: number;
      OldValue: string;
      NewValue: string;
      Description: string;
      /**
       * Entity type: User
       */
      CreatedByID: number;
      CreationTime: string;
      CreatedBy: ListShipmentLedgerForShipmentResponse.UserDto;
    }

    export interface UserDto {
      /**
       * Entity type: User
       */
      ID: number;
      FullName: string;
    }

  }

  /**
   * Returns serial numbers on a shipment line with pagination and filtering capabilities.
   */
  export interface ListShipmentLineSerialNumbers {
    /**
     * Entity type: ShipmentLine
     */
    ShipmentLineID: number;
    PageConfig?: PageConfig<ListShipmentLineSerialNumbersFilter>;
  }

  export interface ListShipmentLineSerialNumbersFilter {
    /**
     * Filter serial numbers containing this text
     */
    SerialNumber?: string;
  }

  export interface ListShipmentLineSerialNumbersResponse {
    Result?: PagedResult<ListShipmentLineSerialNumber>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListShipmentLineSerialNumber {
    SerialNumber: string;
  }

  /**
   * List shipmentlines of a shipment, this service replaces the GetShipmentLines and the ListPurchaseOrderShipmentLines services.
   * 
   * The page size `Limit` has a maximum value of `10.000` for this service.
   */
  export interface ListShipmentLines {
    PageConfig?: PageConfig<ListShipmentLinesFilter>;
  }

  export interface ListShipmentLinesFilter {
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    /**
     * Entity type: ShipmentPackage
     */
    ShipmentPackageID?: number;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    /**
     * Entity type: Order
     */
    OrderIDs: number[];
    /**
     * Entity type: OrderLine
     */
    OrderLineIDs: number[];
    ExcludeEmptyLines?: boolean;
  }

  export interface ListShipmentLinesResponse {
    Result?: PagedResult<ShipmentLineDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ShipmentLineDto {
    /**
     * Entity type: ShipmentLine
     */
    ID: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    ProductBackendID: string;
    ProductCustomID: string;
    Type: OrderLineTypes;
    Description: string;
    BackendReference: string;
    TotalQuantityToShip: number;
    QuantityShipped: number;
    QuantityDelivered: number;
    CurrencyID: string;
    UnitPrice: number;
    IsCompleted: boolean;
    TotalAmount: number;
    TotalAmountInTax: number;
    UnitPriceInTax: number;
    TaxRate: number;
    DeliveryType: ShipmentLineDeliveryTypes;
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
    ShipmentDate?: string;
    NetQuantityShipped: number;
    NetQuantityDelivered: number;
    ShipmentPackageID?: number;
    HasSerialNumbers: boolean;
  }

  export const enum ShipmentLineDeliveryTypes {
    Default = 0,
    Surplus = 1,
    Deficiency = 2
  }

  /**
   * Lists shipment packages for a specified shipment
   */
  export interface ListShipmentPackages {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
    PageConfig?: PageConfig<ListShipmentPackagesFilter>;
  }

  export interface ListShipmentPackagesFilter {
  }

  export interface ListShipmentPackagesResponse {
    Result?: PagedResult<ShipmentPackageDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ShipmentPackageDto {
    ID: number;
    Package: ShipmentPackageDto.PackageDto;
  }

  export namespace ShipmentPackageDto {
    export interface PackageDto {
      ID: number;
      Description: string;
      Length: number;
      Width: number;
      Height: number;
      Weight: number;
    }

  }

  /**
   * Modify the QuantityShipped on one or more ShipmentLines of a Shipment.
   * 
   * When the new QuantityShipped is 0 it will be cancelled.
   */
  export interface ModifyQuantityShipped {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
    Lines: ModifyQuantityShipped.ShipmentLine[];
  }

  export namespace ModifyQuantityShipped {
    export interface ShipmentLine {
      /**
       * Entity type: ShipmentLine
       */
      ShipmentLineID: number;
      QuantityShipped: number;
    }

  }

  /**
   * Generate a packing slip PDF for a shipment, optionally printing or downloading.
   */
  export interface ProducePackingSlip {
    /**
     * Entity type: Station
     */
    StationID?: number;
    Download?: boolean;
    Print?: boolean;
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
  }

  export interface ProducePackingSlipResponse {
    ResourceInfo: ResourceInfo;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Generate pick slips for the provided OrderIDs, optionally printing them.
   */
  export interface ProducePickSlip {
    /**
     * Entity type: Order
     */
    OrderIDs: number[];
    /**
     * Entity type: Station
     */
    StationID?: number;
    Print?: boolean;
  }

  export interface ProducePickSlipResponse {
    ResourceInfos: ResourceInfo[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListShipmentExportsForShipment {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListShipmentExportsForShipmentResponse {
    Result?: PagedResult<ListShipmentExportsForShipmentResponse.ShipmentExportDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListShipmentExportsForShipmentResponse {
    export interface ShipmentExportDto {
      ID: number;
      Name: string;
      Status: TransputJobStatuses;
      CreationTime: string;
      LastModificationTime?: string;
    }

  }

  /**
   * Retrieve details for a ShipmentExport given its ID.
   */
  export interface GetShipmentExportByID {
    /**
     * Entity type: ShipmentExport
     */
    ID: number;
  }

  export interface GetShipmentExportByIDResponse {
    ID: number;
    ShipmentID: number;
    Name: string;
    Status: TransputJobStatuses;
    ShippedFromOrganizationUnitID?: number;
    ShippedFromOrganizationUnitName: string;
    ShippedToOrganizationUnitID: number;
    ShippedToOrganizationUnitName: string;
    CreationTime: string;
    LastModificationTime?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Retry exporting a shipment by ID.
   */
  export interface RetryShipmentExport {
    /**
     * Entity type: ShipmentExport
     */
    ID: number;
    Force?: boolean;
  }

  /**
   * Get request and response documents for a ShipmentExport by ID.
   */
  export interface GetShipmentExportDocuments {
    /**
     * Entity type: ShipmentExport
     */
    ID: number;
  }

  export interface GetShipmentExportDocumentsResponse {
    RequestDocuments: TransputJobDocument[];
    ResponseDocuments: TransputJobDocument[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface TransputJobDocument {
    CreationTime: string;
    Document: string;
  }

  /**
   * Get a shipment identifier by ID.
   */
  export interface GetShipmentIdentifier {
    /**
     * Entity type: ShipmentIdentifier
     */
    ID: number;
  }

  export interface GetShipmentIdentifierResponse {
    /**
     * Entity type: ShipmentIdentifier
     */
    ID: number;
    Name: string;
    Type: ShipmentIdentifierTypes;
    RequiredFor: ShipmentIdentifierRequiredFor;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * List shipment identifiers.
   */
  export interface ListShipmentIdentifiers {
  }

  export interface ListShipmentIdentifiersResponse {
    ShipmentIdentifiers: ListShipmentIdentifiersResponse.ShipmentIdentifierDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListShipmentIdentifiersResponse {
    export interface ShipmentIdentifierDto {
      /**
       * Entity type: ShipmentIdentifier
       */
      ID: number;
      Name: string;
      Type: ShipmentIdentifierTypes;
      RequiredFor: ShipmentIdentifierRequiredFor;
    }

  }

  /**
   * Delete an existing shipment identifier.
   */
  export interface DeleteShipmentIdentifier {
    /**
     * Entity type: ShipmentIdentifier
     */
    ID: number;
  }

  /**
   * Update an existing shipment identifier.
   */
  export interface UpdateShipmentIdentifier {
    /**
     * Entity type: ShipmentIdentifier
     */
    ID: number;
    Name?: string;
    Type?: ShipmentIdentifierTypes;
    RequiredFor?: ShipmentIdentifierRequiredFor;
  }

  /**
   * Create a new shipment identifier.
   */
  export interface CreateShipmentIdentifier {
    Name: string;
    Type: ShipmentIdentifierTypes;
    /**
     * Which flow this identifier should be required for.
     */
    RequiredFor: ShipmentIdentifierRequiredFor;
  }

  export interface CreateShipmentIdentifierResponse {
    /**
     * Entity type: ShipmentIdentifier
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * This service is used in combination with the `GetShipmentSettings` to manage OrganizationUnit settings for Shipments.
   * Optionally an OrganizationUnitID can be provided, but by default the settings are updated for the current OrganizationUnit.
   * 
   * - DefaultReceiveMethod: How shipments should be received if no custom implementation is available
   */
  export interface SetShipmentSettings {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    DefaultReceiveMethod?: ShipmentReceiveMethods;
  }

  /**
   * @see: SetShipmentSettings
   */
  export interface GetShipmentSettings {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export interface GetShipmentSettingsResponse {
    OrganizationUnitID: number;
    DefaultReceiveMethod: ShipmentReceiveMethods;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Ship an existing shipment that has status Pending.
   * 
   * Works only for SalesOrders at this moment.
   */
  export interface ShipShipment {
    BackendID?: string;
    BackendSystemID?: string;
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    /**
     * The moment the shipment was shipped, will be set to DateTime.Now when not set
     */
    ShipmentDate?: string;
    TrackingCode?: string;
    TrackingLink?: string;
    /**
     * Allow to force shipment. Requires additional rights
     */
    Force?: boolean;
  }

  /**
   * Removes stock from transit for an unreceived shipment
   */
  export interface UndoShipment {
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    /**
     * The reason for undoing the shipment
     */
    Remark?: string;
  }

  /**
   * Removes stock for a received shipment
   */
  export interface UndoShipmentReceipt {
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    /**
     * The reason for undoing the shipment
     */
    Remark?: string;
  }

  /**
   * Update a Shipment. For shipments with status > Pending, only `ReceiveMethod`, `ShipmentDate` and `ExpectedDeliveryDate` can be updated.
   * Updating a shipment creates the new necessary shipping lines and packages.
   * Using the RemoveOtherPackagesAndLines property removes the existing ones.
   */
  export interface UpdateShipment {
    BackendID?: string;
    BackendSystemID?: string;
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    ReceiveMethod?: ShipmentReceiveMethods;
    /**
     * Explanation of why the receive method has been changed
     */
    ReceiveMethodChangedReason?: string;
    ShipmentDate?: string;
    ExpectedDeliveryDate?: string;
    /**
     * Optional. When only lines are provided, the PackageID can be used to create a package for all lines.
     * Entity type: Package
     */
    PackageID?: number;
    Lines?: UpdateShipment.ShipmentLine[];
    Packages?: UpdateShipment.ShipmentPackage[];
    TrackingCode?: string;
    TrackingLink?: string;
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
    /**
     * Overwrite the existing Lines and Packages, instead of adding to the existing ones
     * @default false
     */
    RemoveOtherPackagesAndLines?: boolean;
    ShipmentIdentifiers?: UpdateShipment.ShipmentIdentifier[];
  }

  export namespace UpdateShipment {
    export interface ShipmentIdentifier {
      /**
       * Entity type: ShipmentIdentifier
       */
      ID: number;
      Value: string;
    }

    export interface ShipmentPackage {
      /**
       * Entity type: ShipmentPackage
       */
      ID?: number;
      /**
       * Entity type: Package
       */
      PackageID: number;
      Lines: UpdateShipment.ShipmentLine[];
    }

    export interface ShipmentLine {
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      OrderLineBackendID?: string;
      /**
       * When not provided, the QuantityOpen of the OrderLine will be used
       */
      Quantity?: number;
      BackendReference?: string;
    }

  }

  /**
   * Updates the shipment status, creating ledger entries on shipment level.
   * 
   * Will be processed as a whole; a single failing line in `Lines` will prevent all other updates in a single call from persisting.
   */
  export interface UpdateShipmentStatus {
    Lines: UpdateShipmentStatusLine[];
  }

  export interface UpdateShipmentStatusLine {
    /**
     * Identifier of the EVA shipment this update is specific for
     * Entity type: Shipment
     */
    ShipmentID: number;
    /**
     * Type of shipment status update; 0 = CarrierStatus
     */
    Type: ShipmentStatusType;
    /**
     * Date the event occurred - leave empty for 'now'.
     */
    Date?: string;
    /**
     * Optional, additional information, most commonly for the carrier status update code (B01, D01, ...) for CarrierStatus types
     */
    Value?: string;
    /**
     * Optional, additional description, most commonly for the carrier status update code description for CarrierStatus types
     */
    Description?: string;
  }

  export const enum ShipmentStatusType {
    CarrierStatus = 0
  }

  /**
   * Validates if a Shipment can be shipped in the current state.
   * 
   * Returns if it is valid (`IsValid`) and if not, how much still needs to be paid (`OpenAmountForShipment`).
   */
  export interface ValidateShipment {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
  }

  export interface ValidateShipmentResponse {
    PaidAmount: number;
    OpenAmountForShipment: number;
    IsValid: boolean;
    ShipmentStatus: ShipmentStatuses;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * List serial number registrations for a serial number.
   */
  export interface ListSerialNumberRegistrations {
    PageConfig?: PageConfig<ListSerialNumberRegistrationsFilter>;
  }

  export interface ListSerialNumberRegistrationsFilter {
    SerialNumber: string;
  }

  export interface ListSerialNumberRegistrationsResponse {
    Result?: PagedResult<ListSerialNumberRegistrationsResponse.SerialNumberRegistrationModel>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListSerialNumberRegistrationsResponse {
    export interface SerialNumberRegistrationModel {
      /**
       * Entity type: SerialNumberRegistration
       */
      ID?: number;
      /**
       * Entity type: User
       */
      CreatedByID?: number;
      CreationTime?: string;
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      /**
       * Entity type: CaseRelatedItem
       */
      CaseRelatedItemID?: number;
      /**
       * Entity type: Repair
       */
      RepairID?: number;
      /**
       * Entity type: UserBoughtProduct
       */
      UserBoughtProductID?: number;
      /**
       * Entity type: FullStockCountLabelProduct
       */
      FullStockCountLabelProductID?: number;
      /**
       * Entity type: ZonedCycleCountPreCountResult
       */
      ZonedCycleCountPreCountResultID?: number;
      /**
       * Entity type: ShipmentLine
       */
      ShipmentLineID?: number;
    }

  }

  export const enum SerialNumberRegistrationStatus {
    Pending = 0,
    Verified = 1,
    Rejected = -1
  }

  /**
   * Creates a new entity for Serial Number Configuration, defining a set of requirements where linked products should adhere to.
   */
  export interface CreateSerialNumberConfiguration {
    Name?: string;
    Description?: string;
    ValidationRegex?: string;
    IsStrict?: boolean;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    Requirement?: SerialNumberConfigurationRequirement;
  }

  export const enum SerialNumberConfigurationRequirement {
    Sales = 0,
    OwnershipChange = 1,
    StockMovements = 2,
    None = -1
  }

  export interface CreateSerialNumberConfigurationResponse {
    /**
     * Entity type: SerialNumberConfiguration
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Updates an existing Serial Number Configuration by it's `ID`.
   */
  export interface UpdateSerialNumberConfiguration {
    /**
     * Entity type: SerialNumberConfiguration
     */
    ID: number;
    Name?: string;
    Description?: string;
    ValidationRegex?: string;
    IsStrict?: boolean;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    Requirement?: SerialNumberConfigurationRequirement;
  }

  /**
   * Get all Serial Number Configurations, without paging.
   */
  export interface GetSerialNumberConfigurations {
  }

  export interface GetSerialNumberConfigurationsResponse {
    SerialNumberConfigurations: GetSerialNumberConfigurationsResponse.SerialNumberConfigurationDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetSerialNumberConfigurationsResponse {
    export interface SerialNumberConfigurationDto {
      /**
       * Entity type: SerialNumberConfiguration
       */
      ID?: number;
      Name?: string;
      Description?: string;
      ValidationRegex?: string;
      IsStrict?: boolean;
      /**
       * Entity type: Script
       */
      ScriptID?: number;
      Requirement?: SerialNumberConfigurationRequirement;
    }

  }

  /**
   * Deletes an existing Serial Number Configuration by it's `ID` if this is not linked to any existing Serial Number Product.
   */
  export interface DeleteSerialNumberConfiguration {
    /**
     * Entity type: SerialNumberConfiguration
     */
    ID: number;
  }

  /**
   * Lists all products associated with a Serial Number Configuration.
   */
  export interface ListSerialNumberProducts {
    PageConfig?: PageConfig<ListSerialNumberProductsFilter>;
  }

  export interface ListSerialNumberProductsFilter {
    /**
     * Entity type: SerialNumberConfiguration
     */
    SerialNumberConfigurationID: number;
  }

  export interface ListSerialNumberProductsResponse {
    Result?: PagedResult<ListSerialNumberProductsResponse.SerialNumberProductModel>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListSerialNumberProductsResponse {
    export interface SerialNumberProductModel {
      /**
       * Entity type: Product
       */
      ProductID: number;
    }

  }

  /**
   * Associate a product with a Serial Number Configuration, or re-associate with this Serial Number Configuration in case it was previously assigned to another.
   */
  export interface CreateSerialNumberProduct {
    /**
     * Entity type: Product
     * @deprecated Use `ProductIDs`
     */
    ProductID?: number;
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    /**
     * Entity type: SerialNumberConfiguration
     */
    SerialNumberConfigurationID?: number;
  }

  /**
   * Removes a product association with a Serial Number Configuration.
   */
  export interface DeleteSerialNumberProduct {
    /**
     * Entity type: Product
     * @deprecated Use `ProductIDs`
     */
    ProductID?: number;
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
  }

  /**
   * Create a new Serial Number
   */
  export interface CreateSerialNumber {
    SerialNumber: string;
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * @default Allow
     */
    Status?: SerialNumberStatus;
  }

  export const enum SerialNumberStatus {
    Allow = 0,
    Deny = 1
  }

  export interface CreateSerialNumberResponse {
    /**
     * Entity type: SerialNumber
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Gets information about a serial number
   */
  export interface GetSerialNumber {
    SerialNumber: string;
  }

  export interface GetSerialNumberResponse {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    Status: SerialNumberStatus;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Lists Serial Numbers
   */
  export interface ListSerialNumbers {
    PageConfig?: PageConfig<ListSerialNumbersFilter>;
  }

  export interface ListSerialNumbersFilter {
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    Status?: SerialNumberStatus;
    SerialNumbers?: string[];
  }

  export interface ListSerialNumbersResponse {
    Result?: PagedResult<ListSerialNumbersResponse.SerialNumberModel>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListSerialNumbersResponse {
    export interface SerialNumberModel {
      SerialNumber?: string;
      /**
       * Entity type: Product
       */
      ProductID?: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID?: number;
      /**
       * Entity type: StockLabel
       */
      StockLabelID?: number;
      Status?: SerialNumberStatus;
    }

  }

  /**
   * Push multiple serial numbers into EVA.
   * 
   * - The `ProductID` is required
   * - You must either specify *both*, or *neither* of `StockLabelID` and `OrganizationUnitID`
   * 
   * :bulb: Our recommended JSON request size limit is 10 MB
   * :muscle: So when calling this service with just a `SerialNumber` and a `ProductID`, that should be somewhere between 100.000 and 200.000 serials per call
   * :warning: When a product belongs to a Serial Number Configuration that is configured with a validation regex, serial numbers pushed for that product must match this regex
   * 
   * This service is built for speeeeeeeeeeeed :rocket:, and so has a slightly different idempotency from other services;
   * 
   * - Skips over errors and attempts to persist as many serial numbers as possible
   * - Gathers any error encountered and returns (up to 1.000 of) them, so you can fix & retry
   * - Ignores serial numbers that already exist in EVA
   * - Ignores duplicates within the same call (but it's undefined which serial number is used)
   * - Ignores duplicates within multiple simultaneous calls (but it's undefined which serial number is used)
   * - Skips over serial number validation for second chance products
   */
  export interface PushSerialNumbers {
    SerialNumbers: PushSerialNumbers.SerialNumberModel[];
  }

  export namespace PushSerialNumbers {
    export interface SerialNumberModel {
      SerialNumber: string;
      /**
       * Entity type: Product
       */
      ProductID: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID?: number;
      /**
       * Entity type: StockLabel
       */
      StockLabelID?: number;
      /**
       * Defaults to `Allow`
       * @default Allow
       */
      Status?: SerialNumberStatus;
    }

  }

  export interface PushSerialNumbersResponse {
    Errors: { [key: string]: string };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Parses a script for validation and auto-completion.
   * 
   * Can be used as the user types their script, for that purpose use these parameters:
   * - Type: Fast, doing Full performs a full compilation of the script which can take longer. Using Full can be done before the user hits the Save button, or for example every 10th keystroke or so.
   * 
   * Use IncludeCompletionSuggestions if you want to display auto-completion suggestions to the user.
   * 
   * You can verify the entire script and get completion results by passing in the full script as the Source and only the text until the user's cursor in the CompletionSource.
   * 
   * A list of the available dialects can be retrieved by calling GetScriptDialects.
   */
  export interface ParseScript {
    /**
     * The script to parse.
     */
    Source?: string;
    /**
     * The script to parse, in token format as returned by ParseScript when IncludeStructure is passed in as `true`.
     */
    SourceTokens?: ScriptToken[];
    Dialect?: string;
    Type?: ParseTypes;
    IncludeStructure?: boolean;
    DocumentationRequest?: ParseScript.DocumentationRequestInfo;
    AvailableVariablesRequest?: ParseScript.AvailableVariablesRequestInfo;
    CompletionRequest?: ParseScript.CompletionRequestInfo;
  }

  export namespace ParseScript {
    export interface CompletionRequestInfo {
      /**
       * The script that you want to have auto-completion suggestions for.
       * This can be different than the full Source as you only want to provide completion suggestions at the current cursor position,
       * so you can provide the full source for validation purposes and provide the script up to the cursor position for auto-completion suggestions.
       */
      Source?: string;
      SourceTokens?: ScriptToken[];
    }

    export interface DocumentationRequestInfo {
      /**
       * The 0-based column number of the position in the script that you would like documentation for.
       * Min: 0
       */
      Column: number;
      /**
       * The 1-based line number of the position in the script that you would like documentation for.
       * Min: 1
       */
      Line: number;
    }

    export interface AvailableVariablesRequestInfo {
      /**
       * The 0-based column number of the position in the script that you would like to know the available variables for.
       * Min: 0
       */
      Column: number;
      /**
       * The 1-based line number of the position in the script that you would like to know the available variables for.
       * Min: 1
       */
      Line: number;
    }

  }

  export interface ScriptToken {
    Index?: number;
    Type?: string;
    Text?: string;
    Value?: any;
    Column?: number;
    Line?: number;
    IsEditable?: boolean;
    LeadingTrivia?: ScriptTokenTrivia[];
    TrailingTrivia?: ScriptTokenTrivia[];
  }

  export interface ScriptTokenTrivia {
    Type?: string;
    Text?: string;
    Column?: number;
    Line?: number;
  }

  export const enum ParseTypes {
    None = 0,
    Parse = 1,
    Fast = 1,
    TypeCheck = 3,
    Transpile = 7,
    Full = 7
  }

  export interface ParseScriptResponse {
    HasErrors?: boolean;
    HasWarnings?: boolean;
    Errors?: ScriptError[];
    Warnings?: ScriptWarning[];
    CompletionSuggestions?: CompletionSuggestion[];
    Documentation?: DocumentationResult;
    AvailableVariables?: AvailableVariablesResult;
    Structure?: ScriptStructure;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ScriptError {
    Type: string;
    Message: string;
    SourceLine: string;
    SourceLineNumber: number;
    SourceColumn: number;
  }

  export interface ScriptWarning {
    Message: string;
    SourceLine: string;
    SourceLineNumber: number;
    SourceColumn: number;
  }

  export interface CompletionSuggestion {
    Category?: CompletionCategories;
    Label?: string;
    Code?: string;
    Priority?: number;
    Documentation?: string;
  }

  export const enum CompletionCategories {
    Keyword = 0,
    Member = 1,
    Snippet = 2
  }

  export interface DocumentationResult {
    Component?: string;
    Documentation?: string;
  }

  export interface AvailableVariablesResult {
    Variables?: VariableNode[];
  }

  export interface VariableNode {
    Name?: string;
    Children?: VariableNode[];
    Description?: string;
  }

  export interface ScriptStructure {
    RootNode?: ScriptNode;
    Tokens?: ScriptToken[];
  }

  export interface ScriptNode {
    ID?: number;
    ParentID?: number;
    Type?: string;
    Info?: string;
    Tokens?: number[];
    Children?: ScriptNode[];
  }

  /**
   * Creates a new script.
   */
  export interface CreateScript {
    Name?: string;
    Source?: string;
    Dialect?: string;
    IsActive?: boolean;
    IsPrivate?: boolean;
  }

  export interface CreateScriptResponse {
    /**
     * Entity type: Script
     */
    ID?: number;
    RequiresApproval: boolean;
    HasErrors?: boolean;
    HasWarnings?: boolean;
    Errors?: ScriptError[];
    Warnings?: ScriptWarning[];
    CompletionSuggestions?: CompletionSuggestion[];
    Documentation?: DocumentationResult;
    AvailableVariables?: AvailableVariablesResult;
    Structure?: ScriptStructure;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Updates a script
   */
  export interface UpdateScript {
    /**
     * Entity type: Script
     */
    ID?: number;
    RevisionComment?: string;
    Name?: string;
    Source?: string;
    Dialect?: string;
    IsActive?: boolean;
    SourceTokens?: ScriptToken[];
    EditabilityConfiguration?: ScriptEditabilityConfiguration;
  }

  export interface ScriptEditabilityConfiguration {
    Elements?: EditableElementConfiguration[];
  }

  export interface EditableElementConfiguration {
    ID?: string;
    IsEditable?: boolean;
    Name?: string;
    DisplayName?: string;
    Description?: string;
    FieldType?: EditableFieldTypes;
    VariableConfiguration?: EditableVariableConfiguration;
    TableConfiguration?: EditableTableConfiguration;
    IsMissing?: boolean;
  }

  export const enum EditableFieldTypes {
    SetVariable = 0,
    DeclareTable = 1
  }

  export interface EditableVariableConfiguration {
    ValueType?: EditableFieldValueTypes;
    Values?: EditableItemCurrentValue[];
    EntityType?: EditableFieldEntityTypes;
    AllowMultipleValues?: boolean;
    SuggestedAllowMultipleValues?: boolean;
    SuggestedValueType?: EditableFieldValueTypes;
    MinValue?: number;
    MaxValue?: number;
    MinLength?: number;
    MaxLength?: number;
  }

  export const enum EditableFieldValueTypes {
    String = 0,
    Integer = 1,
    Decimal = 2,
    Boolean = 3,
    Date = 4
  }

  export interface EditableItemCurrentValue {
    Type?: EditableItemValueTypes;
    Value?: any;
  }

  export const enum EditableItemValueTypes {
    NumberLiteral = 0,
    StringLiteral = 1,
    BooleanLiteral = 2,
    NullLiteral = 3,
    DynamicValue = 4
  }

  export const enum EditableFieldEntityTypes {
    OrganizationUnitBackendID = 0,
    ProductBackendID = 1,
    CountryID = 2
  }

  export interface EditableTableConfiguration {
    Columns?: EditableTableColumnConfiguration[];
    Rows?: EditableTableRow[];
  }

  export interface EditableTableColumnConfiguration {
    ID?: string;
    Name?: string;
    DisplayName?: string;
    Description?: string;
    Type?: EditableTableColumnType;
    EntityType?: EditableFieldEntityTypes;
    Number?: number;
    IsMissing?: boolean;
  }

  export const enum EditableTableColumnType {
    Unknown = 0,
    String = 1,
    Number = 2,
    Boolean = 3
  }

  export interface EditableTableRow {
    Cells?: EditableTableCell[];
  }

  export interface EditableTableCell {
    ColumnNumber?: number;
    Value?: any;
  }

  export interface UpdateScriptResponse {
    HasErrors?: boolean;
    HasWarnings?: boolean;
    RequiresApproval?: boolean;
    Errors?: ScriptError[];
    Warnings?: ScriptWarning[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Lists scripts, optionally filtered.
   */
  export interface ListScripts {
    InitialPageConfig?: PageTokenConfig<ListScriptsFilter>;
    PageToken?: string;
  }

  export interface ListScriptsFilter {
    /**
     * Entity type: Script
     */
    ID?: number;
    IsActive?: boolean;
    Name?: string;
    Dialect?: string;
    Source?: string;
    Type?: string;
    IsPrivate?: boolean;
    HasProposedEdit?: boolean;
  }

  export interface ListScriptsResponse {
    Results?: ListScriptsItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListScriptsItem {
    /**
     * Entity type: Script
     */
    ID?: number;
    Name?: string;
    Source?: string;
    Dialect?: string;
    IsActive?: boolean;
    Revision?: string;
    UserID?: number;
    UserFullName?: string;
    Date?: string;
    Type?: string;
    RevisionComment?: string;
    IsPrivate?: boolean;
    ProposedEdit?: ProposedScriptEdit;
  }

  export interface ProposedScriptEdit {
    Source?: string;
    IsActive?: boolean;
    IsDeleted?: boolean;
    RevisionComment?: string;
    CreationTime?: string;
    LastModificationTime?: string;
    User?: ProposedScriptEdit.ProposedByUser;
  }

  export namespace ProposedScriptEdit {
    export interface ProposedByUser {
      ID?: number;
      FullName?: string;
      EmailAddress?: string;
    }

  }

  /**
   * Gets a script by ID
   */
  export interface GetScript {
    /**
     * Entity type: Script
     */
    ID?: number;
    IncludeEditabilityConfiguration?: boolean;
  }

  export interface GetScriptResponse {
    /**
     * Entity type: Script
     */
    ID?: number;
    Name?: string;
    Source?: string;
    Dialect?: string;
    IsActive?: boolean;
    Type?: string;
    RevisionComment?: string;
    IsPrivate?: boolean;
    EditabilityConfiguration?: ScriptEditabilityConfiguration;
    ProposedEdit?: ProposedScriptEdit;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Deletes a script
   */
  export interface DeleteScript {
    /**
     * Entity type: Script
     */
    ID?: number;
  }

  export interface DeleteScriptResponse {
    RequiresApproval: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Attempts to explain the given script in plain English.
   */
  export interface ExplainScript {
    Source?: string;
    Dialect?: string;
  }

  export interface ExplainScriptResponse {
    Description?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Returns all available dialects
   */
  export interface GetScriptDialects {
  }

  export interface GetScriptDialectsResponse {
    Dialects?: GetScriptDialectsResponse.Dialect[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetScriptDialectsResponse {
    export interface Dialect {
      Name?: string;
      Keywords?: string[];
      Types?: string[];
    }

  }

  export interface GetScriptExtensionPoints {
  }

  export interface GetScriptExtensionPointsResponse {
    ExtensionPoints?: GetScriptExtensionPointsResponse.ExtensionPoint[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetScriptExtensionPointsResponse {
    export interface ExtensionPoint {
      Name?: string;
    }

  }

  /**
   * Returns a list of revisions for a specific script.
   */
  export interface ListScriptHistory {
    /**
     * ID of the script
     * Entity type: Script
     */
    ID?: number;
    InitialPageConfig?: PageTokenConfig<ListScriptHistoryFilter>;
    PageToken?: string;
  }

  export interface ListScriptHistoryFilter {
  }

  export interface ListScriptHistoryResponse {
    Results?: ListScriptsItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Applies the provided edits to a script
   */
  export interface ApplyScriptEdits {
    /**
     * Entity type: Script
     */
    ID?: number;
    RevisionComment?: string;
    Edits?: EditableScriptElementValue[];
  }

  export interface EditableScriptElementValue {
    ID?: string;
    TableRows?: EditableScriptElementValue.TableRow[];
    Values?: any[];
  }

  export namespace EditableScriptElementValue {
    export interface TableRow {
      Values?: any[];
    }

  }

  /**
   * Approves or rejects a script proposal.
   */
  export interface ReviewScriptProposal {
    /**
     * Entity type: Script
     */
    ScriptID: number;
    Result: ReviewScriptProposalResults;
  }

  export const enum ReviewScriptProposalResults {
    Reject = 0,
    Accept = 1
  }

  /**
   * Create Recurring Task
   */
  export interface CreateRecurringTask {
    ID: string;
    FullName: string;
    Cron?: string;
    Arguments?: { [key: string]: string };
  }

  /**
   * Delete Recurring Task
   */
  export interface DeleteRecurringTask {
    ID?: string;
  }

  /**
   * Enqueue Task
   */
  export interface EnqueueTask {
    FullName?: string;
    Arguments?: { [key: string]: string };
  }

  /**
   * Get the logging of the run of a recurring task.
   */
  export interface GetRecurringTaskLogging {
    ID?: string;
    /**
     * ID of the run, if not specified, the last run will be used.
     */
    RunID?: string;
  }

  export interface GetRecurringTaskLoggingResponse {
    LogEntries: GetRecurringTaskLoggingResponse.LogEntry[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetRecurringTaskLoggingResponse {
    export interface LogEntry {
      Timestamp: string;
      Content: string;
    }

  }

  /**
   * Get the list of runs for a recurring task.
   */
  export interface GetRecurringTaskRuns {
    ID?: string;
  }

  export interface GetRecurringTaskRunsResponse {
    Runs: GetRecurringTaskRunsResponse.RecurringTaskRun[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetRecurringTaskRunsResponse {
    export interface RecurringTaskRun {
      RunID: string;
      StartTime: string;
      EndTime: string;
      IsSuccessful: boolean;
    }

  }

  /**
   * Lists all tasks that are able to be configured to run.
   */
  export interface ListAvailableRecurringTasks {
  }

  export interface ListAvailableRecurringTasksResponse {
    Tasks: ListAvailableRecurringTasksResponse.TaskPluginDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListAvailableRecurringTasksResponse {
    export interface TaskPluginDto {
      Name: string;
      FullName: string;
      Description: string;
      AvailableSettings: TaskPluginSettings[];
      DefaultName: string;
      DefaultCron: string;
    }

  }

  export interface TaskPluginSettings {
    /**
     * Type of the underlying parameter, e.g., 'OrganizationUnit'
     */
    DataModelType: string;
    /**
     * Data type of the parameter, e.g., 'long'.
     */
    Type: string;
    Key: string;
    Description: string;
    Required: boolean;
    Default: any;
  }

  /**
   * Lists all tasks that are scheduled recurringly.
   */
  export interface ListRecurringScheduledTasks {
    PageConfig?: PageConfig<ListRecurringScheduledTasks.Filter>;
  }

  export namespace ListRecurringScheduledTasks {
    export interface Filter {
      ID?: string;
      TypeName?: string;
      Query?: string;
      LastState?: string;
      LastStateID?: LastState;
    }

  }

  export const enum LastState {
    Unknown = 0,
    Succeeded = 1,
    Failed = 2
  }

  export interface ListRecurringScheduledTasksResponse {
    Result?: PagedResult<RecurringTask>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface RecurringTask {
    Cron: string;
    CronDisplay: string;
    ID: string;
    LastExecution?: string;
    NextExecution?: string;
    IsDeleted: boolean;
    Type: string;
    TypeName: string;
    Args: any[];
    LastStateID: LastState;
  }

  /**
   * Trigger Recurring Task
   */
  export interface TriggerRecurringTask {
    ID?: string;
  }

  export interface TriggerRecurringTaskResponse {
    JobId: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface UpdateRecurringTask {
    ID: string;
    /**
     * When provided will change the type of the task that is run.
     */
    FullName?: string;
    Cron: string;
    Arguments?: { [key: string]: string };
  }

  /**
   * Service for retrieving an list of `QuickBuy` options
   */
  export interface GetQuickBuyOptions {
    ProductProperties: string[];
  }

  export interface GetQuickBuyOptionsResponse {
    Options: GetQuickBuyOptionsResponse.QuickBuyOption[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetQuickBuyOptionsResponse {
    export interface QuickBuyOption {
      /**
       * Entity type: QuickBuy
       */
      ID: number;
      Name: string;
      Type: QuickBuyType;
      Products: any[];
    }

  }

  export const enum QuickBuyType {
    Checkout = 1,
    ShoppingCart = 2
  }

  /**
   * Service for creating a `QuickBuy`
   */
  export interface CreateQuickBuy {
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID: number;
    Type: QuickBuyType;
    Name: string;
  }

  export interface CreateQuickBuyResponse {
    /**
     * Entity type: QuickBuy
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for retrieving an existing `QuickBuy` by ID
   */
  export interface GetQuickBuy {
    /**
     * Entity type: QuickBuy
     */
    ID: number;
  }

  export interface GetQuickBuyResponse {
    /**
     * Entity type: QuickBuy
     */
    ID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID: number;
    Type: QuickBuyType;
    Name: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for retrieving an list of `QuickBuy`
   */
  export interface GetQuickBuys {
  }

  export interface GetQuickBuysResponse {
    Items: GetQuickBuysResponse.QuickBuyItem[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetQuickBuysResponse {
    export interface QuickBuyItem {
      /**
       * Entity type: QuickBuy
       */
      ID: number;
      /**
       * Entity type: OrganizationUnitSet
       */
      OrganizationUnitSetID: number;
      /**
       * Entity type: ProductSearchTemplate
       */
      ProductSearchTemplateID: number;
      Type: QuickBuyType;
      Name: string;
    }

  }

  /**
   * Service for updating an existing `QuickBuy` by ID
   */
  export interface UpdateQuickBuy {
    /**
     * Entity type: QuickBuy
     */
    ID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID: number;
    Type: QuickBuyType;
    Name: string;
  }

  /**
   * Service for deleting an existing `QuickBuy` by ID
   */
  export interface DeleteQuickBuy {
    /**
     * Entity type: QuickBuy
     */
    ID: number;
  }

  /**
   * Register an app for push notifications. This will register the device token for the given application identifier so the app can receive PushNotifications for the current User/OrganizationUnit.
   */
  export interface RegisterAppForNotifications {
    DeviceToken: string;
    /**
     * Application identifier: BundleID
     */
    BackendID: string;
    /**
     * Only fill when multiple apps on the same device are involved. Identifier that uniquely identifies the device where the app is running on. Should be the same for multiple apps on the same device.
     */
    DeviceID?: string;
  }

  /**
   * Add lines to an existing purchase order
   * 
   * It is required to supply an OrderID and at least one line with a ProductID and a Quantity. All other line properties are optional.
   * It's not allowed to create multiple lines with the same product on the same stocklabel.
   */
  export interface AddPurchaseOrderLines {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Lines: AddPurchaseOrderLines.Line[];
  }

  export namespace AddPurchaseOrderLines {
    export interface Line {
      /**
       * Entity type: Product
       */
      ProductID?: number;
      /**
       * Min: 1
       */
      Quantity?: number;
      UnitPrice?: number;
      RequestedDate?: string;
      Reference?: string;
      /**
       * Entity type: StockLabel
       */
      StockLabelID?: number;
      /**
       * The currency of the unit price. If not supplied, the order's currency will be used. The UnitPrice will be converted to the order's currency. If no exchangerate is available, the UnitPrice will be ignored and the price is fetched from an available pricelist.
       * Entity type: Currency
       */
      CurrencyID?: string;
    }

  }

  export interface AddPurchaseOrderLinesResponse {
    Result: AddPurchaseOrderLinesResponse.ResultLine[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace AddPurchaseOrderLinesResponse {
    export interface ResultLine {
      /**
       * Entity type: OrderLine
       */
      ID: number;
      /**
       * Entity type: Product
       */
      ProductID: number;
      Quantity: number;
      UnitPrice: number;
      RequestedDate?: string;
      Reference: string;
    }

  }

  /**
   * Confirms that specified Purchase Order will be delivered, identified by the `OrderID` parameter.
   * 
   * Optionally use the `BackendID` parameter to set the BackendID on the Purchase Order.
   */
  export interface ConfirmPurchaseOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    BackendID?: string;
  }

  /**
   * Creates a Purchase Order for supplied `OrganizationUnitID`, from optional `SupplierID`.
   * 
   * Use the `BackendID` to indicate the supplier order reference.
   */
  export interface CreatePurchaseOrder {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: OrganizationUnit
     */
    SupplierID?: number;
    BackendID?: string;
    AutomaticCancellationDate?: string;
    /**
     * Entity type: CustomOrderType
     */
    CustomOrderTypeID?: number;
    /**
     * Entity type: OrderCustomType
     */
    OrderCustomTypeID?: number;
  }

  export interface CreatePurchaseOrderResponse {
    /**
     * Entity type: Order
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Creates a shipment receipt with `Lines` for specified `ShipmentID`.
   * 
   * * `CompletesShipment` / `Lines.CompletesShipmentLine` will close the shipment (line) for futher receipts
   * * `Lines.QuantityReceived` is the delta quantity received in this receipt, so not the new total quantity received
   * * `StockLabelID` is the target StockLabel for the received stock - overrides the StockLabel of the purchase order line
   */
  export interface CreateShipmentReceipt {
    BackendID?: string;
    BackendSystemID?: string;
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    CompletesShipment?: boolean;
    Lines?: CreateShipmentReceipt.Line[];
  }

  export namespace CreateShipmentReceipt {
    export interface Line {
      /**
       * Entity type: ShipmentLine
       */
      ShipmentLineID: number;
      /**
       * Entity type: StockLabel
       */
      StockLabelID?: number;
      QuantityReceived: number;
      CompletesShipmentLine?: boolean;
    }

  }

  export interface CreateShipmentReceiptResponse {
    /**
     * Entity type: ShipmentReceipt
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Receives a shipment completely as-is. Supply either `ID` or `BackendID`.
   */
  export interface FullyReceiveShipment {
    /**
     * Entity type: Shipment
     */
    ID?: number;
    BackendID?: string;
  }

  export interface FullyReceiveShipmentResponse {
    ReservedOrdersCount: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface FullyShipPurchaseOrder {
    /**
     * Entity type: Order
     */
    PurchaseOrderID: number;
    ShipmentBackendID?: string;
    BackendSystemID?: string;
    TrackingCode?: string;
    /**
     * The OrganizationUnit the shipment was physically shipped from.
     * Entity type: OrganizationUnit
     */
    ShippedFromOrganizationUnitID?: number;
  }

  /**
   * Get the supplier product info for a set of product IDs (not supplier product IDs) and the optional supplier OU.
   */
  export interface GetProductSupplierInfoForProducts {
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export interface GetProductSupplierInfoForProductsResponse {
    ProductSupplierInfos: GetProductSupplierInfoForProductsResponse.ProductSupplierInfo[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetProductSupplierInfoForProductsResponse {
    export interface ProductSupplierInfo {
      ProductID: number;
      BackendID: string;
      SupplierProductID: number;
      SupplierProductBackendID: string;
      PreferredMinimumOrderQuantity?: number;
      UnitCost: number;
      Supplier: GetProductSupplierInfoForProductsResponse.Supplier;
      UnitOfMeasures: GetProductSupplierInfoForProductsResponse.UnitOfMeasure[];
      Barcodes: GetProductSupplierInfoForProductsResponse.Barcode[];
    }

    export interface UnitOfMeasure {
      ID: number;
      Name: string;
      Quantity: number;
    }

    export interface Supplier {
      ID: number;
      BackendID: string;
      Name: string;
    }

    export interface Barcode {
      Code: string;
      UnitOfMeasureID: number;
      Quantity: number;
    }

  }

  /**
   * Get details of a shipment to receive, either by `ID` or by `BackendID`/`OrganizationUnitID` combination.
   */
  export interface GetShipmentDetails {
    /**
     * Entity type: Shipment
     */
    ID?: number;
    BackendID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export interface GetShipmentDetailsResponse {
    ReceiveMethod: ShipmentReceiveMethods;
    IsCompleted: boolean;
    WorkSet: ReceiveShipmentWorkSet;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    ShippedTo: GetShipmentDetailsResponse.ShipOrganizationUnitDetails;
    ShippedFrom: GetShipmentDetailsResponse.ShipOrganizationUnitDetails;
    TrackingCode?: string;
    ShipmentDate?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetShipmentDetailsResponse {
    export interface ShipOrganizationUnitDetails {
      ID: number;
      Name: string;
    }

  }

  export interface ReceiveShipmentWorkSet {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
    BackendID: string;
    BackendSystemID: string;
    /**
     * Entity type: OrganizationUnit
     */
    ShippedToOrganizationUnitID: number;
    /**
     * Entity type: OrganizationUnit
     */
    ShippedFromOrganizationUnitID?: number;
    ReceiveMethod: ShipmentReceiveMethods;
    Lines: ReceiveShipmentWorkSetLine[];
    Orders: GetShipmentDetailsOrder[];
  }

  export interface ReceiveShipmentWorkSetLine {
    /**
     * Entity type: Product
     */
    ProductID: number;
    ProductBackendID?: string;
    ProductPrimitiveName: string;
    ProductCustomID: string;
    ProductDetails?: any;
    QuantityOrdered: number;
    QuantityAlreadyReceived: number;
    QuantityShipped: number;
    NetQuantityShipped: number;
    NetQuantityDelivered: number;
    SerialNumbers?: string[];
    ReceivedSerialNumbers?: string[];
    SerialNumberRequired: boolean;
    SerialNumberConfigurationID?: number;
    Receipts: ReceiveShipmentWorkSetLineReceipt[];
    Packages: ReceiveShipmentWorkSetLinePackage[];
  }

  export interface ReceiveShipmentWorkSetLineReceipt {
    QuantityReceived: number;
    /**
     * Entity type: ShipmentLine
     */
    ShipmentLineID: number;
  }

  export interface ReceiveShipmentWorkSetLinePackage {
    UnitOfMeasure: string;
    Barcode: string;
    Quantity: number;
    QuantityBarcode: number;
    QuantityTotal: number;
  }

  export interface GetShipmentDetailsOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    OrderDisplayID?: string;
    BackendID: string;
    CustomerReference: string;
  }

  /**
   * Get an existing ShipmentReceipt
   */
  export interface GetShipmentReceipt {
    /**
     * Entity type: ShipmentReceipt
     */
    ShipmentReceiptID: number;
  }

  export interface GetShipmentReceiptResponse {
    /**
     * Entity type: ShipmentReceipt
     */
    ID: number;
    BackendID?: string;
    BackendSystemID?: string;
    TotalQuantityReceived: number;
    Lines: GetShipmentReceiptResponse.LineDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetShipmentReceiptResponse {
    export interface LineDto {
      QuantityReceived: number;
      ShipmentLine: LineDto.ShipmentLineDto;
      StockLabel: EnumDto;
    }

    export namespace LineDto {
      export interface ShipmentLineDto {
        /**
         * Entity type: Order
         */
        OrderID: number;
        /**
         * Entity type: OrderLine
         */
        OrderLineID: number;
        QuantityShipped: number;
        QuantityDelivered: number;
        BackendReference?: string;
        DeliveryType: ShipmentLineDeliveryTypes;
      }

    }

  }

  /**
   * Modify Purchase Order Line
   */
  export interface ModifyPurchaseOrderLine {
    /**
     * Entity type: OrderLine
     */
    ID: number;
    /**
     * Min: 0
     */
    Quantity?: number;
    UnitPrice?: number;
    RequestedDate?: string;
    Reference?: string;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
  }

  /**
   * Raise Purchase Order Imported Event
   */
  export interface RaisePurchaseOrderImportedEvent {
    /**
     * Entity type: Order
     */
    PurchaseOrderID?: number;
    BackendID?: string;
    BackendSystemID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    ShipToOrganizationUnitID?: number;
  }

  /**
   * Receive (part of) a Shipment for a PurchaseOrder.
   * 
   * A ShipmentID is required.
   * 
   * When doing partial receipts it is strongly advised to supply a BackendSystemID and BackendID to make sure Receipts are not created twice.
   * 
   * To do partial receipts the FinalShipment property should be set to false, otherwise the shipment will be close afterwards and the remaining lines will be booked as missing.
   * 
   * When available it is preferred to identify the ShipmentLines with the ShipmentLineID and not with the ProductID.
   */
  export interface ReceivePurchaseOrderShipment {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
    BackendSystemID?: string;
    BackendID?: string;
    /**
     * If passed in as true this will close the shipment for further receipts.
     */
    CompleteShipment?: boolean;
    Lines: ReceivePurchaseOrderShipment.Line[];
  }

  export namespace ReceivePurchaseOrderShipment {
    export interface Line {
      /**
       * Entity type: ShipmentLine
       */
      ShipmentLineID?: number;
      /**
       * Entity type: Product
       */
      ProductID?: number;
      QuantityReceived: number;
      /**
       * The serial numbers to receive.
       */
      SerialNumbers?: string[];
    }

  }

  export interface ReceivePurchaseOrderShipmentResponse {
    /**
     * Entity type: ShipmentReceipt
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Receive a shipment.
   */
  export interface ReceiveShipment {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
    CompleteShipment?: boolean;
    /**
     * The receipts to create. If left null, it's assumed you wish to receive the entire shipment. If left empty, it's assumed you wish to receive nothing.
     */
    Receipts?: ReceiveShipment.ShipmentReceipt[];
    /**
     * Receipts for products that are not present in the shipment. This can only be used for products that are not declard in the shipment.
     */
    UndeclaredProductsReceipts?: ReceiveShipment.ProductReceipt[];
    /**
     * @deprecated Use `Receipts` instead.
     */
    Lines?: ReceiveShipment.Line[];
  }

  export namespace ReceiveShipment {
    export interface ShipmentReceipt {
      /**
       * The quantity to receive. If left null, the quantity not yet received will be used.
       */
      QuantityReceived?: number;
      /**
       * The serial numbers to receive.
       */
      SerialNumbers?: string[];
      /**
       * The shipment line to receive.
       * Entity type: ShipmentLine
       */
      ShipmentLineID: number;
    }

    export interface ProductReceipt {
      /**
       * The quantity to receive.
       */
      QuantityReceived: number;
      /**
       * The product to receive. This can only be a product that is not in the shipment.
       * Entity type: Product
       */
      ProductID: number;
      /**
       * The serial numbers to receive.
       */
      SerialNumbers?: string[];
    }

    export interface Line {
      /**
       * Entity type: Product
       */
      ProductID: number;
      Receipts?: Line.Receipt[];
    }

    export namespace Line {
      export interface Receipt {
        QuantityReceived: number;
      }

    }

  }

  /**
   * Creates a shipment for given purchase order lines and ships it!
   */
  export interface ShipPurchaseOrder {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    BackendID?: string;
    TrackingCode?: string;
    ShipmentDate?: string;
    Lines?: ShipPurchaseOrderLine[];
    /**
     * The OrganizationUnit the shipment was physically shipped from.
     * Entity type: OrganizationUnit
     */
    ShippedFromOrganizationUnitID?: number;
  }

  export interface ShipPurchaseOrderLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Min: 1
     */
    QuantityToShip: number;
    /**
     * Serial numbers for the items being shipped.
     */
    SerialNumbers?: string[];
  }

  export interface ShipPurchaseOrderResponse {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Creates a purchase order (or updates it if it already exists).
   * 
   * When the order already exists, only the lines can be updated (see `SupplierUpdatePurchaseOrder`) - other properties will be ignored.
   * 
   * :lightbulb: Using `SupplierCreateOrder` and `SupplierUpdatePurchaseOrder` is preferred.
   */
  export interface SupplierCreateOrUpdatePurchaseOrder {
    /**
     * OrganizationUnit who will be supplying the stock.
     * Entity type: OrganizationUnit
     */
    ShipFromOrganizationUnitID: number;
    /**
     * OrganizationUnit that will be receiving the purchase order shipment(s).
     * Entity type: OrganizationUnit
     */
    ShipToOrganizationUnitID: number;
    /**
     * Identifer of the order from the 3rd party
     */
    BackendID: string;
    /**
     * Identifier of the 3rd party system that created the order
     */
    BackendSystemID?: string;
    /**
     * Date that the supplier expects to deliver the shipment(s) of the purchase order
     */
    ExpectedDeliveryDate?: string;
    CustomFields?: { [key: string]: any };
    /**
     * Ship the order immediately after creation. Order won't be shipped again after an update.
     */
    Ship?: boolean;
    /**
     * BackendID of the shipment to be created. Works only if `Ship` is set to true. Make sure this is unique.
     */
    ShipmentBackendID?: string;
    /**
     * Receive the order immediately after shipping, works only if `Ship` is set to true
     */
    Receive?: boolean;
    /**
     * Contents of the purchase order.
     */
    Lines: SupplierCreateOrUpdatePurchaseOrder.SupplierCreateOrUpdatePurchaseOrderLine[];
    /**
     * Identifiers to set on the shipment if any. Works only if `Ship` is set to true.
     */
    ShipmentIdentifiers?: SupplierCreateOrUpdatePurchaseOrder.SupplierCreateOrUpdatePurchaseOrderShipmentIdentifier[];
  }

  export namespace SupplierCreateOrUpdatePurchaseOrder {
    export interface SupplierCreateOrUpdatePurchaseOrderShipmentIdentifier {
      /**
       * Entity type: ShipmentIdentifier
       */
      ShipmentIdentifierID: number;
      Value: string;
    }

    export interface SupplierCreateOrUpdatePurchaseOrderLine {
      /**
       * Identifier of the product
       * Entity type: Product
       */
      ProductID?: number;
      /**
       * Quantity that is expected to be shipped
       */
      Quantity?: number;
      UnitPrice?: number;
      /**
       * The currency of the unit price. If not supplied, the order's currency will be used. The UnitPrice will be converted to the order's currency. If no exchangerate is available, the UnitPrice will be ignored and the price is fetched from an available pricelist.
       * Entity type: Currency
       */
      CurrencyID?: string;
      /**
       * The BackendReference of the line to create. Note that multiple lines with the same product are merged into a single line so the chosen BackendReference is arbitrary.
       */
      BackendReference?: string;
      /**
       * Date that the supplier expects to deliver this orderline. If you supply multiple lines with the same ProductID, we only take the latest date.
       */
      ExpectedDeliveryDate?: string;
    }

  }

  export interface CreatePurchaseOrderResponseWithUpdateIndicator {
    IsUpdated: boolean;
    IsCreated: boolean;
    /**
     * Entity type: Order
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface SupplierCreatePurchaseOrder {
    /**
     * Identifier of the 3rd party system that created the order
     */
    BackendSystemID?: string;
    /**
     * Identifier of the order from the 3rd party
     */
    BackendID?: string;
    /**
     * OrganizationUnit who will be supplying the stock.
     * Entity type: OrganizationUnit
     */
    ShipFromOrganizationUnitID: number;
    /**
     * OrganizationUnit that will be receiving the purchase order shipment(s).
     * Entity type: OrganizationUnit
     */
    ShipToOrganizationUnitID: number;
    /**
     * Date that the supplier expects to deliver the shipment(s) of the purchase order. Can also be specified on the line level. If specified on both levels, the line level will take precedence.
     */
    ExpectedDeliveryDate?: string;
    CustomFields?: { [key: string]: any };
    /**
     * Ship the order immediately after creation.
     */
    Ship?: boolean;
    /**
     * List of shipment identifiers to attach to the shipment. This only works if `Ship` is set to true.
     */
    ShipmentIdentifiers?: SupplierCreatePurchaseOrder.SupplierCreatePurchaseOrderShipmentIdentifier[];
    /**
     * BackendID of the shipment to be created. Works only if `Ship` is set to true. Make sure this is unique.
     */
    ShipmentBackendID?: string;
    /**
     * Copy the orderlines backendreference to the shipmentlines backendreference, works only if `Ship` is set to true
     */
    CopyBackendReferenceOnShip?: boolean;
    /**
     * Receive the order immediately after shipping, works only if `Ship` is set to true
     */
    Receive?: boolean;
    /**
     * Contents of the purchase order.
     * Note: Only one key property can be used to identify the product. When different properties are used, the request will be invalid.
     * This will become redundant when ProductID is the only property left.
     */
    Lines: SupplierCreatePurchaseOrder.SupplierCreatePurchaseOrderBatchableLine[];
  }

  export namespace SupplierCreatePurchaseOrder {
    export interface SupplierCreatePurchaseOrderShipmentIdentifier {
      /**
       * Entity type: ShipmentIdentifier
       */
      ShipmentIdentifierID: number;
      Value: string;
    }

    export interface SupplierCreatePurchaseOrderBatchableLine {
      /**
       * Identifier of the product
       * Entity type: Product
       */
      ProductID: number;
      /**
       * Quantity that is expected to be shipped
       */
      Quantity: number;
      /**
       * Date that the supplier expects to deliver this orderline. If you supply multiple lines with the same ProductID, we only take the latest date.
       */
      ExpectedDeliveryDate?: string;
      UnitPrice?: number;
      /**
       * The currency of the unit price. If not supplied, the order's currency will be used. The UnitPrice will be converted to the order's currency. If no exchangerate is available, the UnitPrice will be ignored and the price is fetched from an available pricelist.
       * Entity type: Currency
       */
      CurrencyID?: string;
      /**
       * The BackendReference of the line to create
       */
      BackendReference: string;
    }

  }

  /**
   * Ships a Purchase Order with specified lines. Supply either `ID` or a `BackendID`/`BackendSystemID` combination to
   * identify the order.
   * 
   * If you wish to receive on behalf of a different organization, identify that organization by specifying a
   * `ShipToOrganizationUnitBackendID`. Should this organization reside in a different cluster, this call will be proxied
   * to that cluster for you.
   */
  export interface SupplierShipPurchaseOrder {
    /**
     * Entity type: Order
     */
    ID?: number;
    BackendID?: string;
    BackendSystemID?: string;
    /**
     * @deprecated This is determined on the purchase order, shipment can't deviate from it.
     */
    ShipToOrganizationUnitBackendID?: string;
    ExpectedDeliveryDate?: string;
    Confirmations: SupplierShipPurchaseOrderConfirmation[];
  }

  export interface SupplierShipPurchaseOrderConfirmation {
    BackendID: string;
    TrackingCode?: string;
    TrackingLink?: string;
    ExpectedDeliveryDate?: string;
    Lines: SupplierShipPurchaseOrderConfirmationLine[];
    CustomFieldsByBackendID?: { [key: string]: CustomFieldValue };
    ShipmentIdentifiers?: SupplierShipPurchaseOrderShipmentIdentifier[];
  }

  export interface SupplierShipPurchaseOrderConfirmationLine {
    /**
     * Identifier of the product
     */
    BackendID?: string;
    /**
     * Please use `BackendID`
     */
    CustomID?: string;
    /**
     * Please use `BackendID`
     */
    Barcode?: string;
    Quantity: number;
    SerialNumbers?: string[];
    BatchCode?: string;
    ExpiryDate?: string;
  }

  export interface SupplierShipPurchaseOrderShipmentIdentifier {
    /**
     * Entity type: ShipmentIdentifier
     */
    ShipmentIdentifierID: number;
    Value: string;
  }

  export interface SupplierUpdatePurchaseOrder {
    /**
     * Identifier of the 3rd party system that created the order
     */
    BackendSystemID?: string;
    /**
     * Identifier of the order from the 3rd party
     */
    BackendID?: string;
    /**
     * OrganizationUnit that will be receiving the purchase order shipment(s).
     * Entity type: OrganizationUnit
     */
    ShipToOrganizationUnitID?: number;
    /**
     * Contents of the purchase order.
     * Note: Only one key property can be used to identify the product. When different properties are used, the request will be invalid.
     * This will become redundant when ProductID is the only property left.
     */
    Lines: SupplierUpdatePurchaseOrder.SupplierUpdatePurchaseOrderLine[];
  }

  export namespace SupplierUpdatePurchaseOrder {
    export interface SupplierUpdatePurchaseOrderLine {
      /**
       * Identifier of the product
       * Entity type: Product
       */
      ProductID: number;
      /**
       * Quantity that is expected to be shipped
       */
      Quantity: number;
      /**
       * Date that the supplier expects to deliver this orderline. If you supply multiple lines with the same ProductID, we only take the latest date.
       */
      ExpectedDeliveryDate?: string;
      UnitPrice?: number;
      /**
       * The currency of the unit price. If not supplied, the order's currency will be used. The UnitPrice will be converted to the order's currency. If no exchangerate is available, the UnitPrice will be ignored and the price is fetched from an available pricelist.
       * Entity type: Currency
       */
      CurrencyID?: string;
      /**
       * The BackendReference of the line to create
       */
      BackendReference: string;
    }

  }

  /**
   * The normal `AddProductToOrder` cannot be used for adding a Product with type `SubscriptionProduct` to an order. Instead this service must be used.
   */
  export interface AddSubscriptionProductToOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Product
     */
    SubscriptionProductID: number;
    /**
     * Entity type: Product
     */
    TriggerProductID?: number;
  }

  export interface AddSubscriptionProductToOrderResponse {
    /**
     * Created or updated OrderLineID
     * Entity type: OrderLine
     */
    OrderLineID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * This service returns the subscriptions for which you currently have at least one trigger product in the provided order.
   * This can then be used to suggest subscriptions to the end-user that they're missing out on.
   * 
   * The IncludedFields field controls which product content you get back for each subscription product. By default, only the product's display value is returned.
   * 
   * Specifying the ProductIDs field means that only suggestions for the given products are returned.
   * If the Order does not contain the provided ProductIDs, nothing will be returned.
   */
  export interface GetPotentialSubscriptionProductsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
  }

  export interface GetPotentialSubscriptionProductsForOrderResponse {
    Result: GetPotentialSubscriptionProductsForOrderResponse.SubscriptionProduct[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetPotentialSubscriptionProductsForOrderResponse {
    export interface SubscriptionProduct {
      /**
       * Entity type: Product
       */
      SubscriptionProductID: number;
      Content: any;
      Pricing: SubscriptionProductPriceInfo;
      Name: string;
      Description?: string;
      Interval: ProductSubscriptionInterval;
      IsActive: boolean;
      /**
       * Entity type: Product
       */
      TriggerProductIDs: number[];
      ShowModal: boolean;
    }

  }

  export interface SubscriptionProductPriceInfo {
    UnitPrice: number;
    UnitPriceInTax: number;
    OriginalUnitPrice?: number;
    OriginalUnitPriceInTax?: number;
    TaxRate: number;
    CurrencyID: string;
  }

  export const enum ProductSubscriptionInterval {
    Weekly = 2,
    Monthly = 3,
    Quarterly = 4,
    Yearly = 5,
    Manual = 99999
  }

  /**
   * Get all ProductSubscriptions for a User.
   */
  export interface GetProductSubscriptionsForUser {
    /**
     * Entity type: User
     */
    UserID?: number;
  }

  export interface GetProductSubscriptionsForUserResponse {
    Subscriptions: UserProductSubscriptionDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface UserProductSubscriptionDto {
    /**
     * Entity type: UserProductSubscription
     */
    ID: number;
    /**
     * Entity type: ProductSubscription
     */
    SubscriptionID: number;
    Name: string;
    Description?: string;
    /**
     * Entity type: Product
     */
    SubscriptionProductID: number;
    Status: ProductSubscriptionStatus;
    Interval: ProductSubscriptionInterval;
    Price: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    RenewalDate?: string;
    Discount?: UserProductSubscriptionDiscountDto;
  }

  export const enum ProductSubscriptionStatus {
    Active = 0,
    Paused = 1,
    Stopped = 2,
    PaymentFailed = 3
  }

  export interface UserProductSubscriptionDiscountDto {
    /**
     * Entity type: Discount
     */
    ID?: number;
    MarketingDescription?: string;
    Description?: string;
  }

  /**
   * Get all the details for a specifc user product subscription.
   */
  export interface GetUserProductSubscriptionDetails {
    /**
     * Entity type: UserProductSubscription
     */
    ID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface GetUserProductSubscriptionDetailsResponse {
    Name: string;
    Description?: string;
    Status: ProductSubscriptionStatus;
    Interval: ProductSubscriptionInterval;
    Price: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    RenewalDate?: string;
    /**
     * Entity type: Product
     */
    SubscriptionProductID: number;
    /**
     * Entity type: Product
     */
    TriggerProductID?: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
    BillingAddress: AddressDataDto;
    ShippingAddress?: AddressDataDto;
    SubscriptionProductContent: any;
    TriggerProductContent?: any;
    Discount?: UserProductSubscriptionDiscountDto;
    Ledger: UserProductSubscriptionLedgerDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface UserProductSubscriptionLedgerDto {
    Type: UserProductSubscriptionLedgerTypes;
    OldValue: string;
    NewValue: string;
    CreationTime: string;
  }

  export const enum UserProductSubscriptionLedgerTypes {
    Status = 1,
    PaymentTransaction = 2,
    OrderGenerated = 3,
    PaymentFailed = 4,
    Renewed = 5
  }

  /**
   * Gets the details of a subscription by its ProductID. The input to this service is `SubscriptionProductID` which refers to the ID
   * of a `Product` that has `Type` = `SubscriptionProduct`.
   * 
   * The `IncludedFields` parameter is optional and allows you to specify which fields you wish to get back from this service.
   */
  export interface GetSubscriptionProductDetails {
    /**
     * Entity type: Product
     */
    SubscriptionProductID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface GetSubscriptionProductDetailResponse {
    /**
     * Entity type: Product
     */
    SubscriptionProductID: number;
    Content: any;
    Pricing: SubscriptionProductPriceInfo;
    Name: string;
    Description?: string;
    Interval: ProductSubscriptionInterval;
    IsActive: boolean;
    /**
     * Entity type: Product
     */
    TriggerProductIDs: number[];
    IsDeleted: boolean;
    ShowModal: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * This service returns a list of subscription products that have the `ProductID` as trigger product.
   * The service is meant to be used on a product detail page as a "these subscriptions are available for this product" component.
   * The request allows you to specify what data you'd like to get back from the subscription product, through the `IncludedFields` field.
   */
  export interface GetTriggeredSubscriptionProductsForProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface GetTriggeredSubscriptionProductsForProductResponse {
    Result: TriggeredSubscriptionProduct[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface TriggeredSubscriptionProduct {
    /**
     * Entity type: Product
     */
    SubscriptionProductID: number;
    Content: any;
    Pricing: SubscriptionProductPriceInfo;
    Name: string;
    Description?: string;
    Interval: ProductSubscriptionInterval;
    IsActive: boolean;
    /**
     * Entity type: Product
     */
    TriggerProductIDs: number[];
    ShowModal: boolean;
  }

  /**
   * Cancel a ProductSubscription for a User.
   */
  export interface CancelProductSubscriptionForUser {
    /**
     * Entity type: UserProductSubscription
     */
    ID: number;
  }

  /**
   * Resume a ProductSubscription for a User.
   */
  export interface ResumeProductSubscriptionForUser {
    /**
     * Entity type: UserProductSubscription
     */
    ID: number;
  }

  /**
   * Pause a ProductSubscription for a User.
   */
  export interface PauseProductSubscriptionForUser {
    /**
     * Entity type: UserProductSubscription
     */
    ID: number;
  }

  /**
   * Renew a Manual ProductSubscription. Only available during testing
   */
  export interface RenewProductSubscription {
    /**
     * Entity type: UserProductSubscription
     */
    ID: number;
  }

  /**
   * Update the addresses of a UserProductSubscription, these are used for renewals.
   */
  export interface UpdateUserProductSubscriptionAddresses {
    /**
     * Entity type: UserProductSubscription
     */
    UserProductSubscriptionID?: number;
    UseDefaultsFromCustomer?: boolean;
    ShippingAddress?: AddressDataDto;
    BillingAddress?: AddressDataDto;
  }

  /**
   * Generate an Order to update the payment of a UserProductSubscription
   */
  export interface UpdateUserProductSubscriptionPayment {
    /**
     * Entity type: UserProductSubscription
     */
    UserProductSubscriptionID: number;
  }

  export interface UpdateUserProductSubscriptionPaymentResponse {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get Configurable Product Detail
   */
  export interface GetConfigurableProductDetail {
    /**
     * Entity type: Product
     */
    ID?: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
    Filter?: ConfigurableProductDetailFilter;
    ApplySearchFilters?: boolean;
  }

  export interface ConfigurableProductDetailFilter {
    Properties: ConfigurableProductDetailFilterProperty[];
    HideUnmatched: boolean;
  }

  export interface ConfigurableProductDetailFilterProperty {
    Property: string;
    Values: any[];
  }

  export interface GetConfigurableProductDetailResponse {
    Configurable: ConfigurableProductDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ConfigurableProductDto {
    /**
     * Entity type: Product
     */
    ProductID: number;
    Type: ProductTypes;
    Status: ProductStatus;
    LogicalLevel: string;
    ConfigurableProperty: string;
    ConfigurablePropertyDisplayName: string;
    MatchesFilter?: boolean;
    Value: any;
    Values: any[];
    Children: ConfigurableProductDto[];
    Properties: any;
    HasDimensions: boolean;
    VariationIndex?: number;
  }

  /**
   * Get Configurable Products Detail
   */
  export interface GetConfigurableProductsDetail {
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
    ApplySearchFilters?: boolean;
  }

  export interface GetConfigurableProductsDetailResponse {
    /**
     * Entity type: Product
     */
    Configurables: { [key: number]: ConfigurableProductDto };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Returns a list of greeting cards. This is limited to 25 cards.
   */
  export interface GetGreetingCards {
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface GetGreetingCardsResponse {
    Products: any[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get product details by id
   */
  export interface GetProductDetail {
    /**
     * Entity type: Product
     */
    ID: number;
  }

  export interface GetProductDetailResponse {
    Result: any;
    IsPartOfBundle: boolean;
    HasSubscriptions: boolean;
    Relations?: ProductRelationDTO[];
    /**
     * Entity type: SerialNumberConfiguration
     */
    SerialNumberConfigurationID?: number;
    /**
     * Stock products that are part of this stock aggregate product. Only returned if the request product is a stock aggregate.
     */
    StockProducts: GetProductDetailResponse.StockProduct[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetProductDetailResponse {
    export interface StockProduct {
      /**
       * Entity type: Product
       */
      ID: number;
      /**
       * Entity type: Product
       */
      BackendID: string;
      Barcodes: string[];
    }

  }

  export interface ProductRelationDTO {
    /**
     * Entity type: ProductRelationType
     */
    ProductRelationTypeID?: number;
    ProductRelationTypeBackendID?: string;
    PrimaryName?: string;
    SecondaryName?: string;
    Direction?: ProductRelationDirection;
    StockRelationType?: StockRelationType;
    /**
     * Entity type: Product
     */
    PrimaryProductIDs?: number[];
    /**
     * Entity type: Product
     */
    RelatedProductIDs?: number[];
    Sequence?: number;
  }

  export const enum ProductRelationDirection {
    Unidirectional = 0,
    Bidirectional = 1,
    Group = 2
  }

  export const enum StockRelationType {
    None = 0,
    Replacing = 1
  }

  /**
   * This service is used to list prices associated with the products determined by IDs.
   * 
   * Price - this value has TaxRate applied
   * PriceInTax - value without TaxRate
   * 
   * A product has more associated prices with different usage types, e.g. Cost, Sales..
   * 
   * Request e.g.:
   * {
   *   "ProductIDs": [
   *     "productId1",
   *     "productId2"
   *   ]
   * }
   */
  export interface GetProductPrices {
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    TargetOrganizationUnitID?: number;
    /**
     * Entity type: User
     */
    UserID?: number;
  }

  export interface GetProductPricesResponse {
    Prices: PriceInfo[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface PriceInfo {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: PriceList
     */
    PriceListID: number;
    /**
     * Entity type: PriceListUsageType
     */
    PriceListUsageTypeID: number;
    PriceListUsageTypeName: string;
    CurrencyID: string;
    TaxRate: number;
    Price: number;
    PriceInTax: number;
    HistoricalPrice?: number;
    HistoricalPriceInTax?: number;
  }

  /**
   * Get Product Pricing
   */
  export interface GetProductPricing {
    /**
     * Entity type: Product
     */
    ProductID: number;
  }

  export interface GetProductPricingResponse {
    UnitPrice: number;
    OriginalUnitPrice?: number;
    TaxRate: number;
    UnitPriceInTax: number;
    OriginalUnitPriceInTax?: number;
    CurrencyID: string;
    UnitCost?: number;
    CostPriceCurrencyID: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get product relations by product id
   */
  export interface GetProductRelations {
    /**
     * Entity type: Product
     */
    ID: number;
  }

  export interface GetProductRelationsResponse {
    Relations?: ProductRelationDTO[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get Product Search Suggestions
   */
  export interface GetProductSearchSuggestions {
    Text?: string;
    MaxSuggestions?: number;
  }

  export interface GetProductSearchSuggestionsResponse {
    Suggestions: SuggestionModel[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface SuggestionModel {
    Score: number;
    Text: string;
    Payload: { [key: string]: any };
  }

  /**
   * Fetch one or more products by ID.
   */
  export interface GetProducts {
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields: string[];
  }

  export interface GetProductsResponse {
    /**
     * Entity type: Product
     */
    Products: { [key: number]: any };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Fetch available units of measure for the provided products and their quantities.
   */
  export interface GetProductUnitOfMeasureQuantities {
    Products?: GetProductUnitOfMeasureQuantities.Model[];
  }

  export namespace GetProductUnitOfMeasureQuantities {
    export interface Model {
      /**
       * Entity type: Product
       */
      ID: number;
      Quantity: number;
    }

  }

  export interface GetProductUnitOfMeasureQuantitiesResponse {
    Results: GetProductUnitOfMeasureQuantitiesResponse.Model[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetProductUnitOfMeasureQuantitiesResponse {
    export interface Model {
      /**
       * Entity type: Product
       */
      ProductID: number;
      UnitOfMeasures: GetProductUnitOfMeasureQuantitiesResponse.Result[];
    }

    export interface Result {
      Value: EnumDto;
      Quantity: number;
    }

  }

  /**
   * Get product warranty information by making a request to an endpoint set with the 'Product:WarrantyEndpoint' setting.
   * 
   * If 'SerialNumber' is not set in the request, we'll try to get it using the 'OrderLineID', so at least one or the other must be present and valid.
   */
  export interface GetProductWarranty {
    /**
     * This or 'OrderLineID' needed for search
     */
    SerialNumber?: string;
    /**
     * This or 'SerialNumber' needed for search
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    OrderDate?: string;
  }

  export interface GetProductWarrantyResponse {
    IsUnderWarranty: boolean;
    WarrantyExpiryDate?: string;
    ManufacturerWarrantyExpiryDate?: string;
    AdditionalInfo: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListBrands {
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListBrandsResponse {
    Result?: PagedResult<ListBrandsResponse.BrandDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListBrandsResponse {
    export interface BrandDto {
      ID: number;
      Name: string;
      BackendID: string;
    }

  }

  /**
   * This service is used to print labels containing the price details of one product
   */
  export interface PrintProductPriceLabel {
    /**
     * The ID of the product
     * Entity type: Product
     */
    ID: number;
    /**
     * How many copies of the price label should be printed
     * Range: 1-999
     */
    Quantity: number;
    /**
     * ID of the printer where the label(s) will be printed
     * Entity type: Station
     */
    StationID?: number;
  }

  export interface PrintProductPriceLabelResponse {
    Success: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * List all ProductRequirement values for an OrderLine
   */
  export interface GetProductRequirementValuesForOrderLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
  }

  export interface GetProductRequirementValuesForOrderLineResponse {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    ProductPrimitiveName: string;
    /**
     * Entity type: ProductRequirement
     */
    Requirements?: { [key: number]: any };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * List all ProductRequirement values for an Order
   */
  export interface GetProductRequirementValuesForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetProductRequirementValuesForOrderResponse {
    Requirements: GetProductRequirementValuesForOrderResponse.ProductRequirement[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetProductRequirementValuesForOrderResponse {
    export interface ProductRequirement {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      /**
       * Entity type: Product
       */
      ProductID: number;
      ProductPrimitiveName: string;
      /**
       * Entity type: ProductRequirement
       */
      Requirements?: { [key: number]: any };
    }

  }

  /**
   * Replace the given ProductRequirement values for an OrderLine with new values
   */
  export interface UpdateProductRequirementValuesForOrderLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Entity type: ProductRequirement
     */
    Values?: { [key: number]: any };
  }

  /**
   * Retrieve the structure of products by `Code` (and for given `LanguageID`/`CountryID`).
   */
  export interface GetProductStructure {
    Code?: string;
    LanguageID?: string;
    CountryID?: string;
  }

  export interface GetProductStructureResponse {
    ID: number;
    Code: string;
    Name: string;
    LanguageID: string;
    CountryID: string;
    Definition: ProductStructureDefinition;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ProductStructureDefinition {
    Name: string;
    Filters: { [key: string]: FilterModel };
    Children: ProductStructureDefinition[];
  }

  export interface FilterModel {
    Values?: any[];
    From?: string;
    To?: string;
    /**
     * @default false
     */
    Negation?: boolean;
    /**
     * @default false
     */
    ExactMatch?: boolean;
    IncludeMissing?: boolean;
  }

  /**
   * Create a new structure of products.
   */
  export interface CreateProductStructure {
    Code: string;
    Name: string;
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    Definition?: ProductStructureDefinition;
  }

  export interface CreateProductStructureResponse {
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Edits an existing structure of products by `ID`.
   */
  export interface EditProductStructure {
    /**
     * Entity type: ProductStructure
     */
    ID: number;
    Code: string;
    Name: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    Definition?: ProductStructureDefinition;
  }

  export interface EditProductStructureResponse {
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Deletes an existing structure of products by `ID`.
   */
  export interface DeleteProductStructure {
    /**
     * Entity type: ProductStructure
     */
    ID: number;
  }

  /**
   * List product structures.
   */
  export interface ListProductStructures {
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListProductStructuresResponse {
    Result?: PagedResult<GetProductStructureResponse>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Resolve product backend IDs
   */
  export interface ResolveProductBackendIDs {
    BackendIDs: string[];
  }

  export interface ResolveProductBackendIDsResponse {
    ResolvedBackendIDs: { [key: string]: number };
    UnresolvedBackendIDs: string[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Performs a search for products, given a `Query` string.
   */
  export interface SearchProducts {
    Query?: string;
    Filters?: { [key: string]: FilterModel };
    AggregationState?: string;
    AggregationOptions?: { [key: string]: AggregationFilterModel };
    PageSize?: number;
    Page?: number;
    Sort?: SortFieldDescriptor[];
    SearchStrategyCode?: string;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
    UserTypeOverride?: UserTypes;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    /**
     * If Explain is set to true the response will contain an explanation of how the search was performed. This is ignored if you do not have the ProductSearchExplanations functionality.
     */
    Explain?: boolean;
    Options?: SearchProductsOptions;
    ProductAvailabilityFilter?: ProductAvailabilityFilter;
  }

  export interface AggregationFilterModel {
    MaxAggregationTerms?: number;
    TermsAggregation: boolean;
    StatsAggregation: boolean;
    AggregationOptions: { [key: string]: AggregationFilterModel };
    Values?: any[];
    From?: string;
    To?: string;
    /**
     * @default false
     */
    Negation?: boolean;
    /**
     * @default false
     */
    ExactMatch?: boolean;
    IncludeMissing?: boolean;
  }

  export interface SortFieldDescriptor {
    FieldName: string;
    Direction: SortDirection;
  }

  export interface SearchProductsOptions {
    /**
     * Order to use for additional options
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Include the results of a PrefigureDiscounts call in the result
     */
    IncludePrefigureDiscounts?: boolean;
    /**
     * If something is defined in these options, the GetProductAvailability results will be added to the response
     */
    AvailabilityOptions?: GetProductAvailabilityOptions;
    /**
     * Include the product relations
     */
    IncludeProductRelations?: boolean;
    /**
     * Include the product serial number configuration
     */
    IncludeSerialNumberConfiguration?: boolean;
    /**
     * Include the information on whether or not a product is part of bundle.
     */
    IncludeProductBundleRelationship?: boolean;
    /**
     * Include the customer wishlists that contain this product.
     */
    IncludeConnectedWishlistForProduct?: boolean;
    /**
     * If a product is a StockAggregate product, include the underlying SKUs in the result.
     */
    IncludeStockProducts?: boolean;
    /**
     * Determines the way we handle stock products.
     */
    StockAggregateHandling?: StockAggregateHandlingOptions;
  }

  export const enum StockAggregateHandlingOptions {
    /**
     * Returns stock aggregates and normal products
     */
    Default = 0,
    /**
     * Returns stock products and normal products
     */
    StockProducts = 1,
    /**
     * Return stock aggregates and stock products and normal products
     */
    Both = 2
  }

  export interface ProductAvailabilityFilter {
    FilterByAvailability: boolean;
    Type: ProductAvailabilityFilterTypes;
  }

  export const enum ProductAvailabilityFilterTypes {
    CurrentOrganizationUnit = 0,
    Suppliers = 1
  }

  export interface SearchProductsResponse {
    Products?: any[];
    AggregationState?: string;
    Aggregations?: { [key: string]: any };
    AggregationOptions?: { [key: string]: AggregationFilterModel };
    Page?: number;
    PageSize?: number;
    Total?: number;
    Sort?: SortFieldDescriptor[];
    Explanation?: ProductSearchExplanationModel;
    /**
     * Contains results of requested options
     */
    Options?: SearchProductsOptionsResponse;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ProductSearchExplanationModel {
    SearchStrategy: any;
    Query: any;
  }

  export interface SearchProductsOptionsResponse {
    PrefiguredDiscounts?: PrefigureDiscountResult[];
    /**
     * Entity type: Product
     */
    AvailabilityResult?: { [key: number]: ProductAvailabilityResult };
    AvailabilityPickupOrganizationUnits?: ProductAvailabilityPickupOrganizationUnit[];
    /**
     * Entity type: Product
     */
    ProductRelations?: { [key: number]: SearchProductsOptionsResponse.ProductRelation[] };
    /**
     * Entity type: Product
     */
    ProductSerialNumberConfigurations?: { [key: number]: SearchProductsOptionsResponse.SerialNumberConfiguration };
    StockProducts: SearchProductsOptionsResponse.StockProduct[];
    /**
     * Entity type: Product
     */
    IsPartOfBundleByProductID: { [key: number]: boolean };
    Wishlists?: SearchProductsOptionsResponse.Wishlist[];
    WishtListProductLinks: SearchProductsOptionsResponse.WishlistProductLink[];
  }

  export namespace SearchProductsOptionsResponse {
    export interface ProductRelation {
      PrimaryName?: string;
      SecondaryName?: string;
      Direction?: ProductRelationDirection;
      StockRelationType?: StockRelationType;
      /**
       * Entity type: Product
       */
      PrimaryProductIDs?: number[];
      /**
       * Entity type: Product
       */
      RelatedProductIDs?: number[];
      Sequence?: number;
    }

    export interface SerialNumberConfiguration {
      /**
       * Entity type: SerialNumberConfiguration
       */
      ID: number;
      Name: string;
    }

    export interface Wishlist {
      /**
       * Entity type: Wishlist
       */
      ID: number;
      Name: string;
    }

    export interface WishlistProductLink {
      /**
       * Entity type: Product
       */
      ProductID: number;
      /**
       * Entity type: Wishlist
       */
      WishlistID: number;
    }

    export interface StockProduct {
      /**
       * Entity type: Product
       */
      StockAggregateProductID: number;
      /**
       * Entity type: Product
       */
      StockProductID: number;
      StockProductBackendID: string;
      StockProductCustomID: string;
    }

  }

  export interface PrefigureDiscountResult {
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    /**
     * Entity type: DiscountLayer
     */
    LayerID?: number;
    Trigger: DiscountTriggers;
    BackendID: string;
    Description: string;
    MarketingDescription: string;
    PromotionLabel: string;
    ImageBlobID?: string;
    ApplyTo: DiscountAppliesTo;
    MaximumUsagePerOrder?: number;
    /**
     * Entity type: Product
     */
    EligibleProductIDs: number[];
    IsAlreadyApplied: boolean;
    RequirementsMet: boolean;
    RequiresCustomer: boolean;
    RequiresCustomerEmail: boolean;
    RequiresCustomerCustomData: boolean;
    RequiresMinimumAmount: boolean;
    RequiresLoyaltyPoints: boolean;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    LoyaltyPointWithdrawal?: number;
    LoyaltyPointsMissing?: number;
    LoyaltyCanApplyRecursive: boolean;
    RequiresCoupon: boolean;
    CouponPresent: boolean;
    AvailableUserCoupons?: PrefigureDiscountResult.Coupon[];
    ActionType: string;
    ActionData: any;
    ActionResult: PrefigureDiscountResult.DataResult;
    ConditionsResults: PrefigureDiscountResult.DataResult[];
    IsPersonalizedPromotion: boolean;
    PersonalizedPromotionData: PrefigureDiscountResult.PersonalizedPromotionInformation[];
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
  }

  export namespace PrefigureDiscountResult {
    export interface Coupon {
      /**
       * Entity type: DiscountCoupon
       */
      ID: number;
      Code: string;
      /**
       * Entity type: Discount
       */
      DiscountID: number;
      ValidFrom: string;
      ValidTill?: string;
    }

    export interface DataResult {
      TypeName: string;
      RequirementsMet: boolean;
      RequiresCustomer: boolean;
      RequiresCustomerCustomData: boolean;
      RequiresMinimumAmount: boolean;
      RequiresLoyaltyPoints: boolean;
      CustomerFilterResult: CustomFieldFilterResult;
      ProductSetResults: PrefigureDiscountResult.ProductSetResult[];
      OrderAmountMissing?: number;
      OrderAmountMissingForNextTier?: number;
      CurrentTier: DataResult.ApplicableTier;
      MinimumLoyaltyPointsRequired?: number;
      LoyaltyPointsMissing?: number;
      LoyaltyPointsMissingForNextTier?: number;
    }

    export namespace DataResult {
      export interface ApplicableTier {
        ID?: string;
        OrderAmount: number;
      }

    }

    export interface ProductSetResult {
      ProductSet: DiscountProductSet;
      SetQuantityMissing?: number;
      SetQuantityMissingForNextTier?: number;
      ProductQuantityMissing?: PrefigureDiscountResult.ProductWithQuantity[];
      ProductQuantityMissingForNextTier?: PrefigureDiscountResult.ProductWithQuantity[];
      SetAmountMissing?: number;
      SetAmountMissingForNextTier?: number;
      ProductAmountMissing?: PrefigureDiscountResult.ProductWithAmount[];
      ProductAmountMissingForNextTier?: PrefigureDiscountResult.ProductWithAmount[];
    }

    export interface ProductWithQuantity {
      ProductID: number;
      Quantity: number;
    }

    export interface ProductWithAmount {
      ProductID: number;
      Amount: number;
    }

    export interface PersonalizedPromotionInformation {
      /**
       * Entity type: PersonalizedPromotion
       */
      PersonalizedPromotionID: number;
      RequiresSelection: boolean;
      LocksAfterFirstUsage: boolean;
      IsLocked: boolean;
    }

  }

  export const enum DiscountTriggers {
    Automatic = 0,
    Manual = 1,
    Coupon = 2,
    Bundles = 4,
    Loyalty = 5,
    ProductSubscription = 6,
    SystemManaged = -1
  }

  export const enum DiscountAppliesTo {
    None = 0,
    Order = 1,
    Line = 2,
    Both = 3
  }

  export interface CustomFieldFilterResult {
    Matches: boolean;
    FilterType: CustomFieldFilterType;
    FilterResults: CustomFieldFilterResult[];
    ConditionResults: CustomFieldFilterConditionResult[];
  }

  export const enum CustomFieldFilterType {
    And = 0,
    Or = 1
  }

  export interface CustomFieldFilterConditionResult {
    CustomFieldId: number;
    ExpectedValue: CustomFieldValue;
    CurrentValue?: CustomFieldValue;
    CurrentValuePresent: boolean;
    Matches: boolean;
  }

  export interface DiscountProductSet {
    ID?: string;
    Name: string;
    RequiredProductAmount?: number;
    RequiredQuantityOfProducts?: number;
    IsDiscountableProductSet: boolean;
    DiscountableQuantityOfProducts?: number;
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    ProductRequirements?: DiscountProductSet.ProductRequirement[];
    ProductSearchID?: number;
    /**
     * Entity type: PersonalizedPromotion
     */
    PersonalizedPromotionID?: number;
    UseLoyaltyProgramProducts: boolean;
    CountryID: string;
    LanguageID: string;
    Filters: DiscountProductSet.Filter[];
  }

  export namespace DiscountProductSet {
    export interface Filter {
      Exclude: boolean;
      PropertyName: string;
      Values: any[];
      ExactMatch: boolean;
      From?: string;
      To?: string;
    }

    export interface ProductRequirement {
      /**
       * Entity type: ProductRequirement
       */
      ProductRequirementID: number;
      Values: any[];
    }

  }

  /**
   * The normal `AddProductToOrder` cannot be used for adding a Product with type `BundleProduct` to an order. Instead, `AddBundleProductToOrder` must be
   * used. In addition to the `BundleProductID`, this service accepts an optional `LineSelection`, which represents the bundle's configuration in terms of
   * which products you've chosen.
   * 
   * The `LineSelection` data structure contains a `SelectedProductID`, which must refer to a ProductID that is a valid option for this bundle, according
   * to what `GetBundleProductDetails` returns.
   * 
   * If no `LineSelection` is provided then the default products of the bundle are added to the Order.
   */
  export interface AddBundleProductToOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    LineActionType?: LineActionTypes;
    /**
     * Entity type: Product
     */
    BundleProductID: number;
    LineSelection?: BundleProductOrderLineSelection[];
    /**
     * If specified the new bundle OrderLine becomes a child of the specified OrderLine.
     * Entity type: OrderLine
     */
    ParentOrderLineID?: number;
    /**
     * This will always create new lines, ignoring existing OrderLines that could be included in the bundle.
     */
    ForceNewLine?: boolean;
  }

  export interface BundleProductOrderLineSelection {
    /**
     * Entity type: ProductBundleLine
     */
    ProductBundleLineID: number;
    /**
     * Entity type: Product
     */
    SelectedProductID: number;
    LineSelection: BundleProductOrderLineSelection[];
  }

  export interface AddBundleProductToOrderResponse {
    /**
     * Created or updated OrderLineID
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * This service is used to apply a selection of products to the provided `BundleProductOrderLineID`.
   * The `BundleProductOrderLineID` field refers to the ID of an `OrderLine` on the provided `Order` that has a `BundleProduct` Product on it.
   * The `LineSelection` field is a list that couples a `SelectedProductID` to a `ProductBundleLineID` and is identical to how it's used in `AddBundleProductToOrder`.
   */
  export interface ApplyBundleProductSelection {
    /**
     * Entity type: Order
     */
    OrderID: number;
    LineActionType?: LineActionTypes;
    /**
     * Entity type: OrderLine
     */
    BundleProductOrderLineID: number;
    LineSelection?: BundleProductOrderLineSelection[];
  }

  export interface SimpleShoppingCartResponse {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * This service returns a list of bundle products that contain the `ProductID` in the request.
   * The service is meant to be used on a product detail page as a "this product is also available in these bundles" component.
   * The request allows you to specify what data you'd like to get back from the bundle product, through the `IncludedFields` field.
   */
  export interface GetBundleProductsForProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface GetBundleProductsForProductResponse {
    Result: BundleProductContainingProduct[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface BundleProductContainingProduct {
    /**
     * Entity type: Product
     */
    BundleProductID: number;
    BundlePricing: BundleProductPriceInfo;
    BundleProductContent: any;
    IsPromptSuppressed: boolean;
  }

  export interface BundleProductPriceInfo {
    UnitPrice: number;
    UnitPriceInTax: number;
    OriginalUnitPrice?: number;
    OriginalUnitPriceInTax?: number;
    TaxRate: number;
    CurrencyID: string;
  }

  /**
   * This service returns the bundles for which you currently have at least one product in the provided order.
   * This can then be used to suggest bundles to the end-user that they're missing out on.
   * 
   * The IncludedFields field controls which product content you get back for each bundle product. By default, only the product's display value is returned.
   * 
   * Specifying the ProductIDs field means that only suggestions for the given products are returned.
   * If the Order does not contain the provided ProductIDs, nothing will be returned.
   */
  export interface GetPotentialBundleProductsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
  }

  export interface GetPotentialBundleProductsForOrderResponse {
    Result: GetPotentialBundleProductsForOrderResponse.BundleProduct[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetPotentialBundleProductsForOrderResponse {
    export interface BundleProduct {
      BundleProductID: number;
      BundlePricing: BundleProductPriceInfo;
      BundleProductContent: any;
    }

  }

  /**
   * This service creates a ProductBundle for the given BundleProductID.
   * 
   * The request body object contains three parameters:
   * 
   * - BackendID: Optional. Can be filled in with the identifier of this bundle by which it is known in another system.
   * - BundleProductID: Required. This should refer to an EVA product with type `BundleProduct`.
   * - Type: Required. This specifies the type of bundle: discount or configurable. The type can not be changed after the bundle has been created.
   * - Lines: Optional. These specify the `ProductBundle`'s lines. If left empty or null at creation, these can be filled in by calling `UpdateProductBundle`. When specified, a line consists of the following:
   *     - BackendID: Optional. If the bundle exists in another system, this can refer to it.
   *     - Options: A list of available options for this line from which can be chosen. Only contains a ProductID for now, which may refer to a normal sellable product, a product with Type `ConfigurableProduct` or a `BundleProduct` (which would create bundles of bundles).
   *     - DefaultProductID: Optional, but required if there are multiple options or if the line option is a Configurable product. The DefaultProductID cannot be a `ConfigurableProduct` or a `BundleProduct`.
   *     - IsRequired: Is this line an optional part of the bundle or not?
   *     - IsPromptSuppressed: Should the FE suppress the modal that allows the user to select a matching bundle for the scanned product
   */
  export interface CreateProductBundle {
    BackendID?: string;
    /**
     * Entity type: Product
     */
    BundleProductID: number;
    Type: ProductBundleTypes;
    Lines?: CreateProductBundleLine[];
    /**
     * Should the FE suppress the modal that allows the user to select a matching bundle for the scanned product
     */
    IsPromptSuppressed?: boolean;
  }

  export const enum ProductBundleTypes {
    Discount = 0,
    Configurable = 1
  }

  export interface CreateProductBundleLine {
    /**
     * Entity type: Product
     */
    DefaultProductID?: number;
    Description?: string;
    BackendID?: string;
    Type: ProductBundleLineTypes;
    Options: CreateProductBundleLineOption[];
    MaxSelectedOptionsCount?: number;
  }

  export interface CreateProductBundleLineOption {
    /**
     * Entity type: Product
     */
    ProductID: number;
    Quantity?: number;
    /**
     * Entity type: Product
     */
    AdditionalProductID?: number;
    AdditionalProductQuantity: number;
    /**
     * Entity type: Product
     */
    ExcludesProductIDs: number[];
  }

  export interface CreateProductBundleResponse {
    /**
     * Entity type: ProductBundle
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * This service is largely the same as CreateProductBundle.
   * The model passed into the request body is considered to be the entire bundle configuration.
   * Any lines that are currently present but not present in the update model are removed from the bundle.
   * The only parameter that is different is that the model requires an ID to be set for the root object and its lines, which you get back from the `GetProductBundle` and `ListProductBundles` services.
   */
  export interface UpdateProductBundle {
    /**
     * Entity type: ProductBundle
     */
    ID: number;
    BackendID?: string;
    /**
     * Should the FE suppress the modal that allows the user to select a matching bundle for the scanned product
     */
    IsPromptSuppressed?: boolean;
    Lines?: UpdateProductBundleLine[];
  }

  export interface UpdateProductBundleLine {
    /**
     * Can be left null for new lines to be added to the bundle.
     * Entity type: ProductBundleLine
     */
    ID?: number;
    Description: string;
    /**
     * Entity type: Product
     */
    DefaultProductID?: number;
    BackendID: string;
    Type: ProductBundleLineTypes;
    Options: UpdateProductBundleLineOption[];
    MaxSelectedOptionsCount?: number;
  }

  export interface UpdateProductBundleLineOption {
    /**
     * Entity type: Product
     */
    ProductID: number;
    Quantity?: number;
    /**
     * Entity type: Product
     */
    AdditionalProductID?: number;
    AdditionalProductQuantity: number;
    /**
     * Entity type: Product
     */
    ExcludesProductIDs: number[];
  }

  /**
   * Deletes a ProductBundle.
   */
  export interface DeleteProductBundle {
    /**
     * Entity type: ProductBundle
     */
    ID: number;
  }

  /**
   * This service returns a paged summary of `ProductBundles`, for each bundle it contains the `BundleProduct` and the pricing information for the bundle.
   */
  export interface ListProductBundles {
    PageConfig?: PageConfig<ListProductBundlesFilter>;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface ListProductBundlesFilter {
    /**
     * The ProductBundleID
     * Entity type: ProductBundle
     */
    ProductBundleID?: number;
    /**
     * The ProductBundle BackendID
     */
    ProductBundleBackendID?: string;
    ProductBundleType?: ProductBundleTypes;
    /**
     * The ProductBundle ProductID
     * Entity type: Product
     */
    ProductBundleProductID?: number;
    /**
     * The ProductBundle Product BackendID
     */
    ProductBundleProductBackendID?: string;
    /**
     * The ProductBundle Product CustomID
     */
    ProductBundleProductCustomID?: string;
    /**
     * The ProductBundle Product Name
     */
    ProductBundleProductName?: string;
  }

  export interface ListProductBundlesResponse {
    Result: PagedResult<ListProductBundlesResponseResult>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListProductBundlesResponseResult {
    /**
     * Entity type: ProductBundle
     */
    ID: number;
    BackendID: string;
    BundleProduct: ProductBundlesProductInfo;
    BundlePricing: BundleProductPriceInfo;
    /**
     * Indicates whether the bundle has any non-default options. If it doesn't, there is no need to configure it after adding it to an order.
     */
    HasNonDefaultOptions: boolean;
    /**
     * Should the FE suppress the modal that allows the user to select a matching bundle for the scanned product
     */
    IsPromptSuppressed: boolean;
  }

  export interface ProductBundlesProductInfo {
    /**
     * Entity type: Product
     */
    ID: number;
    CustomID: string;
    Content: any;
    BackendID: string;
  }

  /**
   * This service is used to fetch a `ProductBundle` by its ID. The requested bundle will be returned with its lines and for each line, its options.
   */
  export interface GetProductBundle {
    /**
     * Entity type: ProductBundle
     */
    ID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface GetProductBundleResponse {
    /**
     * Entity type: ProductBundle
     */
    ID: number;
    BackendID: string;
    BundleProduct: ProductBundlesProductInfo;
    BundlePricing: BundleProductPriceInfo;
    Lines: GetProductBundleResponse.Line[];
    Type: ProductBundleTypes;
    /**
     * Indicates whether the bundle has any non-default options. If it doesn't, there is no need to configure it after adding it to an order.
     */
    HasNonDefaultOptions: boolean;
    /**
     * Should the FE suppress the modal that allows the user to select a matching bundle for the scanned product
     */
    IsPromptSuppressed: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetProductBundleResponse {
    export interface Line {
      /**
       * Entity type: ProductBundleLine
       */
      ID: number;
      Description: string;
      BackendID: string;
      Type: ProductBundleLineTypes;
      DefaultProduct: ProductBundlesProductInfo;
      Options: GetProductBundleResponse.LineOption[];
      MaxSelectedOptionsCount?: number;
    }

    export interface LineOption {
      /**
       * Entity type: ProductBundleLineOption
       */
      ID: number;
      Sequence: number;
      Quantity: number;
      Product: ProductBundlesProductInfo;
      /**
       * Entity type: Product
       */
      ExcludesProductIDs: number[];
    }

  }

  /**
   * Gets the details of a bundle by its ProductID. The input to this service is `BundleProductID` which refers to the ID
   * of a `Product` that has `Type` = `BundleProduct`.
   * 
   * The details of a bundle is a structure containing the lines of the bundle, the available options for each line
   * of the bundle and, if it's a bundle of bundles or a bundle of configurable products, this structure is recursive; each option
   * can have lines of its own again. So the output of this service contains a tree of all the available products for the bundle.
   * 
   * The `IncludedFields` parameter is optional and allows you to specify which fields you wish to get back from this service.
   */
  export interface GetBundleProductDetails {
    /**
     * Entity type: Product
     */
    BundleProductID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface GetBundleProductDetailResponse {
    Lines: BundleProductLine[];
    /**
     * Entity type: Product
     */
    BundleProductID: number;
    Products: GetBundleProductProduct[];
    IsDeleted: boolean;
    /**
     * Should the FE suppress the modal that allows the user to select a matching bundle for the scanned product
     */
    IsPromptSuppressed: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface BundleProductLine {
    /**
     * Entity type: ProductBundleLine
     */
    ID: number;
    BackendID: string;
    /**
     * Entity type: Product
     */
    DefaultProductID?: number;
    Options: BundleProductLineOption[];
    IsRequired: boolean;
    IncludedInBundlePrice: boolean;
    Description: string;
    IsDeleted: boolean;
    MaxSelectedOptionsCount?: number;
  }

  export interface BundleProductLineOption {
    /**
     * Entity type: Product
     */
    ProductID: number;
    Lines: BundleProductLine[];
    /**
     * Entity type: ProductBundleLine
     */
    ProductBundleLineID: number;
    AdditionalUnitPriceInTax?: number;
    /**
     * Entity type: ProductBundleLineOption
     */
    ID: number;
    Quantity: number;
    Sequence: number;
    /**
     * Entity type: Product
     */
    AdditionalProductID?: number;
    AdditionalProductQuantity: number;
    /**
     * Entity type: Product
     */
    ExcludesProductIDs: number[];
  }

  export interface GetBundleProductProduct {
    /**
     * Entity type: Product
     */
    ID: number;
    CustomID: string;
    Type: ProductTypes;
    Content: any;
    Pricing: BundleProductPriceInfo;
  }

  /**
   * Pushes a blob (by `BlobID` or `BlobUrl`) to a device of specified `Type` on given `StationID`.
   */
  export interface Print {
    /**
     * Entity type: Station
     */
    StationID?: number;
    Type?: PrintType;
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrl?: string;
  }

  export const enum PrintType {
    Paper = 0,
    Zebra = 1
  }

  /**
   * Renders the result of a previous thermal print job to HTML and/or PDF. Supply either a `BlobID` or `BlobUrl`.
   */
  export interface RenderThermalPrintResult {
    /**
     * The output format. It's possible to provide both HTML and PDF. When Html is specified the response will contain the thermal print result inside the `Html` field.
     */
    OutputFormat?: RenderThermalPrintResultOutputFormat;
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrl?: string;
  }

  export const enum RenderThermalPrintResultOutputFormat {
    Html = 1,
    Pdf = 2,
    Png = 4
  }

  export interface RenderThermalPrintResultResponse {
    Html: string;
    PdfUrl: string;
    PngUrl: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Reprints the results of a previous thermal print job to a specified station. Supply either a `BlobID` or `BlobUrl`.
   */
  export interface ReprintThermalPrintResult {
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrl?: string;
    /**
     * Entity type: Station
     */
    StationID?: number;
  }

  /**
   * Returns a tree representation of how the price was derived for the given ProductIDs in the given PriceListID. NOTICE THAT you can provide a maximum of 100 products to explain.
   */
  export interface ExplainProductPrices {
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    /**
     * Entity type: PriceList
     */
    PriceListID: number;
  }

  export interface ExplainProductPricesResponse {
    Products: ExplainProductPricesResponse.ProductPricingExplanation[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ExplainProductPricesResponse {
    export interface ProductPricingExplanation {
      ProductID: number;
      Explanations: ProductPricingExplanation.Explanation[];
    }

    export namespace ProductPricingExplanation {
      export interface PriceListAdjustment {
        ID: number;
        Name: string;
      }

      export interface Explanation {
        PriceListID?: number;
        PriceListAdjustment?: ProductPricingExplanation.PriceListAdjustment;
        NodeType?: string;
        OldPrice?: number;
        NewPrice?: number;
        Message?: string;
        Data?: any;
        Children?: ProductPricingExplanation.Explanation[];
      }

    }

  }

  /**
   * Calculate potential pricing for the given ProductIDs and optional UserID.
   */
  export interface GetPotentialProductPricing {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    /**
     * Entity type: Order
     */
    OrderID?: number;
  }

  export interface GetPotentialProductPricingResponse {
    Products?: GetPotentialProductPricingResponse.ProductPriceInfo[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetPotentialProductPricingResponse {
    export interface ProductPriceInfo {
      CurrentPrice?: GetPotentialProductPricingResponse.CurrentPriceInfo;
      PotentialPrices?: GetPotentialProductPricingResponse.PotentialPriceInfo[];
    }

    export interface CurrentPriceInfo {
      CurrencyID?: string;
      UnitPrice?: number;
      UnitPriceInTax?: number;
      OriginalUnitPrice?: number;
      OriginalUnitPriceInTax?: number;
      PricingGroupID?: string;
    }

    export interface PotentialPriceInfo {
      CurrencyID?: string;
      UnitPrice?: number;
      UnitPriceInTax?: number;
      OriginalUnitPrice?: number;
      OriginalUnitPriceInTax?: number;
      PricingGroupID?: string;
      Condition?: PotentialPriceInfo.ConditionInfo;
    }

    export namespace PotentialPriceInfo {
      export interface ConditionInfo {
        CustomFields?: ConditionInfo.CustomFieldCondition[];
      }

      export namespace ConditionInfo {
        export interface CustomFieldCondition {
          FieldName?: string;
          RequiredValue?: string;
          PricingGroupID?: string;
        }

      }

    }

  }

  export interface ListManualTaxExemptionReasons {
    PageConfig?: PageConfig<ListTaxExemptionReasonModelFilters>;
  }

  export interface ListTaxExemptionReasonModelFilters {
    Code?: string;
    Name?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export interface ListManualTaxExemptionReasonsResponse {
    Result?: PagedResult<ManualTaxExemptionReason>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ManualTaxExemptionReason {
    ID: number;
    Code: string;
    Name: string;
    RequiresVerification: boolean;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    OrganizationUnitSetName: string;
  }

  export interface ListProductPrices {
    InitialPageConfig?: PageTokenConfig<ListProductPricesFilter>;
    PageToken?: string;
  }

  export interface ListProductPricesFilter {
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    /**
     * Entity type: PriceList
     */
    PriceListIDs?: number[];
    PriceListAdjustmentTypes?: string[];
    /**
     * Entity type: PriceListUsageType
     */
    PriceListUsageTypeIDs?: number[];
  }

  /**
   * Returns a paged list of all calculated prices, optionally filtered by ProductID and PriceListID.
   * 
   * In addition to filtering on ProductID and PriceListID, it's also possible to only return prices for pricelists that are built using certain adjustment types.
   * 
   * For example, to only return prices for pricelists that contain a MANUAL_INPUT adjustment, pass that string into the `PriceListAdjustmentTypes` array field.
   * 
   * Likewise, to only return pricelists that are attached to an organization with a certain PriceListUsageType you can add the PriceListUsageTypeID to the PriceListUsageTypeIDs filter.
   */
  export interface ListProductPricesResponse {
    Results?: ListProductPricesItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListProductPricesItem {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: PriceList
     */
    PriceListID: number;
    PriceListName: string;
    Price?: number;
    CurrencyID: string;
    LabelID?: number;
    LabelName: string;
  }

  export interface ListTaxCodes {
    PageConfig?: PageConfig<ListTaxCodesFilter>;
  }

  export interface ListTaxCodesFilter {
    /**
     * Entity type: TaxCode
     */
    ID?: number;
    Name: string;
    /**
     * Only returns tax codes which currently have an active tax rate for your current country. Defaults to true.
     */
    ActiveOnly: boolean;
  }

  export interface ListTaxCodesResponse {
    Result?: PagedResult<TaxCodeItem>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface TaxCodeItem {
    /**
     * Entity type: TaxCode
     */
    ID: number;
    Name: string;
    Description: string;
    LedgerClassID: string;
    BackendTaxCodeID: string;
    BackendID: string;
  }

  /**
   * A service that allows to manage the entirety of a price list.
   */
  export interface PushPriceList {
    /**
     * The unique identifier for this pricelist.
     */
    ID?: string;
    /**
     * A string that identifies the system that was used to call this service. In combination with the ID of the pricelist, this is what uniquely identifies the pricelist in EVA.
     * The SystemID must be the same for every call, if it's different from a previous call then a new pricelist will be created.
     */
    SystemID?: string;
    /**
     * If set to true then all prices specified on this price list will be interpreted as already VAT-included. If set to false then all prices will be interpreted as VAT-excluded. If not specified then the default value is true.
     * 
     * So if a price entry of 90 EUR is added to this pricelist with SpecifiedPricesIncludeTax = true (or not specified) then the price will be interpreted as 90 EUR already including VAT.
     * If SpecifiedPricesIncludeTax = false then the price will be interpreted as 90 EUR excluding VAT so that will be added on top for any orders created with this price.
     */
    SpecifiedPricesIncludeTax?: boolean;
    /**
     * The name of the pricelist. Must be present for the creation of a pricelist but can be left empty in subsequent calls.
     */
    Name?: string;
    /**
     * Whether or not the pricelist is active.
     */
    IsActive?: boolean;
    /**
     * The timezone that will be used to interpret activation times for prices.
     */
    TimeZone?: string;
    /**
     * The currency for the pricelist. Must be present for the creation of a pricelist but can be left empty in subsequent calls.
     */
    CurrencyID?: string;
    /**
     * The list of components that make up the pricelist. If left empty this will leave the current configuration unchanged. If specified only the components present will be modified. Components must be explictly deleted.
     */
    Components?: PushPriceList.Component[];
    /**
     * The organization units that use this pricelist. If left empty will leave the current configuration unchanged. If specified, will replace the current configuration.
     */
    ActiveForOrganizationUnits?: PushPriceList.ActiveOrganizationUnit[];
    /**
     * Whether or not to immediately recalculate the effective prices after processing the changes. Otherwise, the prices are automatically recalculated every 15 minutes. Until such a recalculation has been performed, the old price will remain active.
     * Defaults to false, only specify as true if you cannot wait for the normal recalculation cycle.
     */
    RecalculateEffectivePrices?: boolean;
    /**
     * If specified as true, the call to PushPriceList will not return until all uploaded prices have been stored and all prices have been recalculated. Normally this process runs in the background.
     */
    WaitForCompletion?: boolean;
    /**
     * The PushPriceList service is optimized for updating a pricelist in its entirety, so for many products at once when using a PriceEntry component. When using few products or even single products this service can perform unnecessary work. It's always recommended to
     * use this service in a large batch manner but if that's not possible you can specify your intent by using either LowProductCountOption = Auto or Optimize. Effectively this service will simply store the new price entries and return.
     * The updated prices won't become effective until the next calculation round, which happens every 15 minutes. The threshold for 'low product count' is set at 100 products.
     */
    LowProductCountOption?: PushPriceList.LowProductCountOptions;
  }

  export namespace PushPriceList {
    export interface Component {
      /**
       * The unique identifier for this component. Required.
       */
      ID?: string;
      /**
       * The name of the component. If left empty on creation of the component the ID will be used as the name.
       */
      Name?: string;
      /**
       * Determines the type of the component. Cannot be changed after creation.
       */
      Type: PushPriceList.ComponentTypes;
      Label?: string;
      /**
       * Determines when this component will become active. Until then the component will not be included in the calculation of the pricelist.
       */
      StartDate?: string;
      /**
       * Determines when this component will become inactive. After this date the component will not be included in the calculation of the pricelist.
       */
      EndDate?: string;
      /**
       * The PricingGroupID that this component is active for. Components with a PricingGroupID are only active for users that are members of that group. If left empty the component will be active for all users.
       */
      PricingGroupID?: string;
      /**
       * Components are applied in the order of their sequence number, from lowest to highest.
       */
      SequenceNumber?: number;
      /**
       * Determines if the price resulting from this component simply replaces the value as calculated by preceding components or if it's a relative value.
       * 
       * It defaults to false.
       * 
       * This affects the different component types in the following ways:
       * 
       * PriceEntries:
       * 
       * If OverrideCurrentCalculatedPrice = true then the value of the price entry replaces any value by a previous component. If false (the default) then the price entry is added to the existing value.
       * 
       * So if a previous component calculated that the price should be 100 and there is a price entry for 90, then with OverrideCurrentCalculatedPrice = true the resulting price will become 90. With false, it would become 190.
       * 
       * Markup:
       * 
       * It's only applied to a markup component if it has Type = Amount, it does not have any effect for Type = Percentage.
       * 
       * If set to true, a Amount markup component will function like a price entry compnent and replace the current value with the amount of the markup component.
       * 
       * If false (the default) it will add the Amount of the markup component to the current calculated value.
       */
      OverrideCurrentCalculatedPrice?: boolean;
      /**
       * If specified as true, the component will be deleted.
       */
      Delete: boolean;
      /**
       * The data that accompanies a Component with Type = PriceEntries, so a component that is simply a list of product/price pairs.
       * The simplest and most direct way to give a product a price.
       * 
       * This data consists of either a list of product/price pairs or a BlobID which is a reference to a previously created blob in EVA that contains data of the following format:
       * 
       * [
       *     {
       *       "ProductID": "<ProductID>",
       *       "Price": <Price>
       *     },
       *     ...
       * ]
       * 
       * If you only supply a handful of prices, the inline data works well, but for large quantities of prices you may want to use the BlobID method.
       * 
       * This data is ignored for all other Component types.
       * 
       * PriceEntries data is processed asynchronously in the background and will not be immediately visible after the service call returns.
       */
      PriceEntriesData?: PushPriceList.PriceEntriesData;
      /**
       * The data that accompanies a Component with Type = PricesFromOtherPriceList which is a component to copy prices from another pricelist.
       * 
       * Is useful for example for promotion prices, where you first 'import' the prices from the original pricelist, and then apply a negative markup to them to create a promotion discount.
       * 
       * Which prices you copy can be modified by specifying a ProductSearchTemplateID, only products that are contained in the results of the search will be copied,
       * unless ExcludeProductsInFilter is set to true, in which case the reverse is true; all products except the matching ones will have their prices copied.
       */
      CopyPricesFromOtherPriceListData?: PushPriceList.CopyPricesFromOtherPriceListData;
      /**
       * The data that accompanies a Component with Type = Markup which is a component that alters the price value of the previusly applied components,
       * either up or down. The markup/markdown can either be an absolute value or a percentage depending on the Type.
       */
      MarkupData?: PushPriceList.MarkupData;
    }

    export interface PriceEntriesData {
      /**
       * The blob that refers to the price entry data that was previously uploaded to a Blob in EVA. If left empty the inline data will be used.
       * 
       * The data in the blob must be in the following format:
       * 
       * [
       *     {
       *       "ProductID": "<ProductID>",
       *       "Price": <Price>
       *     },
       *     ...
       * ]
       */
      BlobID?: string;
      /**
       * The inline data that will be used to create the price entries. If left empty the blob will be used.
       */
      Prices?: PriceEntriesData.PriceEntryPrice[];
    }

    export namespace PriceEntriesData {
      export interface PriceEntryPrice {
        ID?: string;
        ProductID?: string;
        Price?: number;
        StartDate?: string;
        EndDate?: string;
      }

    }

    export interface CopyPricesFromOtherPriceListData {
      /**
       * The ID of the pricelist to copy prices from.
       */
      PriceListID?: string;
      /**
       * The ID of the ProductSearchTemplate to use to filter the products to copy. If left empty all products will be copied.
       * Entity type: ProductSearchTemplate
       */
      ProductSearchTemplateID?: number;
      /**
       * If true, all products except the matching ones will have their prices copied. If false, only the matching ones will have their prices copied.
       */
      ExcludeProductsInFilter?: boolean;
    }

    export interface MarkupData {
      /**
       * The type of markup/markdown. Either absolute amount or a percentage. Determines how FactorValue will be interpreted.
       */
      Type: FactorType;
      /**
       * The value of the markup/markdown. If Type is Amount, this is the amount to add to the price.
       * If Type is Percentage, this is the amount that the Price will be multiplied by.
       * 
       * A 10% markup should be specified as 1.10, a 25% discount should be specified as 0.75.
       */
      FactorValue: number;
      /**
       * The ID of the ProductSearchTemplate to use to filter the products to copy. If left empty all products will be copied.
       * Entity type: ProductSearchTemplate
       */
      ProductSearchTemplateID?: number;
      /**
       * If true, all products except the matching ones will have their prices copied. If false, only the matching ones will have their prices copied.
       */
      ExcludeProductsInFilter: boolean;
    }

    export const enum ComponentTypes {
      PriceEntries = 0,
      Markup = 1,
      CopyPricesFromOtherPriceList = 2
    }

    export const enum PriceListUsageTypes {
      /**
       * The price that is used as the price that a product is sold for in the normal B2C scenarios.
       */
      Sales = 0,
      /**
       * The price that is used to calculat what the cost price is of products that are sold to the party who sells it.
       */
      Cost = 1,
      /**
       * A promotional price reduction of the normal Sales price.
       */
      Promotion = 2,
      /**
       * The price that is used for sales prices between organizations in a B2B scenario.
       */
      Purchase = 3,
      /**
       * RecommendedRetail prices can be used for display purposes, not used in any logic.
       */
      RecommendedRetail = 4,
      /**
       * Can be used to give an indication of effective product prices after applying discounts. This is purely for display purposes.
       */
      PotentialDiscountedPrice = 5,
      /**
       * Economic taxes (recycling fees) can be used for display purposes, not used in any logic.
       */
      EcoTax = 6
    }

    export interface ActiveOrganizationUnit {
      OrganizationUnitID?: string;
      UsageType?: PushPriceList.PriceListUsageTypes;
      TargetOrganizationUnitID?: string;
      PricingGroupID?: string;
      Delete?: boolean;
    }

    export const enum LowProductCountOptions {
      Auto = 0,
      Optimize = 1,
      DoNotOptimize = 2
    }

  }

  export const enum FactorType {
    Amount = 0,
    Percentage = 1
  }

  export interface PushPriceListResponse {
    /**
     * Entity type: PriceList
     */
    PriceListID: number;
    /**
     * Returns unknown products that could not be processed. Only supported with low product counts.
     */
    UnknownProducts?: string[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Push multiple price lists in a single call. Each price list follows the same format as PushPriceList.
   */
  export interface PushPriceLists {
    PriceLists?: PushPriceLists.PushPriceListBase[];
  }

  export namespace PushPriceLists {
    export interface PushPriceListBase {
      /**
       * The unique identifier for this pricelist.
       */
      ID?: string;
      /**
       * A string that identifies the system that was used to call this service. In combination with the ID of the pricelist, this is what uniquely identifies the pricelist in EVA.
       * The SystemID must be the same for every call, if it's different from a previous call then a new pricelist will be created.
       */
      SystemID?: string;
      /**
       * If set to true then all prices specified on this price list will be interpreted as already VAT-included. If set to false then all prices will be interpreted as VAT-excluded. If not specified then the default value is true.
       * 
       * So if a price entry of 90 EUR is added to this pricelist with SpecifiedPricesIncludeTax = true (or not specified) then the price will be interpreted as 90 EUR already including VAT.
       * If SpecifiedPricesIncludeTax = false then the price will be interpreted as 90 EUR excluding VAT so that will be added on top for any orders created with this price.
       */
      SpecifiedPricesIncludeTax?: boolean;
      /**
       * The name of the pricelist. Must be present for the creation of a pricelist but can be left empty in subsequent calls.
       */
      Name?: string;
      /**
       * Whether or not the pricelist is active.
       */
      IsActive?: boolean;
      /**
       * The timezone that will be used to interpret activation times for prices.
       */
      TimeZone?: string;
      /**
       * The currency for the pricelist. Must be present for the creation of a pricelist but can be left empty in subsequent calls.
       */
      CurrencyID?: string;
      /**
       * The list of components that make up the pricelist. If left empty this will leave the current configuration unchanged. If specified only the components present will be modified. Components must be explictly deleted.
       */
      Components?: PushPriceList.Component[];
      /**
       * The organization units that use this pricelist. If left empty will leave the current configuration unchanged. If specified, will replace the current configuration.
       */
      ActiveForOrganizationUnits?: PushPriceList.ActiveOrganizationUnit[];
    }

  }

  export interface PushPriceListsResponse {
    PriceLists?: PushPriceListsResponse.ProcessedPriceList[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace PushPriceListsResponse {
    export interface ProcessedPriceList {
      /**
       * Entity type: PriceList
       */
      PriceListID?: number;
      ID?: string;
    }

  }

  /**
   * Create Tax Code
   */
  export interface CreateTaxCode {
    Name: string;
    Description?: string;
    LedgerClassID?: string;
    BackendID?: string;
    BackendTaxCodeID?: string;
  }

  export interface CreateTaxCodeResponse {
    /**
     * Entity type: TaxCode
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update Tax Code
   */
  export interface UpdateTaxCode {
    /**
     * Entity type: TaxCode
     */
    ID: number;
    Name?: string;
    Description?: string;
    BackendID?: string;
    BackendTaxCodeID?: string;
    LedgerClassID?: string;
  }

  /**
   * Delete Tax Code
   */
  export interface DeleteTaxCode {
    /**
     * Entity type: TaxCode
     */
    ID: number;
  }

  /**
   * Create a new manual tax exemption reason.
   */
  export interface CreateManualTaxExemptionReason {
    Code: string;
    Name: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    RequiresVerification?: boolean;
  }

  export namespace CreateManualTaxExemptionReason {
    export interface CreateManualTaxExemptionReasonLine {
      TaxRate: number;
      TaxName: string;
    }

  }

  export interface CreateManualTaxExemptionReasonResponse {
    /**
     * Entity type: TaxExemptionReason
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update a manual tax exemption reason.
   */
  export interface UpdateManualTaxExemptionReason {
    /**
     * Entity type: TaxExemptionReason
     */
    ID: number;
    Code: string;
    Name: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    RequiresVerification?: boolean;
  }

  /**
   * Delete a manual tax exemption reason.
   */
  export interface DeleteManualTaxExemptionReason {
    /**
     * Entity type: TaxExemptionReason
     */
    ID: number;
  }

  /**
   * Delete a manual tax exemption reason line.
   */
  export interface DeleteManualTaxExemptionReasonLine {
    /**
     * Entity type: TaxExemptionReasonLine
     */
    ID: number;
  }

  /**
   * Creates a tax rate.
   * 
   * * `CountryID` is a foreign key to the Countries table, which uses the ISO 3166-2 standard as ID
   * * `CountrySubdivisionID` is a foreign key to the CountrySubdivisions table, which uses the ISO 3166-2 standard as ID
   * * `TaxCodeID` is a foreign key to the TaxCodes table, which can be listed using the `ListTaxCodes` service
   * 
   * Percentages are a human readable formatted result of a fraction - applications use a `Rate` instead as an actual result of fraction to maintain
   * precision and integrity. If you wish to set a 21% tax percentage, that means a 1.21 tax rate. Setting a rate of 1.00 implies a 0% tax percentage,
   * and setting to 2.00 would mean a rediculous 100% tax percentage, doubling prices. You can probably tell that a `Rate` of 2.00 here is much more
   * readable than a 100% increase, but hey; nobody's forcing you to stick to percentages. At least - we're not!
   * 
   * Oh, and you can set a tax rate of 0.00, which would mean it will be fully sponsored by the government and will be free to purchase. The services
   * block anything lower than 0.00 and higher than 2.00 for sanity reasons. Will recap when governments gone mad.
   * 
   * :key: The combination of `CountryID`, `CountrySubdivision` and `TaxCodeID` is unique and will be enforced by EVA.
   * 
   * :point_right: `StartDate` and `EndDate` are optional, and can be used to transition from one rate to a next when it changes. Both these dates
   * are inclusive, meaning you'd want to set the `EndDate` of the expiring tax rate to 2018-12-31 and the `StartDate` of the new tax rate to
   * 2019-01-01 (for example).
   */
  export interface CreateTaxRate {
    /**
     * Entity type: Country
     */
    CountryID: string;
    /**
     * Entity type: CountrySubdivision
     */
    CountrySubdivisionID?: string;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID: number;
    /**
     * Range: 1-2
     */
    Rate: number;
    StartDate?: string;
    EndDate?: string;
    /**
     * Defines in which category the provided Rate falls for the provided CountryID. For example, a rate of 25% in the country Denmark should have Category = High as 25% is the high VAT rate in Denmark.
     * 
     * If the TaxCode used for this TaxRate is one of the predefined ones (High, Low, Zero, Exempt, Intermediate) this parameter is ignored but Category must be provided when using a custom TaxCode.
     * 
     * The Category `Dynamic` should be used for countries such as the US where the actual tax rate is context dependent and calculated dynamically.
     */
    Category?: TaxRateCategory;
  }

  export interface CreateTaxRateResponse {
    /**
     * Entity type: TaxRateInfo
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Gets a tax rate.
   * 
   * :point_right: See `CreateTaxRate` service for more info.
   */
  export interface GetTaxRate {
    /**
     * Entity type: TaxRateInfo
     */
    ID: number;
  }

  export interface GetTaxRateResponse {
    Result: TaxRateModel;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface TaxRateModel {
    /**
     * Entity type: TaxRateInfo
     */
    ID: number;
    /**
     * Entity type: Country
     */
    CountryID: string;
    /**
     * Entity type: CountrySubdivision
     */
    CountrySubdivisionID?: string;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID: number;
    TaxCodeName: string;
    Rate: number;
    StartDate?: string;
    EndDate?: string;
    Category: TaxRateCategory;
  }

  /**
   * Lists all tax rates.
   * 
   * Supports the filter `OnlyActive`, and when specified, will filter out all tax rates that have a `StartDate` or `EndDate` out of bounds for
   * 'today'. The actual value of the filter is irrelevant.
   * 
   * :point_right: See `CreateTaxRate` service for more info.
   */
  export interface ListTaxRates {
    PageConfig?: PageConfig<ListTaxRateModelFilters>;
  }

  export interface ListTaxRateModelFilters {
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: CountrySubdivision
     */
    CountrySubdivisionID?: string;
    OnlyActive?: boolean;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID?: number;
    TaxCodeName?: string;
    StartDate?: string;
    EndDate?: string;
  }

  export interface ListTaxRatesResponse {
    Result?: PagedResult<TaxRateModel>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Modifies a tax rate.
   * 
   * :point_right: See `CreateTaxRate` service for more info.
   */
  export interface UpdateTaxRate {
    /**
     * Entity type: TaxRateInfo
     */
    ID: number;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: CountrySubdivision
     */
    CountrySubdivisionID?: string;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID?: number;
    /**
     * Min: 0
     */
    Rate?: number;
    StartDate?: string;
    EndDate?: string;
    /**
     * Defines in which category the provided Rate falls for the provided CountryID. For example, a rate of 25% in the country Denmark should have Category = High as 25% is the high VAT rate in Denmark.
     * 
     * If the TaxCode used for this TaxRate is one of the predefined ones (High, Low, Zero, Exempt, Intermediate) this parameter is ignored but Category must be provided when using a custom TaxCode.
     * 
     * The Category `Dynamic` should be used for countries such as the US where the actual tax rate is context dependent and calculated dynamically.
     */
    Category?: TaxRateCategory;
  }

  /**
   * Deletes a tax rate.
   */
  export interface DeleteTaxRate {
    /**
     * Entity type: TaxRateInfo
     */
    ID: number;
  }

  /**
   * Update the prices in the pricelist specified.
   * 
   * This service takes a simplified approach of the pricing tools EVA offers, but that limits the options you have available. The price list to update may
   * only have a single active adjustment, and that has to be of type `MANUAL_INPUT`.
   * 
   * * The pricelist is identified by the `PriceListID` or the `BackendSystemID` and `BackendID`.
   * * Products can be identified by their (EVA) `ID`.
   * * Updates from this service are persisted in the background, which could take up to 15 minutes to process (unless you set `ForcePriceListRecalculation` to `true`)
   */
  export interface UpdateSimplePrices {
    /**
     * Entity type: PriceList
     */
    PriceListID?: number;
    PriceListBackendID?: string;
    PriceListBackendSystemID?: string;
    Prices: UpdateSimplePrices.Price[];
    /**
     * Set this to `true` when an immediate persistance of these prices is required. Not recommended; background recalculation is usually done within 15 minutes.
     */
    ForcePriceListRecalculation?: boolean;
  }

  export namespace UpdateSimplePrices {
    export interface Price {
      /**
       * Entity type: Product
       * 
       * Allows missing/invalid values when using EVA-IDs-Mode: ExternalIDs.
       */
      ProductID?: number;
      /**
       * Leave empty to delete the price for this product
       */
      NewPrice?: number;
    }

  }

  /**
   * Approve a non-confirmed payment transaction capture
   */
  export interface ApproveCapture {
    /**
     * Entity type: PaymentTransactionCapture
     */
    PaymentTransactionCaptureID: number;
  }

  /**
   * Approve a non-confirmed payment transaction
   */
  export interface ApprovePayment {
    /**
     * Entity type: PaymentTransaction
     * @deprecated Renamed to PaymentTransactionID
     */
    PaymentID?: number;
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID?: number;
  }

  export interface ApprovePaymentResponse {
    HasBeenApproved: boolean;
    Reason?: ApprovementFailureReasons;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum ApprovementFailureReasons {
    AlreadyApproved = 1,
    OrderAlreadyPaid = 2
  }

  /**
   * Cancels a non-confirmed payment transaction
   */
  export interface CancelPayment {
    /**
     * Entity type: PaymentTransaction
     * @deprecated Renamed to PaymentTransactionID
     */
    PaymentID?: number;
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID?: number;
  }

  /**
   * Sends a capture request to the PSP for the given PaymentTransaction with the given amount.
   */
  export interface CapturePayment {
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID: number;
    Amount?: number;
  }

  export interface CapturePaymentResponse {
    PaymentTransaction: PaymentTransactionDto;
    OpenAmount?: number;
    OrderAmountToCapture?: number;
    Success: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface PaymentTransactionDto {
    /**
     * Entity type: PaymentTransaction
     */
    ID: number;
    BackendID?: string;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    BackendSystemID: string;
    /**
     * Entity type: Device
     */
    DeviceID?: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
    GroupID?: string;
    /**
     * Only exposed with the functionality PaymentDetails (View).
     */
    PaymentDetails?: string;
    /**
     * Only exposed with the functionality PaymentDetails (View).
     */
    ErrorDetails?: string;
    /**
     * Only exposed to API callers with the functionality PaymentData (View).
     */
    Data?: string;
    AdditionalData?: { [key: string]: string };
    PaymentDate?: string;
    Amount: number;
    Status: PaymentStatuses;
    IsConfirmed: boolean;
    PendingOrConfirmed: boolean;
    PaidAmount: number;
    PaymentName: string;
    Change: number;
    /**
     * Entity type: PaymentType
     */
    TypeID: number;
    Type: PaymentTypeDto;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * Entity type: Currency
     */
    ForeignCurrencyID?: string;
    ExchangeRate?: number;
    Description?: string;
    /**
     * Only exposed with the functionality PaymentSettlements (View).
     */
    SettledAmount?: number;
    IsSettled?: boolean;
    RequiresCapture: boolean;
    CapturedAmount?: number;
    CapturableAmount?: number;
    AmountPendingCapture?: number;
    IsCaptured?: boolean;
    ForeignAmount?: number;
    ForeignPaidAmount?: number;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    CaptureMoment?: PaymentTypeCaptureMoment;
    HasDispute: boolean;
    HasUnresolvedDispute: boolean;
    IsRefund: boolean;
    IsAuthorizationAdjustment: boolean;
    IsAuthorizationExpired: boolean;
    AuthorizationExpirationDate?: string;
    Properties?: PaymentTransactionProperties;
    /**
     * Only included when requested
     */
    AvailableActions?: PaymentTransactionActions;
    OrganizationUnit: PaymentOrganizationUnitDto;
  }

  export const enum PaymentStatuses {
    New = 0,
    Pending = 1,
    Partial = 2,
    Confirmed = 10,
    Failed = -1
  }

  export interface PaymentTypeDto {
    Code: string;
    Name: string;
    IsRoundingType: boolean;
    PrintOnDocuments: boolean;
  }

  export const enum PaymentTypeCaptureMoment {
    None = 0,
    Manual = 1,
    Ship = 2,
    Confirmation = 3
  }

  export const enum PaymentTransactionProperties {
    None = 0,
    /**
     * The transaction was reversed by the psp
     */
    Reversed = 1,
    /**
     * The transaction was charched back due to a dispute
     */
    Chargedback = 2,
    /**
     * The losses created by a Reversal or a Chargeback are booked
     */
    DisputeResolved = 4,
    /**
     * A request for cancelling the remaining capturable amount has been done
     */
    CaptureCancelRequested = 8,
    /**
     * A request for cancelling the remaining capturable amount has been confirmed
     */
    CaptureCancelConfirmed = 16,
    /**
     * A request for a fraud check has been issued, pending external verification
     */
    FraudCheckRequested = 32,
    /**
     * A request for a fraud check has passed
     */
    FraudCheckPassed = 64,
    /**
     * A request for a fraud check has been denied
     */
    FraudCheckDenied = 128,
    /**
     * A request for cancelling the remaining capturable amount was failed
     */
    CaptureCancelFailed = 256,
    /**
     * This payment requests a Recurring Payment Token from the PSP to generate recurring payments later
     */
    RequestsTokenization = 512,
    /**
     * This payment is a Recurring Payment, made with a RecurringPaymentToken and no client interaction
     */
    Recurring = 1024
  }

  export interface PaymentTransactionActions {
    Cancel: boolean;
    Refund: boolean;
    Update: boolean;
    Approve: boolean;
    Capture: boolean;
  }

  export interface PaymentOrganizationUnitDto {
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
    Name: string;
    BackendID?: string;
  }

  /**
   * Capture Shipment
   */
  export interface CaptureShipment {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
  }

  export interface CaptureShipmentResponse {
    Success: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface CreatePayment {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID: number;
    /**
     * Range: 0-1000000
     */
    Amount?: number;
    Properties?: { [key: string]: any };
    /**
     * If the payment is done in another currency than the Order, this is required
     * Entity type: Currency
     */
    CurrencyID?: string;
    /**
     * When the created payment is confirmed and the order is paid, the order will be shipped automatically when possible.
     */
    AutoShipAfterConfirm?: boolean;
  }

  export interface CreatePaymentResponse {
    OpenAmount: number;
    Properties: { [key: string]: any };
    PaymentTransactions: PaymentTransactionDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Create a new paymenttransaction ledger of the given type. Only custom types are allowed
   */
  export interface CreatePaymentTransactionLedger {
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID?: number;
    LedgerType?: string;
    Value?: string;
    Description?: string;
    CreationTime?: string;
  }

  /**
   * Create a refund
   * 
   * With this service a refund can be done based on an existing PaymentTransaction, or without it for an Order.
   * 
   * It is required to specify a transaction or to specify the PaymentType to use.
   * 
   * When no Amount is specified the open amount of the order will be used.
   */
  export interface CreateRefund {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID?: number;
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID?: number;
    /**
     * Min: 0
     */
    Amount?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    Properties?: { [key: string]: any };
  }

  export interface CreateRefundResponse {
    Success: boolean;
    RefundedOnOrder: boolean;
    PaymentTransactions: PaymentTransactionDto[];
    Properties: { [key: string]: any };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get Active Payment Types
   */
  export interface GetActivePaymentTypes {
  }

  export interface GetActivePaymentTypesResponse {
    Result: string[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Retrieve all available payment methods, in general, or for a specific order.
   * 
   * When ReturnUnusablePaymentMethods is set to true, the system will also return unusable payment methods
   */
  export interface GetAvailablePaymentMethods {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * @default false
     */
    ReturnUnusablePaymentMethods?: boolean;
  }

  export interface GetAvailablePaymentMethodsResponse {
    PaymentMethods: string[];
    Results: AvailablePaymentMethod[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface AvailablePaymentMethod {
    Name: string;
    LocalizedName: string;
    IsUsable: boolean;
    IsCustom: boolean;
    NotUsableError: PaymentMethodNotUsableError;
    Types: AvailablePaymentMethodType[];
  }

  export interface PaymentMethodNotUsableError {
    Type: string;
    Message: string;
  }

  export interface AvailablePaymentMethodType {
    /**
     * Entity type: PaymentType
     */
    ID: number;
    Name: string;
    PaymentMethodName: string;
    /**
     * Entity type: PaymentMethod
     */
    PaymentMethodID: number;
    Code: string;
    Data: any;
    /**
     * Only used for refunds.
     */
    CanRefundWithoutOriginalPaymentTransaction?: boolean;
    /**
     * When this field is set, the amount that can be paid with this method is limited.
     */
    MaximumAmount?: number;
    IsFixedAmount: boolean;
    DisplayPriority: number;
  }

  /**
   * Get all available options for refunds on the given order
   * 
   * Refunds can be executed with the CreateRefund service
   */
  export interface GetAvailableRefundPaymentMethodsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetAvailableRefundPaymentMethodsResponse {
    Methods: RefundPaymentMethod[];
    /**
     * The amount currently available for refund on the given order
     */
    OrderAmountAvailableForRefund?: number;
    /**
     * Indicates if this order can be (partially) refunded with RefundOrder.
     */
    IsAutoRefundAvailable: boolean;
    AutoRefundableAmount?: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface RefundPaymentMethod {
    Code: string;
    IsCustom: boolean;
    Types: AvailablePaymentMethodType[];
    Transactions: RefundablePaymentTransaction[];
  }

  export interface RefundablePaymentTransaction {
    /**
     * Entity type: PaymentTransaction
     */
    ID: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    BackendID?: string;
    PaidAmount: number;
    RefundableAmount: number;
    ForeignPaidAmount?: number;
    Code: string;
    Type: string;
    /**
     * Entity type: PaymentType
     */
    TypeID: number;
    CreationTime: string;
    CanRefundWithoutInteraction: boolean;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * Entity type: Currency
     */
    ForeignCurrencyID?: string;
    AdditionalData?: { [key: string]: string };
  }

  /**
   * Get Payment Transaction
   */
  export interface GetPaymentTransaction {
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID: number;
  }

  export interface GetPaymentTransactionResponse {
    PaymentTransaction: PaymentTransactionDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get the PaymentTransactions attached to the given Order
   * 
   * The response also includes an object `AvailableActions`:
   * - Cancel: can the payment be cancelled
   * - Refund: can the payment be refunded
   * - Update: can an update for this payment be requested
   * - Approve: can the payment be approved
   */
  export interface GetPaymentTransactionsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetPaymentTransactionsResponse {
    PaymentTransactions: GetPaymentTransactionsResponse.PaymentTransaction[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetPaymentTransactionsResponse {
    export interface PaymentTransaction {
      DeviceSerialNumber?: string;
      /**
       * Entity type: PaymentTransaction
       */
      ID: number;
      BackendID?: string;
      /**
       * Entity type: User
       */
      CreatedByID: number;
      BackendSystemID: string;
      /**
       * Entity type: Device
       */
      DeviceID?: number;
      /**
       * Entity type: Order
       */
      OrderID: number;
      GroupID?: string;
      /**
       * Only exposed with the functionality PaymentDetails (View).
       */
      PaymentDetails?: string;
      /**
       * Only exposed with the functionality PaymentDetails (View).
       */
      ErrorDetails?: string;
      /**
       * Only exposed to API callers with the functionality PaymentData (View).
       */
      Data?: string;
      AdditionalData?: { [key: string]: string };
      PaymentDate?: string;
      Amount: number;
      Status: PaymentStatuses;
      IsConfirmed: boolean;
      PendingOrConfirmed: boolean;
      PaidAmount: number;
      PaymentName: string;
      Change: number;
      /**
       * Entity type: PaymentType
       */
      TypeID: number;
      Type: PaymentTypeDto;
      /**
       * Entity type: Currency
       */
      CurrencyID: string;
      /**
       * Entity type: Currency
       */
      ForeignCurrencyID?: string;
      ExchangeRate?: number;
      Description?: string;
      /**
       * Only exposed with the functionality PaymentSettlements (View).
       */
      SettledAmount?: number;
      IsSettled?: boolean;
      RequiresCapture: boolean;
      CapturedAmount?: number;
      CapturableAmount?: number;
      AmountPendingCapture?: number;
      IsCaptured?: boolean;
      ForeignAmount?: number;
      ForeignPaidAmount?: number;
      /**
       * Entity type: CustomField
       */
      CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
      CaptureMoment?: PaymentTypeCaptureMoment;
      HasDispute: boolean;
      HasUnresolvedDispute: boolean;
      IsRefund: boolean;
      IsAuthorizationAdjustment: boolean;
      IsAuthorizationExpired: boolean;
      AuthorizationExpirationDate?: string;
      Properties?: PaymentTransactionProperties;
      /**
       * Only included when requested
       */
      AvailableActions?: PaymentTransactionActions;
      OrganizationUnit: PaymentOrganizationUnitDto;
    }

  }

  /**
   * Get the PaymentTransactions attached to the given Invoice
   * 
   * The response also includes an object `AvailableActions`:
   * - Cancel: can the payment be cancelled
   * - Refund: can the payment be refunded
   * - Update: can an update for this payment be requested
   * - Approve: can the payment be approved
   */
  export interface GetPaymentTransactionsForInvoice {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
  }

  /**
   * When a PaymentTransaction is disputed due to a Chargeback or a Reversal, the difference can be booked in a different PaymentTransaction to allow the order to be completed.
   * 
   * Calling this service will result in an additional PaymentTransaction of type `DISPUTE`.
   */
  export interface HandlePaymentTransactionDispute {
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID: number;
  }

  /**
   * Set up a payment type
   */
  export interface InitializePaymentType {
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID: number;
    Properties?: { [key: string]: any };
  }

  export interface InitializePaymentTypeResponse {
    Properties: { [key: string]: any };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * List PaymentTransactionLedger
   * 
   * All available filters are typed in the PageConfig.Filter property.
   */
  export interface ListPaymentTransactionLedger {
    PageConfig?: PageConfig<ListPaymentTransactionLedgerFilter>;
  }

  export interface ListPaymentTransactionLedgerFilter {
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: PaymentTransactionLedgerType
     */
    TypeID?: number;
  }

  export interface ListPaymentTransactionLedgerResponse {
    Result?: PagedResult<ListPaymentTransactionLedgerResponse.PaymentTransactionLedgerDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListPaymentTransactionLedgerResponse {
    export interface PaymentTransactionLedgerDto {
      /**
       * Entity type: PaymentTransactionLedger
       */
      ID: number;
      /**
       * Entity type: PaymentTransaction
       */
      PaymentTransactionID: number;
      /**
       * Entity type: Order
       */
      OrderID?: number;
      /**
       * Entity type: PaymentTransactionLedgerType
       */
      TypeID: number;
      TypeName: string;
      OldValue: string;
      NewValue: string;
      Description: string;
      CreationTime: string;
      CreatedBy: ListPaymentTransactionLedgerResponse.UserDto;
    }

    export interface UserDto {
      /**
       * Entity type: User
       */
      ID: number;
      FullName: string;
    }

  }

  /**
   * Set a preferred method to use when this order will be refunded.
   * Can be used on ReturnOrders to indicate how the money should be transferred back to the customer.
   * 
   * Available methods can be listed with the GetAvailableRefundPaymentMethodsForOrder service.
   */
  export interface SetPreferredRefundMethod {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID?: number;
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID?: number;
    Properties?: { [key: string]: any };
  }

  /**
   * Get the selected preferred refund method to use when this order will be refunded.
   * 
   * See SetPreferredRefundMethod for more information.
   */
  export interface GetPreferredRefundMethod {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetPreferredRefundMethodResponse {
    PaymentMethod?: string;
    PaymentType?: PaymentTypeDto;
    PaymentTransaction?: PaymentTransactionDto;
    Properties?: { [key: string]: any };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Certain payment methods support retrieving the current status. Given a PaymentTransactionID this service will attempt to poll thestatus for that particular payment and directly update its status.
   */
  export interface RequestPaymentUpdate {
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID: number;
  }

  export interface RequestPaymentUpdateResponse {
    PaymentTransaction: PaymentTransactionDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Retrieve the anonymous token for specified `OrganizationUnitID` and `LanguageID`. The response is your token, or null when not present.
   */
  export interface GetAnonymousToken {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
  }

  export interface GetAnonymousTokenResponse {
    Token: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Create an anonymous token for specified `OrganizationUnitID` and `LanguageID`. The response is your new token, or a current one if it already existed.
   */
  export interface CreateAnonymousToken {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    LanguageID?: string;
  }

  export interface CreateAnonymousTokenResponse {
    Token: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Deletes an existing anonymous token.
   */
  export interface DeleteAnonymousToken {
    Token?: string;
  }

  /**
   * Archive an organization unit.
   * NOTE: Only do this when it is no longer in use. While this action is reversible, settings and other configurations previously in place may be lost.
   */
  export interface ArchiveOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     * Min: 1
     */
    OrganizationUnitID: number;
    /**
     * Enabling this will archive all children of the organization unit
     */
    ForceArchiveArchiveChildren?: boolean;
  }

  /**
   * Restore an archived organization unit.
   */
  export interface UnarchiveOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  /**
   * Updates some of the non-unique the OrganizationUnit's settings. This service can be used to only update a subset of the settings of the OrganizationUnit by providing only the fields you want to update.
   * If a field is not part of the request message (or has value `undefined`) then the setting is not updated. If the field is present but has a value of `null` then it's assumed you want to unset the setting.
   * 
   * The targeted OrganizationUnits can be identified by providing `OrganizationUnitIDs` or an `OrganizationUnitSetID`.
   * 
   * All OrganizationUnits will be updated, if one of them fails, no changes will be persisted.
   */
  export interface BulkUpdateOrganizationUnitSettings {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    RegisterCashLimit?: number;
    SafeCashLimit?: number;
    /**
     * Entity type: CashHandler
     */
    CashHandlerID?: number;
    Type?: OrganizationUnitTypes;
    /**
     * Entity type: TaxProvider
     */
    TaxProviderID?: number;
    /**
     * Min: 0
     */
    CashFloat?: number;
    Subnet?: string;
    UseForAccounting?: boolean;
    /**
     * Entity type: User
     */
    AttachedToUserID?: number;
    CountryID?: string;
    CountrySubdivisionID?: string;
    LanguageID?: string;
    TimeZone?: string;
    /**
     * Entity type: Assortment
     */
    AssortmentID?: number;
    /**
     * Entity type: RoleSet
     */
    RoleSetID?: number;
    CostPriceCalculationMethod?: CostPriceCalculationMethod;
    /**
     * Entity type: OrganizationUnit
     */
    ReturnOrganizationUnitID?: number;
    EnableEndlessSupplierStock?: boolean;
    /**
     * Entity type: VisibilityGroup
     */
    VisibilityGroupID?: number;
    ForceLocalMode?: boolean;
  }

  export const enum CostPriceCalculationMethod {
    Manual = 0,
    WeightedAverageCost = 1,
    LastIn = 2,
    Fifo = 3
  }

  /**
   * Create a new OrganizationUnit
   */
  export interface CreateOrganizationUnit {
    ToCreate?: CreateOrganizationUnitDto;
  }

  export interface CreateOrganizationUnitDto {
    BackendID?: string;
    Name?: string;
    Description?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    Type?: OrganizationUnitTypes;
    Status?: OrganizationUnitStatus;
    Latitude?: number;
    Longitude?: number;
    Subnet?: string;
    Address?: AddressDataDto;
    OpeningHours?: CreateOrganizationUnitDto.OpeningHour[];
    Website?: string;
    BIC?: string;
    /**
     * Entity type: VisibilityGroup
     */
    VisibilityGroupID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    ParentID?: number;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: CountrySubdivision
     */
    CountrySubdivisionID?: string;
    /**
     * Entity type: Assortment
     */
    AssortmentID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    ReturnOrganizationUnitID?: number;
    /**
     * Entity type: Company
     */
    CompanyID?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    /**
     * Entity type: Currency
     */
    CostPriceCurrencyID?: string;
    Notes?: string;
    BankAccount?: string;
    BackendRelationID?: string;
    BranchNumber?: string;
    GlobalLocationNumber?: string;
    RegisterCashLimit?: number;
    SafeCashLimit?: number;
    /**
     * Min: 0
     */
    CashFloat?: number;
    /**
     * Entity type: TaxProvider
     */
    TaxProviderID?: number;
    /**
     * Entity type: CashHandler
     */
    CashHandlerID?: number;
    UseForAccounting?: boolean;
    /**
     * Entity type: User
     */
    AttachedToUserID?: number;
    IpAddress?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    TimeZone?: string;
    /**
     * Entity type: RoleSet
     */
    RoleSetID?: number;
    CostPriceCalculationMethod?: CostPriceCalculationMethod;
    EnableEndlessSupplierStock?: boolean;
    EstablishmentNumber?: string;
  }

  export namespace CreateOrganizationUnitDto {
    export interface OpeningHour {
      /**
       * Entity type: OpeningHoursType
       */
      TypeID?: number;
      DayOfWeek?: DayOfWeek;
      Date?: string;
      Description?: string;
      StartTime?: string;
      EndTime?: string;
    }

  }

  export interface CreateOrganizationUnitResponse {
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface DeleteOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     * Min: 1
     */
    OrganizationUnitID: number;
    /**
     * Enabling this will delete all children of the organization unit
     */
    ForceDeleteArchiveChildren?: boolean;
  }

  /**
   * Returns all `CashHandlers` available to use on `OrganizationUnits`
   */
  export interface GetAvailableCashHandlers {
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
  }

  export interface GetAvailableCashHandlersResponse {
    Handlers: GetAvailableCashHandlersResponse.CashHandler[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetAvailableCashHandlersResponse {
    export interface CashHandler {
      ID: number;
      Name: string;
      CurrencyID: string;
    }

  }

  /**
   * Retrieve detailed organization unit information.
   */
  export interface GetOrganizationUnitDetailed {
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
  }

  export interface GetOrganizationUnitDetailedResponse {
    /**
     * Entity type: OrganizationUnit
     */
    ID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    ParentID?: number;
    ParentName?: string;
    /**
     * Entity type: Company
     */
    CompanyID?: number;
    CompanyName?: string;
    /**
     * Entity type: Address
     */
    AddressID?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    /**
     * Entity type: VisibilityGroup
     */
    VisibilityGroupID?: number;
    /**
     * Entity type: TaxProvider
     */
    TaxProviderID?: number;
    VisibilityGroupName?: string;
    Name?: string;
    BackendID?: string;
    BackendRelationID?: string;
    CashFloat?: number;
    Description?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    Type?: OrganizationUnitTypes;
    Status?: OrganizationUnitStatus;
    OpeningHours?: OpeningHoursDto[];
    ExtendedOpeningHours?: ExtendedOpeningHours[];
    Subnet?: string;
    RegisterCashLimit?: number;
    SafeCashLimit?: number;
    Latitude?: number;
    Longitude?: number;
    BankAccount?: string;
    Website?: string;
    BIC?: string;
    TimeZone?: string;
    EstablishmentNumber?: string;
    Address?: AddressDto;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    CountryID?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get Organization Unit Settings
   */
  export interface GetOrganizationUnitSettings {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetOrganizationUnitSettingsResponse {
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    ParentID?: number;
    BackendID: string;
    BackendRelationID: string;
    BranchNumber: string;
    GlobalLocationNumber: string;
    RegisterCashLimit?: number;
    SafeCashLimit?: number;
    /**
     * Entity type: CashHandler
     */
    CashHandlerID?: number;
    CashHandlerName: string;
    CashFloat?: number;
    Type: OrganizationUnitTypes;
    Subnet: string;
    UseForAccounting: boolean;
    /**
     * Entity type: User
     */
    AttachedToUserID?: number;
    AttachedToUserName?: string;
    IpAddress: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    /**
     * Entity type: CountrySubdivision
     */
    CountrySubdivisionID?: string;
    Region: string;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * Entity type: Currency
     */
    CostPriceCurrencyID: string;
    TimeZone: string;
    /**
     * Entity type: Assortment
     */
    AssortmentID?: number;
    AssortmentName: string;
    /**
     * Entity type: RoleSet
     */
    RoleSetID: number;
    RoleSetName: string;
    CostPriceCalculationMethod: CostPriceCalculationMethod;
    /**
     * Entity type: OrganizationUnit
     */
    ReturnOrganizationUnitID?: number;
    ReturnOrganizationUnitName?: string;
    /**
     * Entity type: TaxProvider
     */
    TaxProviderID?: number;
    TaxProviderName?: string;
    ForceLocalMode: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Returns the full hierarchy of organization units, starting from the root and then containing a nested list of child OU's.
   */
  export interface GetOrganizationUnitsHierarchy {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    Functionality?: string;
    FunctionalityScope?: FunctionalityScope;
  }

  export interface GetOrganizationUnitsHierarchyResponse {
    OrganizationUnits: OrganizationUnitHierarchy[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface OrganizationUnitHierarchy {
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
    Name: string;
    BackendID: string;
    /**
     * Entity type: OrganizationUnit
     */
    ParentID?: number;
    Children?: OrganizationUnitHierarchy[];
  }

  /**
   * Returns a summary of a specific organizationunit. Since this service is publicly available, this will return minimal information (aka a summary) about the OU.
   * Service can also be called for archived organization units to fetch minimal information.
   */
  export interface GetOrganizationUnitSummary {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetOrganizationUnitSummaryResponse {
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
    Name: string;
    Address?: AddressDto;
    PhoneNumber?: string;
    Latitude?: number;
    Longitude?: number;
    UpcomingOpeningHours: WeekOpeningsDto[];
    RegularOpeningHours: RegularOpeningHours[];
    /**
     * Entity type: OrganizationUnit
     */
    ParentID?: number;
    /**
     * Entity type: Country
     */
    CountryID: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface WeekOpeningsDto {
    DayOfWeek: DayOfWeek;
    OpeningTime: string;
    ClosingTime: string;
    Date: string;
    Closed: boolean;
  }

  export interface RegularOpeningHours {
    DayOfWeek: DayOfWeek;
    OpeningTime: string;
    ClosingTime: string;
    Closed: boolean;
  }

  /**
   * Get Required Organization Unit Fields
   */
  export interface GetRequiredOrganizationUnitFields {
  }

  export interface GetRequiredOrganizationUnitFieldsResponse {
    RequiredFields: string[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Shows in which OU sets an OU is included.
   */
  export interface GetSetsByOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
  }

  export interface GetSetsByOrganizationUnitResponse {
    Result: GetSetsByOrganizationUnitResponse.OrganizationUnitSetDetails[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetSetsByOrganizationUnitResponse {
    export interface OrganizationUnitSetDetails {
      /**
       * Entity type: OrganizationUnitSet
       */
      ID: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID?: number;
      Name: string;
      Description: string;
      Subsets: GetSetsByOrganizationUnitResponse.OrganizationUnitSetDetails[];
    }

  }

  /**
   * Returns stores in proximity of a set of coordinates.
   * 
   * If `ProductID` and `HasStock` is set, only the stores with stock for that product will be returned.
   */
  export interface GetShopsByProximity {
    /**
     * Amount of stores to return, defaults to setting `GetShopsByProximityDefaultLimit` / 10
     */
    Limit?: number;
    /**
     * Range around the coordinates to look for shops, in meters, defaults to setting `DefaultShopProximityRange` / 50_000
     */
    Range?: number;
    /**
     * Country code of the user (ISO 3166-1)
     */
    CountryID?: string;
    /**
     * Filter only stores with available stock
     */
    HasStock?: boolean;
    Status?: OrganizationUnitStatus;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Range: -90-90
     */
    Latitude: number;
    /**
     * Range: -180-180
     */
    Longitude: number;
  }

  export interface GetShopsByProximityResponse {
    Shops: GetShopsByProximityResponse.ShopInfo[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetShopsByProximityResponse {
    export interface ShopInfo {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
      Address: AddressDto;
      PhoneNumber: string;
      Latitude: number;
      Longitude: number;
      Distance: number;
    }

  }

  /**
   * This service return the available webshop OrganizationUnits
   */
  export interface GetWebshops {
  }

  export interface GetWebshopsResponse {
    Webshops: GetWebshopsResponse.WebshopDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetWebshopsResponse {
    export interface WebshopDto {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
      /**
       * Entity type: Country
       */
      CountryID: string;
    }

  }

  /**
   * Creates or updates specified `OrganizationUnits`, identified by your `ID` (that we map to our `BackendID`).
   * 
   * Omit any field you don't want altered, or send in null values of nullable fields to unset their current value.
   * 
   * - Does not apply to `Address` - if you specify a new or different one from the current, a new Address will be created with only the data specify!
   * - Does not apply to `OpeningHours` - every value you specify will either update or create a record for that day
   */
  export interface ImportOrganizationUnits {
    OrganizationUnits?: ImportOrganizationUnits.ImportOrganizationUnit[];
  }

  export namespace ImportOrganizationUnits {
    export interface ImportOrganizationUnit {
      /**
       * Your identifier for an organization unit (mapped as `BackendID`)
       */
      ID: string;
      /**
       * Your identifier for a parent organization unit (mapped as `BackendID`)
       */
      ParentID: string;
      /**
       * Name of the organization unit
       */
      Name: string;
      Description?: string;
      EmailAddress?: string;
      PhoneNumber?: string;
      VatNumber?: string;
      Type?: OrganizationUnitTypes;
      Status?: OrganizationUnitStatus;
      /**
       * Entity type: Company
       */
      CompanyID?: number;
      CompanyBackendID?: string;
      Latitude?: number;
      Longitude?: number;
      Subnet?: string;
      TimeZone?: string;
      Region?: string;
      IsDeleted?: boolean;
      /**
       * Entity type: Country
       */
      CountryID?: string;
      /**
       * Entity type: CountrySubdivision
       */
      CountrySubdivisionID?: string;
      /**
       * Entity type: Language
       */
      LanguageID?: string;
      /**
       * Entity type: Currency
       */
      CurrencyID?: string;
      /**
       * Entity type: Currency
       */
      CostPriceCurrencyID?: string;
      ReturnOrganizationUnitID?: string;
      /**
       * Optional additional custom fields
       */
      CustomFields?: CustomFieldKeyValue[];
      Address?: ImportOrganizationUnits.ImportOrganizationUnitAddress;
      OpeningHours?: ImportOrganizationUnits.ImportOrganizationUnitOpeningHour[];
    }

    export interface ImportOrganizationUnitAddress {
      FirstName?: string;
      LastName?: string;
      HouseNumber?: string;
      Address1?: string;
      Address2?: string;
      ZipCode?: string;
      Subdistrict?: string;
      District?: string;
      City?: string;
      State?: string;
      Region?: string;
      CountryID?: string;
      Latitude?: number;
      Longitude?: number;
    }

    export interface ImportOrganizationUnitOpeningHour {
      DayOfWeek?: DayOfWeek;
      StartTime?: string;
      EndTime?: string;
      Date?: string;
      Description?: string;
      /**
       * Entity type: OpeningHoursType
       */
      TypeID?: number;
      /**
       * Name of the OpeningHoursType, used when TypeID is not set
       */
      TypeName?: string;
    }

  }

  export interface ImportOrganizationUnitsResponse {
    Created: { [key: string]: number };
    Updated: { [key: string]: number };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Returns all data of a list of organizationunits. Since this service is not publicly available, this will return all information about the OUs.
   */
  export interface ListOrganizationUnitsDetailed {
    /**
     * Indicate some properties that will be omitted in the response, to keep the responsesize down
     */
    Excluded?: ListOrganizationUnitsDetailed.ExcludedProperties;
    PageConfig?: PageConfig<ListOrganizationUnitsFilter>;
  }

  export namespace ListOrganizationUnitsDetailed {
    export const enum ExcludedProperties {
      CustomFields = 1,
      Openinghours = 2,
      Address = 4
    }

  }

  export interface ListOrganizationUnitsFilter {
    /**
     * Entity type: OrganizationUnit
     */
    IDs?: number[];
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Name?: string;
    BackendIDs?: string[];
    NameOrBackendID?: string;
    /**
     * Entity type: Country
     */
    CountryIDs?: string[];
    /**
     * Filters organization units that have one of the given types.
     */
    TypeID?: number;
    StatusID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    ParentID?: number;
    /**
     * Entity type: Company
     */
    CompanyID?: number;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    /**
     * Entity type: VisibilityGroup
     */
    VisibilityGroupID?: number;
    /**
     * Entity type: RoleSet
     */
    RoleSetID?: number;
    Functionality?: string;
    FunctionalityScope?: FunctionalityScope;
    /**
     * Ignored when a functionality is applied.
     */
    IsArchived?: boolean;
    /**
     * Entity type: CustomField
     */
    CustomFields?: { [key: number]: CustomFieldValue };
  }

  export interface ListOrganizationUnitsDetailedResponse {
    Result?: PagedResult<ListOrganizationUnitsDetailedResponse.OrganizationUnit>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListOrganizationUnitsDetailedResponse {
    export interface OrganizationUnit {
      /**
       * Entity type: OrganizationUnit
       */
      ID?: number;
      BackendID?: string;
      /**
       * Entity type: Company
       */
      CompanyID?: number;
      /**
       * Entity type: OrganizationUnit
       */
      ParentID?: number;
      Name?: string;
      Description?: string;
      EmailAddress?: string;
      PhoneNumber?: string;
      Type?: OrganizationUnitTypes;
      Status?: OrganizationUnitStatus;
      Latitude?: number;
      Longitude?: number;
      Address?: AddressDto;
      Website?: string;
      BIC?: string;
      UpcomingOpeningHours?: WeekOpeningsDto[];
      RegularOpeningHours?: RegularOpeningHours[];
      CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
      /**
       * Entity type: Currency
       */
      CurrencyID?: string;
      CountryID?: string;
      IsArchived?: boolean;
    }

  }

  /**
   * Returns summaries of a list of organizationunits. Since this service is publicly available, this will return minimal information (aka a summary) about the OUs.
   */
  export interface ListOrganizationUnitSummaries {
    PageConfig?: PageConfig<ListOrganizationUnitsFilter>;
  }

  export interface ListOrganizationUnitSummariesResponse {
    Result?: PagedResult<ListOrganizationUnitSummariesResponse.OrganizationUnit>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListOrganizationUnitSummariesResponse {
    export interface OrganizationUnit {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
      /**
       * Entity type: OrganizationUnit
       */
      ParentID?: number;
      /**
       * Entity type: Country
       */
      CountryID: string;
      /**
       * Entity type: Language
       */
      LanguageID?: string;
      /**
       * Entity type: Currency
       */
      CurrencyID: string;
      Address?: AddressDto;
      PhoneNumber?: string;
      Latitude?: number;
      Longitude?: number;
    }

  }

  /**
   * Service that returns OrganizationUnitDtos that are approximately in range of the given latitude and longitude. The result are returned in ascending order.
   * 
   * This service is useful for displaying a list of the nearest shops (eg: checkout and choosing a pick-up shop).
   * 
   * The page size `Limit` has a maximum value of `100` for this service.
   */
  export interface ListShopsByProximity {
    /**
     * Latitude of a user or device of some kind to search stores that are nearby.
     * Range: -90-90
     */
    Latitude: number;
    /**
     * Longitude of a user or device of some kind to search stores that are nearby.
     * Range: -180-180
     */
    Longitude: number;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListShopsByProximityResponse {
    Result?: PagedResult<ListShopsByProximityResponse.ShopInfo>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListShopsByProximityResponse {
    export interface ShopInfo {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
      Description: string;
      Address: AddressDto;
      PhoneNumber: string;
      Latitude: number;
      Longitude: number;
      UpcomingOpeningHours: WeekOpeningsDto[];
      RegularOpeningHours: RegularOpeningHours[];
    }

  }

  /**
   * List the Shop OrganizationUnits in a certain area
   * 
   * Included are the OpeningHours in the next 7 days, and the Regular OpeningHours.
   * 
   * This service is useful for showing all shops in a map, where you want to search in a given rectangle.
   */
  export interface ListShopsInArea {
    NorthWest: ListShopsInArea.Coordinate;
    SouthEast: ListShopsInArea.Coordinate;
    Status?: OrganizationUnitStatus;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export namespace ListShopsInArea {
    export interface Coordinate {
      Latitude: number;
      Longitude: number;
    }

  }

  export interface ListShopsInAreaResponse {
    Result?: PagedResult<ListShopsInAreaResponse.ShopInfo>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListShopsInAreaResponse {
    export interface ShopInfo {
      ID: number;
      Name: string;
      Address: AddressDto;
      PhoneNumber: string;
      Latitude: number;
      Longitude: number;
      UpcomingOpeningHours: WeekOpeningsDto[];
      RegularOpeningHours: RegularOpeningHours[];
    }

  }

  /**
   * Get Organization Unit Notes
   */
  export interface GetOrganizationUnitNotes {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetOrganizationUnitNotesResponse {
    Notes: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Set Organization Unit Notes
   */
  export interface SetOrganizationUnitNotes {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    Notes: string;
  }

  /**
   * Update custom fields for multiple organization units at once.
   */
  export interface UpdateCustomFieldsForOrganizationUnits {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * When set, OrganizationUnitIDs will be ignored and instead all organization units for this set will be updated
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * The values in here will be merged with existing custom field values
     */
    CustomFields?: CustomFieldKeyValue[];
  }

  /**
   * Updates the basic information associated with an OrganizationUnit. This service can be used to only update a subset of the settings of the OrganizationUnit by providing only the fields you want to update.
   * 
   * If a field is not part of the request message (or has value `undefined`) then the setting is not updated. If the field is present but has a value of `null` then it's assumed you want to unset the setting.
   */
  export interface UpdateOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
    /**
     * Entity type: Company
     */
    CompanyID?: number;
    Name?: string;
    Description?: string;
    Status?: OrganizationUnitStatus;
    Latitude?: number;
    Longitude?: number;
    BankAccount?: string;
    BranchNumber?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    Address?: AddressDataDto;
    Website?: string;
    BIC?: string;
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
    EstablishmentNumber?: string;
  }

  export namespace UpdateOrganizationUnit {
    export interface OpeningHour {
      /**
       * Entity type: OpeningHours
       */
      ID?: number;
      /**
       * Entity type: OpeningHoursType
       */
      TypeID?: number;
      DayOfWeek?: DayOfWeek;
      Date?: string;
      Description?: string;
      IsClosed?: boolean;
      StartTime?: string;
      EndTime?: string;
      IsActive?: boolean;
    }

  }

  /**
   * Updates the OrganizationUnit's settings. This service can be used to only update a subset of the settings of the OrganizationUnit by providing only the fields you want to update.
   * If a field is not part of the request message (or has value `undefined`) then the setting is not updated. If the field is present but has a value of `null` then it's assumed you want to unset the setting.
   */
  export interface UpdateOrganizationUnitSettings {
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    ParentID?: number;
    BackendID?: string;
    BackendRelationID?: string;
    GlobalLocationNumber?: string;
    RegisterCashLimit?: number;
    SafeCashLimit?: number;
    /**
     * Entity type: CashHandler
     */
    CashHandlerID?: number;
    /**
     * Entity type: TaxProvider
     */
    TaxProviderID?: number;
    /**
     * Min: 0
     */
    CashFloat?: number;
    Type?: OrganizationUnitTypes;
    Subnet?: string;
    UseForAccounting?: boolean;
    /**
     * Entity type: User
     */
    AttachedToUserID?: number;
    IpAddress?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: CountrySubdivision
     */
    CountrySubdivisionID?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    TimeZone?: string;
    /**
     * Entity type: Assortment
     */
    AssortmentID?: number;
    /**
     * Entity type: RoleSet
     */
    RoleSetID?: number;
    CostPriceCalculationMethod?: CostPriceCalculationMethod;
    /**
     * Entity type: OrganizationUnit
     */
    ReturnOrganizationUnitID?: number;
    EnableEndlessSupplierStock?: boolean;
    /**
     * Entity type: VisibilityGroup
     */
    VisibilityGroupID?: number;
    /**
     * Entity type: Company
     */
    CompanyID?: number;
    Name?: string;
    Description?: string;
    Status?: OrganizationUnitStatus;
    Latitude?: number;
    Longitude?: number;
    BankAccount?: string;
    BranchNumber?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    Address?: AddressDataDto;
    Website?: string;
    BIC?: string;
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
    ForceLocalMode?: boolean;
  }

  /**
   * Add a discount coupon to an order
   */
  export interface AddDiscountCouponToOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    CouponCode: string;
  }

  export interface AddDiscountToOrderResponse {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    DiscountIsApplied: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Add a manual Discount to an order
   */
  export interface AddManualDiscountToOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    DiscountAmount?: number;
    Reason?: string;
    CustomFields?: CustomFieldKeyValue[];
    OrderLines?: OrderLineWithQuantity[];
  }

  export interface OrderLineWithQuantity {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    Quantity?: number;
  }

  /**
   * Add a loyalty Discount to an order
   */
  export interface AddLoyaltyDiscountToOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    /**
     * Min: 1
     */
    NumberOfTimesToApply?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
  }

  /**
   * Cancel a discount order line.
   * 
   * When the discount of the given line is a coupon triggerd discount, the coupon will be removed from the order.
   * When the discount of the given line is a manual discount, the manual discount will be cancelled.
   * When the discount of the given line is an automatic discount, the discount will be disabled on the order. To re-enable it you must call the 'EnableDisabledDiscountOnOrder' service. You can check which discount are disabled on an order by calling 'ListDisabledDiscountsOnOrder'
   */
  export interface CancelDiscountOrderLine {
    /**
     * Entity type: Order
     */
    OrderLineID: number;
  }

  /**
   * Get discount product options for a specific discount line
   */
  export interface GetDiscountProductOptionsForOrderLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    IncludedProperties?: string[];
  }

  export interface GetDiscountProductOptionsForOrderLineResponse {
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    ActionType: string;
    ActionSelectionData: any;
    /**
     * Entity type: Product
     */
    CurrentSelection?: number;
    SelectionOptions: any[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get discount product options for order
   */
  export interface GetDiscountProductOptionsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    IncludedProperties?: string[];
  }

  export interface GetDiscountProductOptionsForOrderResponse {
    DiscountOptions: GetDiscountProductOptionsForOrderResponse.DiscountOption[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetDiscountProductOptionsForOrderResponse {
    export interface DiscountOption {
      /**
       * Entity type: Discount
       */
      DiscountID: number;
      ActionType: string;
      ActionSelectionData: any;
      LineOptions: GetDiscountProductOptionsForOrderResponse.DiscountLineOption[];
    }

    export interface DiscountLineOption {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      /**
       * Entity type: Product
       */
      CurrentSelection?: number;
      SelectionOptions: any[];
    }

  }

  /**
   * Set the product selection for a specific discount line
   */
  export interface SetDiscountProductOption {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * When set to 'true' selection must be within the given product options
     */
    DisallowSelectionOutsideProductOptions?: boolean;
  }

  /**
   * Add a Product to an Order
   * 
   * A product can be defined by `ProductID` or `Barcode`.
   * If the product is unstackable (e.g. gift cards, same product added with different serial numbers), new orderlines are created.
   */
  export interface AddProductToOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Barcode?: string;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Min: 9000
     */
    QuantityOrdered?: number;
    LineActionType: LineActionTypes;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    GroupID?: string;
    /**
     * If the product allows its price to be modified, you can specify the desired price using this field.
     */
    UnitPriceInTax?: number;
    Children: AddProductToOrder.ChildOrderLine[];
    /**
     * This will always create a new line, regardless of whether a line with the same product ID was found in the order.
     */
    ForceNewLine?: boolean;
    /**
     * Optionally override the default description that is generated for the new OrderLine. If specified, this OrderLine will not be stacked on any existing OrderLines in the Order of the same Product (unless they use the same Description). Instead, a new OrderLine will be created.
     */
    Description?: string;
    /**
     * Specify this field to add the new line as a child of the specified parent
     * Entity type: OrderLine
     */
    ParentID?: number;
    SerialNumber?: string;
  }

  export namespace AddProductToOrder {
    export interface ChildOrderLine {
      /**
       * Entity type: Product
       */
      ProductID: number;
      /**
       * Optionally override the default description that is generated for the new OrderLine.
       */
      Description: string;
      /**
       * Min: 9000
       */
      QuantityOrdered?: number;
      SerialNumber?: string;
    }

  }

  export interface AddProductToOrderResponse {
    Result: AddProductToOrderResponse.AddProductToOrderResult[];
    /**
     * Entity type: Order
     */
    OrderID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace AddProductToOrderResponse {
    export interface ChildOrderLine {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      /**
       * Entity type: Product
       */
      ProductID?: number;
    }

    /**
     * Created or updated OrderLineIDs
     */
    export interface AddProductToOrderResult {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      Children: AddProductToOrderResponse.ChildOrderLine[];
    }

  }

  /**
   * Adds a service product to an order.
   */
  export interface AddServiceProductToOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    Description?: string;
    UnitPriceInTax?: number;
    UnitCost?: number;
  }

  export interface AddServiceProductToOrderResponse {
    /**
     * Created or updated `OrderLineID`
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Attach addresses to specified order(s), requiring either `OrderID` or `OrderIDs`.
   */
  export interface AttachAddressToOrder {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: Order
     */
    OrderIDs?: number[];
    /**
     * Entity type: Address
     */
    BillingAddressID?: number;
    /**
     * Entity type: Address
     */
    ShippingAddressID?: number;
    /**
     * Entity type: AddressBook
     */
    BillingAddressBookID?: number;
    /**
     * Entity type: AddressBook
     */
    ShippingAddressBookID?: number;
  }

  export interface AttachAddressToOrderResponse {
    CreditcardDisabled: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Attaches a consumer company to an order. Optionally, provide a user ID to associate with it.
   */
  export interface AttachConsumerCompanyToOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Company
     */
    CompanyID: number;
    /**
     * Entity type: User
     */
    UserID?: number;
  }

  export interface AttachConsumerCompanyToOrderResponse {
    /**
     * Entity type: Company
     */
    ID: number;
    VatNumberValidationResult: AuditingVatNumberValidationResult;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum AuditingVatNumberValidationResult {
    Unknown = 0,
    Success = 1,
    Failure = -1
  }

  /**
   * Attach a Customer to an Order. When no UserID is provided the current user will be attached. If the selected User has addresses, these will also be assigned to the Order.
   */
  export interface AttachCustomerToOrder {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Attachment Metadata to be added in the Order Ledger's Description.
     */
    AttachmentMetadata?: string;
  }

  /**
   * Detach a Customer from an Order. The addresses on the Order will also be cleared.
   */
  export interface DetachCustomerFromOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Attempts to autocomplete the order by:
   * 
   * - Cancelling the lines that can still be cancelled
   * - Invoicing the lines that've been (partially) shipped
   * - Optionally creating a payment to bring the open amount to 0
   * 
   * :bikini: __The actions this service performs are irreverisble__
   * 
   * *With great power comes great responsibility*
   * -Uncle Ben
   */
  export interface AutocompleteOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface AutocompleteOrderResponse {
    IsCompleted: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Cancel a complete order or a subset of lines.
   * 
   * The order can be identified by an OrderID or by BackendID + BackendSystemID, the lines can be identified by an OrderLineID or by BackendID.
   * 
   * The result will tell you if it was successful.
   */
  export interface CancelOrder {
    /**
     * Reference to the order that is being cancelled - required when `OrderID` is omitted
     */
    BackendID?: string;
    /**
     * Reference to the system from which the order originated - required when `OrderID` is omitted
     */
    BackendSystemID?: string;
    /**
     * ID of the order that is being cancelled - required when `BackendID` and `BackendSystemID` are omitted
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Lines to cancel - or, if none are specified, all open lines of the order will be cancelled
     */
    OrderLines?: CancelOrder.LineToCancel[];
    /**
     * Forcing cancellations is not recommended! Requires `ForceCancelOrder` functionality.
     * 
     *       Only use this when a normal cancellation does not work, because the exported party (warehouse) does not accept it, and they have agreed that
     *       they too will manually cancel it in their systems. This will skip all external validation and cause discrepancies in this order status and stock levels.
     */
    Force?: boolean;
  }

  export namespace CancelOrder {
    export interface LineToCancel {
      /**
       * Reference to the orderline that is being cancelled - required when `OrderLineID` is omitted
       */
      BackendID?: string;
      /**
       * ID of the orderline that is being cancelled - required when `BackendID` is omitted
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      /**
       * Quantity to be cancelled. If left blank the full order line will be cancelled
       */
      Quantity?: number;
    }

  }

  export interface CancelOrderResponse {
    Result: OrderCancellationOptions;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum OrderCancellationOptions {
    CanBeCancelled = 0,
    AlreadyCancelled = 1,
    ShouldBeRequested = 2,
    MustBeRequested = 3,
    CannotBeCancelled = 4
  }

  /**
   * Update some OrderLines to a state so that they can be carried out in a store
   * 
   * If the products should be ordered from a supplier first, the `OrderTheLinesFromASupplier` property should be true.
   * 
   * When no OrderLineIDs are provided all eligable lines in the Order are updated
   */
  export interface ChangeOrderLinesToCarryOut {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineIDs?: number[];
    /**
     * Set to true to indicate that you don't have stock available for carry-out and that you want to order the products from a supplier when the order is placed.
     */
    MustBeOrdered?: boolean;
  }

  /**
   * Update some OrderLines to a state so that they can be delivered to the ShippingAddress on the order
   * 
   * When no OrderLineIDs are provided all eligable lines in the Order are updated
   */
  export interface ChangeOrderLinesToDelivery {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineIDs?: number[];
  }

  /**
   * Update some OrderLines to a state so that they can be pickup up in a store by the customer attached to the order
   * 
   * If no PickupOrganizationUnit was choses yet, it should be provided in the `PickupOrganizationUnitID` property.
   * 
   * When no OrderLineIDs are provided all eligable lines in the Order are updated
   */
  export interface ChangeOrderLinesToPickup {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineIDs?: number[];
    /**
     * Will keep the current value when not provided.
     * Entity type: OrganizationUnit
     */
    PickupOrganizationUnitID?: number;
  }

  /**
   * Check if order BackendID exists
   */
  export interface CheckOrderBackendIDExists {
    BackendSystemID?: string;
    BackendID?: string;
  }

  export interface BackendIDExistsResponse {
    Exists: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Check if shipment BackendID exists
   */
  export interface CheckShipmentBackendIDExists {
    BackendSystemID?: string;
    BackendID?: string;
  }

  /**
   * Check if the order has fraudulent shipping or billing addresses
   */
  export interface CheckOrderAddressFraud {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface CheckOrderAddressFraudResponse {
    HasFraudulentAddress: boolean;
    HasFraudulentShippingAddress: boolean;
    HasFraudulentBillingAddress: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Complete an order and all its order lines without invoking any side effects.
   */
  export interface CompleteOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface CompleteOrderResponse {
    IsCompleted: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Create a correction on an already invoiced line.
   * 
   * This can be used to refund a partial amount on a completed OrderLine, in cases where the product should still be returnable.
   * 
   * Specify either `OrderLineID` and `CorrectionAmount`, or `Lines`.
   * 
   * - If the product is not returnable anymore, a return without retake should be created
   * - This will result in a new line that will be invoiced immediately and shipped by default (AutoProcess.Ship is the default variant).
   * - If the shipping isn't desired, use AutoProcess.None;
   * - If a refund is desired, use AutoProcess.ShipAndRefund.
   */
  export interface CreateInvoicedOrderLineCorrection {
    Lines?: CreateInvoicedOrderLineCorrection.CreateInvoicedOrderLineCorrectionLine[];
    /**
     * @default Ship
     */
    AutoProcess?: AutoProcess;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Min: 0
     */
    CorrectionAmount?: number;
    /**
     * Entity type: UnitPriceCorrectionReason
     */
    CorrectionReasonID?: number;
  }

  export namespace CreateInvoicedOrderLineCorrection {
    export interface CreateInvoicedOrderLineCorrectionLine {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      /**
       * Min: 0
       */
      CorrectionAmount: number;
      /**
       * Entity type: UnitPriceCorrectionReason
       */
      CorrectionReasonID?: number;
    }

  }

  export const enum AutoProcess {
    Ship = 0,
    ShipAndRefund = 1,
    None = 2
  }

  /**
   * Converts an order to an offer
   */
  export interface CreateOfferFromOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    OfferExpirationDate?: string;
  }

  /**
   * Creates and sets an app token on specified order, to allow accessing it from an anonymous context. The order may not have a Customer attached.
   */
  export interface CreateOrderAppToken {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface CreateOrderAppTokenResponse {
    Token: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Create an Order from an Offer specified by `OrderID`.
   */
  export interface CreateOrderFromOffer {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface CreateOrderFromOfferResponse {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Create a new order ledger of the given type
   */
  export interface CreateOrderLedger {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    OrderLedgerType?: string;
    Value?: string;
    Description?: string;
    CreationTime?: string;
  }

  /**
   * Create a price correction on the order line, specified by `OrderID` and `OrderLineID`. Provide the new `UnitPrice` this order line should have, and include
   * a property `IncludingTax` to indicate if you mean IN or EX taxes.
   */
  export interface CreateOrderLineUnitPriceCorrection {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    UnitPrice: number;
    IncludingTax?: boolean;
    /**
     * Entity type: UnitPriceCorrectionReason
     */
    CorrectionReasonID?: number;
  }

  /**
   * Reset the unitprice on an OrderLine with a price correction.
   */
  export interface RemoveOrderLineUnitPriceCorrection {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
  }

  /**
   * Create a new Order of the given Type
   */
  export interface CreateOrder {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    Type: OrderTypes;
    ClientOrderID?: string;
  }

  export interface CreateOrderResponse {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Create price corrections for products when a PO was completed that had incorrect prices.
   * 
   * We'll try to do a best-effort correction on the costprice of the product if the receiving OU uses WAC.
   * To track some product information, we'll store that on the description of the order line.
   */
  export interface CreatePurchaseOrderLineUnitPriceCorrection {
    /**
     * The backend ID to set on the correction order.
     */
    OrderBackendID?: string;
    /**
     * Entity type: OrderLine
     * @deprecated No longer supported, use `Lines`. Any value provided to this field will be ignored.
     */
    PurchaseOrderLineID?: number;
    /**
     * @deprecated Use `Lines`
     * Min: 0
     */
    UnitPrice?: number;
    /**
     * Entity type: Product
     * @deprecated Use `Lines`
     */
    ProductID?: number;
    /**
     * @deprecated Use `Lines`
     */
    OldPrice?: number;
    /**
     * @deprecated Use `Lines`
     */
    QuantityOrdered?: number;
    /**
     * Entity type: OrganizationUnit
     */
    SoldFromOrganizationUnitID: number;
    /**
     * Entity type: OrganizationUnit
     */
    SoldToOrganizationUnitID: number;
    Lines: PurchaseOrderLineCorrection[];
  }

  export interface PurchaseOrderLineCorrection {
    /**
     * Min: 0
     */
    UnitPrice: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    OldPrice: number;
    QuantityOrdered: number;
  }

  export interface CreatePurchaseOrderLineUnitPriceCorrectionResponse {
    /**
     * Entity type: OrderLine
     * @deprecated Use `Results`
     */
    CorrectionPurchaseOrderLineID?: number;
    /**
     * Entity type: Order
     * @deprecated Use `Results`
     */
    OrderID?: number;
    Results: PurchaseOrderLineCorrectionResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface PurchaseOrderLineCorrectionResult {
    /**
     * Entity type: OrderLine
     */
    CorrectionPurchaseOrderLineID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
  }

  /**
   * Get additional order information intended for delivery data.
   */
  export interface GetDeliveryOrderData {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetDeliveryOrderDataResponse {
    DeliveryOrderData: DeliveryOrderData;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface DeliveryOrderData {
    DefaultShippingMethodID?: number;
    ShippingType: string;
    ShippingPrice: number;
    DeliveryService: string;
    PickUpPointID: string;
    PickUpPointName: string;
    AdditionalPickUpPointInformation: string;
    ExpectedDeliveryDate?: string;
    DeliveryTimeFrom?: string;
    DeliveryTimeTo?: string;
  }

  /**
   * Set additional order information intended for delivery data.
   */
  export interface SetDeliveryOrderData {
    /**
     * Entity type: Order
     */
    OrderID: number;
    DeliveryOrderData: DeliveryOrderData;
  }

  /**
   * Detaches the consumer company from an order.
   */
  export interface DetachConsumerCompanyFromOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Detach the given Order from the attached customer and a session. A ReminderToken will be returned to be able to use the Order later with the `RecoverShoppingCartService`.
   * 
   * This service can be used to transfer an Order to a different User:
   * - DetachOrder
   * - Logout
   * - Login
   * - RecoverShoppingCart
   */
  export interface DetachOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface DetachOrderResponse {
    ReminderToken: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Indicate that this was the current order, but has been dismissed.
   * 
   * This is purely a ledger and does not affect the order in any other way.
   */
  export interface DismissOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Make a new `Order` based on an existing one.
   * 
   * * Optionally you can provide some OrderLineIDs to duplicate only a subset of the order.
   * * When an `OrganizationUnitID` is set, the Order will be created Originating and SoldFrom the specified OrganizationUnit
   * * To include the orignal GiftWrapping the flag `IncludeGiftWrapping` should be set to true. When combining this with a subset of lines, this can generate an error when some wrapped lines are not duplicated.
   * * To ignore shipping costs, set `IgnoreShippingCosts` to true (defaults to false)
   */
  export interface DuplicateOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineIDs?: number[];
    /**
     * @default false
     */
    IncludeGiftWrapping?: boolean;
    /**
     * @default false
     */
    IncludeBundles?: boolean;
    /**
     * @default false
     */
    IgnoreShippingCosts?: boolean;
    DuplicationReason?: string;
    LineActionType?: LineActionTypes;
  }

  export interface DuplicateOrderResponse {
    /**
     * Entity type: Order
     */
    DuplicatedOrderID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get the fiscal properties of an Order.
   */
  export interface GetFiscalOrderData {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetFiscalOrderDataResponse {
    FiscalID: string;
    VatNumber: string;
    FiscalRemark?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update the fiscal properties on an Order.
   */
  export interface SetFiscalOrderData {
    /**
     * Entity type: Order
     */
    OrderID: number;
    FiscalID?: string;
    VatNumber?: string;
    FiscalRemark?: string;
  }

  /**
   * Finalize order placement for the given OrderID, returning a validation summary.
   */
  export interface ForcePlaceOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface ForcePlaceOrderResponse {
    ValidationResult: OrderExportValidationResult;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface OrderExportValidationResult {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Result: OrderExportValidationResults;
    Messages: OrderExportValidationResultMessage[];
  }

  export const enum OrderExportValidationResults {
    Unknown = 0,
    Valid = 1,
    Invalid = 2,
    NothingToBeExported = 3
  }

  export interface OrderExportValidationResultMessage {
    Code: string;
    Message: string;
  }

  /**
   * Retrieve an order view for the given OrderID and LogicalLevel, including configurable fields.
   */
  export interface GetConfigurableOrderView {
    /**
     * Entity type: Order
     */
    OrderID: number;
    LogicalLevel: string;
    GroupByPropertyType: string;
    IncludeAllChildren?: boolean;
    ProductProperties?: string[];
  }

  export interface GetConfigurableOrderViewResponse {
    PropertyGroups: PropertyGroup[];
    OtherLines: Record<'NormalProduct' | 'Discount' | 'ExtraCosts' | 'ShippingCosts' | 'ReturnCosts' | 'PriceCorrection' | 'Service' | 'GiftWrappingCosts' | 'DownPayment', SimpleOrderLine[]>;
    TotalAmount: number;
    TotalAmountInTax: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface PropertyGroup {
    PropertyValue: any;
    TotalAmount: number;
    TotalAmountInTax: number;
    Quantity: number;
    ChildGroups: ConfigurableGroup[];
  }

  export interface ConfigurableGroup {
    ProductID: number;
    Properties: any;
    LogicalLevel: string;
    ConfigurableProperty: string;
    Value: any;
    Values: any[];
    TotalAmount: number;
    TotalAmountInTax: number;
    Quantity: number;
    Children: ConfigurableGroup[];
    OrderLines: ConfigurableOrderLine[];
  }

  export interface ConfigurableOrderLine {
    OrderLineID: number;
    Quantity: number;
    TotalAmount: number;
    TotalAmountInTax: number;
  }

  export interface SimpleOrderLine {
    OrderLineID: number;
    ProductID?: number;
    Properties: any;
    Description: string;
    Quantity: number;
    TotalAmount: number;
    TotalAmountInTax: number;
  }

  /**
   * Returns a list of custom status changes for a specific order
   */
  export interface GetOrderCustomStatusLedger {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetOrderCustomStatusLedgerResponse {
    Results: GetOrderCustomStatusLedgerResponse.Model[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetOrderCustomStatusLedgerResponse {
    export interface Model {
      Description: string;
      BackendID: string;
      Name: string;
      CreationTime: string;
      Sequence: number;
      Data: { [key: string]: any };
    }

  }

  /**
   * Return the current order links for the given order
   */
  export interface GetOrderLinks {
    /**
     * Entity type: Order
     */
    ID: number;
  }

  export interface GetOrderLinksResponse {
    PrimaryRelations: SingleOrderLink[];
    RelatedRelations: SingleOrderLink[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface SingleOrderLink {
    OrderLink: OrderDataForSingleOrderLink;
    Type: AssociationTypeForSingleOrderLink;
  }

  export interface OrderDataForSingleOrderLink {
    /**
     * Entity type: Order
     */
    ID: number;
    /**
     * Entity type: OrderLink
     */
    OrderLinkID: number;
  }

  export interface AssociationTypeForSingleOrderLink {
    /**
     * Entity type: OrderLinkType
     */
    ID: number;
    Name: string;
  }

  /**
   * Get an Order by ID.
   * 
   * This service is readonly, it will not update the order just by calling it like the `GetShoppingCart` service does.
   * 
   * To include the result of `GetRequiredDataForOrder`, the property `AdditionalOrderDataOptions.RequiredFor` can be set to the desired level of requirements.
   * To include the result of `GetProductRequirementValuesForOrder`, the property `AdditionalOrderDataOptions.IncludeProductRequirements` can be set to `true`.
   * To include the result of `GetGiftWrappingOptionsForOrder` and `GetAvailableGiftWrappingLinesForOrder`, the property `AdditionalOrderDataOptions.IncludeGiftWrapping` can be set to `true`.
   * To include the result of `PrefigureDiscounts` and `GetPotentialDiscountsForOrder`, the property `AdditionalOrderDataOptions.IncludePrefigureDiscounts` can be set to `true`.
   * To include the result of `GetPickProductDiscountOptionsForOrder`, the property `AdditionalOrderDataOptions.IncludePickProductOptions` can be set to `true`.
   * To include the result of `ListAvailableShippingMethods`, the property `AdditionalOrderDataOptions.IncludeAvailableShippingMethods` can be set to `true`.
   * To include the result of `GetAvailablePaymentMethods`, the property `AdditionalOrderDataOptions.IncludeAvailablePaymentMethods` can be set to `true`.
   * To include the result of `GetAvailableRefundPaymentMethodsForOrder`, the property `AdditionalOrderDataOptions.IncludeAvailableRefundPaymentMethods` can be set to `true`.
   * To include the result of `ValidateOrderShipment`, the property `AdditionalOrderDataOptions.IncludeValidateShipment` can be set to `true`.
   * To include the available actions for the PaymentTransactions, the property `AdditionalOrderDataOptions.IncludePaymentTransactionActions` can be set to `true`.
   */
  export interface GetOrder {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    IncludeAllPayments?: boolean;
    ShowOnlyShippableLines?: boolean;
    AdditionalOrderDataOptions?: AdditionalOrderDataOptions;
  }

  export interface AdditionalOrderDataOptions {
    ProductProperties: string[];
    RequiredFor?: RequiredFor;
    IncludeProductRequirements: boolean;
    IncludeGiftWrapping: boolean;
    IncludeGiftCardBusinessRules: boolean;
    IncludePrefigureDiscounts: boolean;
    IncludePickProductOptions: boolean;
    IncludeAvailableShippingMethods: boolean;
    IncludeAvailablePaymentMethods: boolean;
    IncludeAvailableRefundPaymentMethods: boolean;
    IncludeValidateShipment: boolean;
    IncludePaymentTransactionActions: boolean;
    IncludeCheckoutOptions: boolean;
    IncludeOrganizationUnitData: boolean;
    IncludeCustomerCustomFields: boolean;
  }

  export const enum RequiredFor {
    PlaceOrder = 1,
    Payment = 2,
    Ship = 4,
    Invoice = 8,
    All = 15
  }

  export interface GetOrderResponse {
    Result: OrderDto;
    Amounts: OpenOrderAmounts;
    HasMoreLines: boolean;
    AdditionalOrderData?: AdditionalOrderData;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface OrderDto {
    GlobalID: string;
    /**
     * Entity type: Order
     */
    ID: number;
    BackendID: string;
    BackendSystemID: string;
    Type: OrderTypes;
    Definition: OrderDefinitionModel;
    OrderCustomStatus?: OrderCustomStatusModel;
    OrderCustomType?: OrderCustomTypeModel;
    /**
     * Entity type: User
     */
    CustomerID?: number;
    Customer: UserDto;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    /**
     * Only populated in case the CreatedBy user in an employee
     */
    CreatedByFullName: string;
    CreationTime: string;
    Payments: PaymentTransactionDto[];
    /**
     * Entity type: Address
     */
    ShippingAddressID?: number;
    /**
     * Entity type: Address
     */
    BillingAddressID?: number;
    /**
     * Entity type: Address
     */
    PickupAddressID?: number;
    ShippingAddress: AddressDto;
    BillingAddress: AddressDto;
    PickupAddress: AddressDto;
    Lines: OrderLineDto[];
    OfferExpirationDate?: string;
    IsOffer: boolean;
    IsExpiredOffer?: boolean;
    IsLocked: boolean;
    OriginalTotalAmount?: number;
    OriginalTotalAmountInTax?: number;
    TotalAmount: number;
    TotalTaxAmount: number;
    TotalAmountInTax: number;
    TotalAmountInvoiced: number;
    TotalEcoTaxInTax?: number;
    TaxTable: TaxAmount[];
    IsCompleted: boolean;
    IsDelivered: boolean;
    IsShipped: boolean;
    IsPaid: boolean;
    IsCaptured: boolean;
    IsInvoiced: boolean;
    IsPlaced: boolean;
    CompletionDate?: string;
    CaptureDate?: string;
    ShipmentDate?: string;
    DeliveryDate?: string;
    InvoiceDate?: string;
    PaymentDate?: string;
    Status: OrderStatus;
    /**
     * Entity type: OrderHoldStatus
     */
    HoldStatusID?: number;
    Remark: string;
    CustomerOrderID: string;
    CustomerReference: string;
    TotalItems: number;
    HasDelivery: boolean;
    IdentificationID?: number;
    Properties: OrderProperties;
    Characteristics: OrderProperties;
    /**
     * Entity type: OrganizationUnit
     */
    OriginatingOrganizationUnitID: number;
    /**
     * Requested by setting AdditionalOrderDataOptions.IncludeOrganizationUnitData
     */
    OriginatingOrganizationUnitData?: OrganizationUnitData;
    /**
     * Entity type: OrganizationUnit
     */
    PickupOrganizationUnitID: number;
    /**
     * Requested by setting AdditionalOrderDataOptions.IncludeOrganizationUnitData
     */
    PickupOrganizationUnitData?: OrganizationUnitData;
    /**
     * Entity type: OrganizationUnit
     */
    SoldFromOrganizationUnitID: number;
    /**
     * Requested by setting AdditionalOrderDataOptions.IncludeOrganizationUnitData
     */
    SoldFromOrganizationUnitData?: OrganizationUnitData;
    /**
     * Entity type: OrganizationUnit
     */
    ShipFromOrganizationUnitID?: number;
    /**
     * Requested by setting AdditionalOrderDataOptions.IncludeOrganizationUnitData
     */
    ShipFromOrganizationUnitData?: OrganizationUnitData;
    /**
     * Entity type: OrganizationUnit
     */
    SoldToOrganizationUnitID?: number;
    /**
     * Requested by setting AdditionalOrderDataOptions.IncludeOrganizationUnitData
     */
    SoldToOrganizationUnitData?: OrganizationUnitData;
    /**
     * Entity type: OrganizationUnit
     */
    ShipToOrganizationUnitID?: number;
    /**
     * Requested by setting AdditionalOrderDataOptions.IncludeOrganizationUnitData
     */
    ShipToOrganizationUnitData?: OrganizationUnitData;
    /**
     * Entity type: VisibilityGroup
     */
    VisibilityGroupIDs: number[];
    CurrencyID: string;
    CustomStatusID?: number;
    PreferredPriceDisplayMode: OrderPreferredPriceDisplayMode;
    IsTaxExempt: boolean;
    FiscalID: string;
    FiscalRemark?: string;
    VatNumber: string;
    UserAgentApplication: string;
    UserAgentVersion: string;
    AllowPartialFulfillment: boolean;
    PlacementDate?: string;
    IgnoreDiscounts: boolean;
    IgnoreShippingCosts: boolean;
    IgnoreGiftWrappingCosts: boolean;
    /**
     * Entity type: Discount
     */
    DisabledDiscounts: number[];
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    IsConfirmed: boolean;
    Barcode: string;
    PriceLists?: PriceListModel[];
    BackfillInformation?: OrderBackfillInformation;
    IsDownPayment: boolean;
    TransferReference?: string;
    TransferredOrderID?: number;
    AutomaticCancellationDate?: string;
    /**
     * Entity type: CustomOrderType
     */
    CustomOrderTypeID?: number;
    /**
     * @deprecated Use `SelectedFulfillment` instead
     */
    SelectedFulfillmentOptions?: SelectedOrderFulfillmentOptions[];
    ClientOrderID?: string;
    TotalLineCount: number;
    TaxFreeInformation?: TaxFreeInformation;
    TotalLoyaltyProgramWithdrawals: OrderLoyaltyMutation[];
    TotalLoyaltyProgramDeposits: OrderLoyaltyMutation[];
    CustomerIdentifiers?: OrderCustomerIdentifiers;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    LoyaltyProgramValidated?: boolean;
    LoyaltyProgramName: string;
    LoyaltyProgramDescription: string;
    /**
     * The repair this order is associated with.
     */
    Repair?: RepairModel;
    /**
     * Information related to local mode, in case it was imported from LiveGuard.
     */
    LocalInformation?: LocalInformation;
    DisplayID: string;
    HasPresaleLines: boolean;
    HasProductSubscriptions: boolean;
    /**
     * Entity type: UserProductSubscription
     */
    UserProductSubscriptionID?: number;
    /**
     * Entity type: Company
     */
    CompanyID?: number;
    Company?: CompanyDto;
    /**
     * Indicates whether the company was explicitly attached to the order.
     */
    HasExplicitCompany: boolean;
    DisplayProperties: OrderDisplayProperties;
    Culture?: string;
    SelectedFulfillment: FulfillmentSelection;
  }

  export interface OrderDefinitionModel {
    Status: OrderDefinitionModel.Value;
    Type: OrderDefinitionModel.Value;
  }

  export namespace OrderDefinitionModel {
    export interface Value {
      BackendID: string;
      Title: string;
    }

  }

  export interface OrderCustomStatusModel {
    /**
     * Entity type: OrderCustomStatus
     */
    ID: number;
    BackendID: string;
    Name: string;
    Description: string;
  }

  export interface OrderCustomTypeModel {
    /**
     * Entity type: OrderCustomType
     */
    ID: number;
    BackendID: string;
    Name: string;
    Description: string;
  }

  export interface UserDto {
    /**
     * Entity type: User
     */
    ID: number;
    BackendID: string;
    CustomID: string;
    EmployeeNumber: string;
    BackendRelationID: string;
    EmailAddress: string;
    EmailAddressValidated: boolean;
    Initials: string;
    FirstName: string;
    LastName: string;
    FullName: string;
    DateOfBirth?: string;
    PlaceOfBirth: string;
    Gender: string;
    Type: UserTypes;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    IsDeleted: boolean;
    AccountType: UserAccountType;
    SingleSignOnOnly: boolean;
    AllowPasswordLogin: boolean;
    Nickname: string;
    Company: CompanyDto;
    BankAccount: string;
    IsDebtor: boolean;
    PhoneNumber: string;
    GravatarHash: string;
    Data: { [key: string]: string };
    TimeZone: string;
    FiscalID: string;
    SocialSecurityNumber: string;
    Title: string;
    Salutation: string;
    CreationTime: string;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    CreatedByFullName: string;
    /**
     * Entity type: VisibilityGroup
     */
    VisibilityGroupID?: number;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions: { [key: number]: CustomFieldValueWithOptions };
    Barcode: string;
    LastSuccessfulLogin?: string;
  }

  export interface TaxAmount {
    Rate: number;
    /**
     * Amount of tax for this rate
     */
    Amount: number;
    /**
     * TotalAmount that has this rate
     */
    Base: number;
    /**
     * TotalAmount including the tax (Base + Amount)
     */
    Total: number;
  }

  export const enum OrderStatus {
    Cart = 0,
    Order = 1
  }

  export const enum OrderProperties {
    None = 0,
    IsPickup = 1,
    CreatedByEmployee = 2,
    IsInterbranch = 4,
    IsB2B = 8,
    Duplicated = 16,
    /**
     * Indicates that the order was auto completed with force by a user.
     */
    Autocompleted = 32,
    /**
     * ReturnToSupplier indicates that the order will be returned from the store back to the supplier (RMA/CMA).
     */
    ReturnToSupplier = 128,
    /**
     * CustomTaxesApplied indicates that the order has custom taxes applied and other processes should not touch the taxes anymore.
     */
    CustomTaxesApplied = 256,
    /**
     * Replenishment indicates that this order is used to replenish a store/warehouse
     */
    Replenishment = 512,
    /**
     * Indicates that the SoldBy, which is normally determined automatically, has been manually overriden on the Order level.
     */
    SoldByOverridden = 1024,
    /**
     * Indicates that this order was created in localmode on liveguard and pushed to the cloud.
     */
    ImportedFromLiveGuard = 2048,
    IsTransferOrder = 4096,
    IsReturnsTransferOrder = 8192,
    IsOffer = 16384,
    IsUnified = 32768,
    /**
     * Indicates that this order has been returned, partially or completely, by another order.
     */
    IsReturned = 65536,
    /**
     * Indicates the order contains lines that have negative quantities to ship, aka, are returned lines.
     */
    HasReturnLines = 131072,
    DownPayment = 262144,
    /**
     * Indicates that the order is a restitution order
     */
    Restitution = 524288,
    /**
     * Indicates that the order is a repair order and contains products used during a repair
     */
    Repairs = 1048576,
    /**
     * Indicates that the order is the result of a return reversal.
     */
    IsReturnReversal = 2097152
  }

  export interface OrganizationUnitData {
    Name: string;
    BackendID?: string;
  }

  export const enum OrderPreferredPriceDisplayMode {
    InTax = 0,
    ExTax = 1
  }

  export const enum DiscountInvalidReasons {
    None = 0,
    /**
     * The coupon does not exist
     */
    NotExist = 1,
    /**
     * The coupon is not valid (yet)
     */
    NotValidYet = 2,
    /**
     * The coupon is expired
     */
    Expired = 3,
    /**
     * The coupon has already been used
     */
    HasAlreadyBeenUsed = 4,
    /**
     * The coupon code has already been added
     */
    CouponCodeAlreadyAdded = 5,
    /**
     * The manual discount does not meet all conditions
     */
    ManualValueIsInvalid = 6,
    /**
     * The discount does not apply to this order type
     */
    InvalidOrderType = 7,
    Invalid = 8
  }

  export interface PriceListModel {
    /**
     * Entity type: PriceList
     */
    ID: number;
    Name: string;
    BackendID: string;
  }

  export interface OrderBackfillInformation {
    /**
     * Original date when this order was created
     */
    OriginalCreationDate?: string;
    /**
     * Original date when this order was invoiced
     */
    OriginalInvoiceDate?: string;
    /**
     * Original invoicenumber of this order
     */
    OriginalInvoiceNumber?: string;
  }

  export interface SelectedOrderFulfillmentOptions {
    SameDayDelivery: SelectedOrderFulfillmentOptions.SameDayDeliveryOptions;
    OrderLineIDs: number[];
  }

  export namespace SelectedOrderFulfillmentOptions {
    export interface SameDayDeliveryOptions {
      UseSameDayDelivery: boolean;
    }

  }

  export interface TaxFreeInformation {
    Handler?: string;
    IsIssued?: boolean;
    IsVoided?: boolean;
    FormIdentifier?: string;
    UserIdentifier?: string;
    CanBePrinted?: boolean;
    DeviceTypeForPrinting?: FlagsEnumDto;
  }

  export interface FlagsEnumDto {
    /**
     * Entity type: Enum
     */
    ID: number;
    /**
     * Usually an internal & unchangable code - for display, use `Description`
     */
    Name: string;
    IDs: number[];
    Names: string[];
  }

  export interface OrderLoyaltyMutation {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID: number;
    BackendID: string;
    Name: string;
    Points: number;
  }

  export interface OrderCustomerIdentifiers {
    UserID?: string;
    UserSubscriptionID?: string;
    UserBackendID?: string;
    UserCustomID?: string;
    EmailAddress?: string;
  }

  export interface RepairModel {
    /**
     * Entity type: Repair
     */
    ID: number;
  }

  export interface LocalInformation {
    LocalInvoices: LocalInformation.LocalInvoice[];
  }

  export namespace LocalInformation {
    export interface LocalInvoice {
      InvoiceNumber: string;
      InvoiceDate?: string;
      PreviousSignature: string;
      Signature: string;
    }

  }

  export interface OrderDisplayProperties {
    Subtotal: number;
  }

  export interface FulfillmentSelection {
    NormalDelivery: FulfillmentSelection.NormalDeliverySelection;
    SameDayDelivery: FulfillmentSelection.SameDayDeliverySelection;
    PickupDropoff: FulfillmentSelection.PickupDropoffSelection;
  }

  export namespace FulfillmentSelection {
    export interface NormalDeliverySelection {
      /**
       * Entity type: OrderLine
       */
      OrderLineIDs?: number[];
      OptionID?: string;
      OptionName?: string;
      SubOptionID?: string;
      SubOptionName?: string;
      Carrier?: FulfillmentSelection.CarrierInfo;
    }

    export interface SameDayDeliverySelection {
      /**
       * Entity type: OrderLine
       */
      OrderLineIDs?: number[];
      OptionID?: string;
      OptionName?: string;
      SubOptionID?: string;
      SubOptionName?: string;
      Carrier?: FulfillmentSelection.CarrierInfo;
    }

    export interface PickupDropoffSelection {
      /**
       * Entity type: OrderLine
       */
      OrderLineIDs?: number[];
      OptionID?: string;
      OptionName?: string;
      SubOptionID?: string;
      SubOptionName?: string;
      Carrier?: FulfillmentSelection.CarrierInfo;
      Location?: FulfillmentSelection.LocationInfo;
    }

    export interface LocationInfo {
      ID: string;
      Name: string;
      ZipCode: string;
      CountryID: string;
      AddressLines: string[];
      Latitude: number;
      Longitude: number;
    }

    export interface CarrierInfo {
      Name?: string;
      LogoUrl?: string;
    }

  }

  export interface OpenOrderAmounts {
    Open: OpenOrderAmount;
    OpenAmountIsZero: boolean;
    CurrencyID: string;
    Total: OrderAmount;
    UnroundedTotal: OrderAmount;
    Paid: PaidOrderAmount;
    Taxes: TaxAmount[];
    Types: Record<'NormalProduct' | 'Discount' | 'ExtraCosts' | 'ShippingCosts' | 'ReturnCosts' | 'PriceCorrection' | 'Service' | 'GiftWrappingCosts' | 'DownPayment', OrderAmount>;
    Discounts: DiscountAmounts;
    SubtotalExDiscount: number;
  }

  export interface OpenOrderAmount {
    InTax: number;
    PendingInTax: number;
    Capturable: number;
  }

  export interface OrderAmount {
    Amount: number;
    InTax: number;
    Tax: number;
  }

  export interface PaidOrderAmount {
    Pending: number;
    Amount: number;
    Captured: number;
  }

  export interface DiscountAmounts {
    TotalDiscountAmount: number;
    PerDiscount: DiscountAmounts.GroupedDiscountAmount[];
  }

  export namespace DiscountAmounts {
    export interface GroupedDiscountAmount {
      /**
       * Entity type: Discount
       */
      DiscountID: number;
      Discount: DiscountAmounts.DiscountAmountDiscount;
      Total: number;
    }

    export interface DiscountAmountDiscount {
      Description: string;
    }

  }

  export interface AdditionalOrderData {
    RequiredData?: RequiredData;
    ProductRequirements?: ProductRequirementModel[];
    GiftCardBusinessRules?: GiftCardBusinessRulesDto[];
    GiftWrappingLineAvailability?: GiftWrappingLineAvailabilityDto[];
    GiftWrappingOptions?: GiftWrappingOptionsForOrder;
    PrefiguredDiscounts?: PrefigureDiscountResult[];
    PotentialDiscounts?: PotentialDiscountDto[];
    /**
     * Entity type: OrderLine
     */
    DiscountPickProductOptions?: { [key: number]: OrderPickProductDiscountOptions };
    HasMoreDiscountPickProductOptions?: boolean;
    AvailableShippingMethods?: ShippingMethodByOrderLineDto[];
    AvailablePaymentMethods?: AvailablePaymentMethod[];
    AvailableRefundPaymentMethods?: RefundPaymentMethod[];
    OrderAmountAvailableForRefund?: number;
    /**
     * Amount required to pay when the whole order would be shipped.
     */
    OpenAmountForShipment?: number;
    /**
     * Is the amount required to pay when the whole order would be shipped valid.
     */
    IsPaidAmountValidForShipment?: boolean;
    /**
     * Amount required to pay when the carry out lines of the order would be shipped.
     */
    OpenAmountForShipmentOfCarryOut?: number;
    /**
     * Is the amount required to pay when the carry out lines of the order would be shipped valid.
     */
    IsPaidAmountValidForShipmentOfCarryOut?: boolean;
    IsAutoRefundAvailable?: boolean;
    AutoRefundableAmount?: number;
    IsAutoShipAvailable?: boolean;
    LineDiscountProductOptions?: LineDiscountProductOption[];
    HasMoreLineDiscountProductOptions?: boolean;
    AvailableCheckoutOptions?: CheckoutOrderOption[];
    /**
     * Entity type: CustomField
     */
    CustomerCustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
  }

  export interface RequiredData {
    Order: Requirement[];
    /**
     * Entity type: OrderLine
     */
    OrderLines: { [key: number]: Requirement[] };
    Customer: Requirement[];
    Company: Requirement[];
  }

  export interface Requirement {
    Name: string;
    IsValid: boolean;
    Message: string;
    Type: string;
    ValidationRule: string;
    DataType: string;
    RequiredFor: RequiredFor;
    Data: any;
  }

  export interface ProductRequirementModel {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    ProductPrimitiveName: string;
    RequirementModels: ProductRequirementLineModel[];
  }

  export interface ProductRequirementLineModel {
    /**
     * Entity type: ProductRequirement
     */
    ID: number;
    Name: string;
    Value: any;
  }

  export interface GiftCardBusinessRulesDto {
    /**
     * The order line where the giftcard is stored at.
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * The date the giftcard was purchased.
     */
    DateOfPurchase?: string;
    /**
     * The date the giftcard expired / will expire.
     */
    DateOfExpiration?: string;
    /**
     * The expiration status of the giftcard.
     */
    IsExpired?: boolean;
  }

  export interface GiftWrappingLineAvailabilityDto {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    QuantityWrapped: number;
    QuantityAvailable: number;
    TotalQuantityWrappable: number;
  }

  export interface GiftWrappingOptionsForOrder {
    WrapOrder: boolean;
    WrapIndividually: boolean;
    GiftWraps: GiftWrapDto[];
    GreetingCardProductID?: number;
    Message: string;
  }

  export interface GiftWrapDto {
    /**
     * Entity type: Product
     */
    GreetingCardProductID?: number;
    Message?: string;
    Lines: WrapLine[];
  }

  export interface WrapLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    Quantity: number;
  }

  export interface PotentialDiscountDto {
    /**
     * Entity type: Discount
     */
    ID: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    BackendID?: string;
    Description?: string;
    MarketingDescription?: string;
    PromotionLabel?: string;
    ImageBlobID?: string;
    AmountMissing?: number;
    /**
     * Entity type: Product
     */
    SecondaryProductIDs?: number[];
    ActionProperties?: any;
    IsAlreadyApplied: boolean;
  }

  export interface OrderPickProductDiscountOptions {
    BaseAmount: number;
    /**
     * Entity type: Product
     */
    Options: number[];
    Tiers: OrderPickProductDiscountOptions.PickProductTierOptions[];
    /**
     * Entity type: Product
     */
    CurrentSelection?: number;
    CurrentTier?: string;
  }

  export namespace OrderPickProductDiscountOptions {
    export interface PickProductTierOptions {
      ID: string;
      From: number;
      Difference: number;
      /**
       * Entity type: Product
       */
      DefaultProductID?: number;
      Prompt: boolean;
      /**
       * Entity type: Product
       */
      Products: any[];
      Description: string;
      IsCurrentTier: boolean;
    }

  }

  export interface ShippingMethodByOrderLineDto {
    /**
     * Entity type: OrderLine
     */
    AppliesToOrderLineIDs: number[];
    RequestedDeliveryDates: RequestedDateByOrderLineID[];
    Costs: ShippingMethodByOrderLineDto.ShippingMethodCosts;
    /**
     * Entity type: ShippingMethod
     */
    ID: number;
    /**
     * Entity type: Carrier
     */
    CarrierID: number;
    Carrier: CarrierDto;
    Name: string;
    Description: string;
    Code: string;
    Priority: number;
    PaymentHandledByCarrier: boolean;
    DeliveryType: ShippingMethodDeliveryTypes;
    CustomFieldValues: { [key: number]: CustomFieldValue };
  }

  export namespace ShippingMethodByOrderLineDto {
    export interface ShippingMethodCosts {
      Amount: number;
      /**
       * The ranges of the shipping costs based on the order amount. Empty if shipping costs are determined using scripting or no ranges are known for the shipping method.
       * The ranges are non-overlapping, gapless and sorted by the minimum amount (ascending). The first range has a minimum amount of 0. The last range has a maximum amount of null.
       */
      Ranges: ShippingCostRange[];
    }

  }

  export interface RequestedDateByOrderLineID {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    RequestedDate?: string;
  }

  export interface ShippingCostRange {
    MinAmount: number;
    MaxAmount?: number;
    Costs: number;
  }

  export interface LineDiscountProductOption {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Entity type: Discount
     */
    DiscountID: number;
    ActionType: string;
    /**
     * Entity type: Product
     */
    CurrentSelection?: number;
    Options: any[];
  }

  export interface CheckoutOrderOptionCategory {
    Options: CheckoutOrderOption[];
    /**
     * Entity type: CheckoutOptionCategory
     */
    ID: number;
    Name: string;
    Description?: string;
  }

  export interface CheckoutOrderOption {
    /**
     * Entity type: CheckoutOption
     */
    ID: number;
    Name: string;
    Description?: string;
    Handler: string;
    ConfigData?: ICheckoutOptionConfigData;
    ValueData?: ICheckoutOptionValueData;
    CheckoutOptionCategory?: CheckoutOrderOptionCategoryInfo;
  }

  export interface ICheckoutOptionConfigData {
  }

  export interface ICheckoutOptionValueData {
  }

  export interface CheckoutOrderOptionCategoryInfo {
    /**
     * Entity type: CheckoutOptionCategory
     */
    ID: number;
    Name: string;
    Description?: string;
  }

  /**
   * Get Order Statistics
   */
  export interface GetOrderStatistics {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetOrderStatisticsResponse {
    Statistics: OrderStatistics;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface OrderStatistics {
    GrossMargin: number;
    /**
     * Entity type: OrderLine
     */
    OrderLines: { [key: number]: OrderStatistics.OrderLineStatistics };
  }

  export namespace OrderStatistics {
    export interface OrderLineStatistics {
      UnitPrice: number;
      UnitCost: number;
      DiscountAmount: number;
    }

  }

  /**
   * Get a summary of an Order to be used when a shipment will be made.
   * 
   * Caution: the ProductID is nullable, all non-cancelled lines are returned
   */
  export interface GetOrderSummaryForShipping {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetOrderSummaryForShippingResponse {
    Lines: GetOrderSummaryForShippingResponse.OrderLineSummary[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetOrderSummaryForShippingResponse {
    export interface OrderLineSummary {
      ID: number;
      ProductID?: number;
      TotalQuantityToShip: number;
      QuantityShipped: number;
      QuantityOpen: number;
    }

  }

  /**
   * Returns a summarized version of the order with less details than `GetOrder`. This service should be used to expose
   * less data to the frontend, also this variant to retrieve the order can be used when authenticated via the `GetTemporaryTokenForOrder`
   * service. Where `GetOrder` is not accessible.
   */
  export interface GetOrderSummary {
    /**
     * Entity type: Order
     */
    OrderID: number;
    ProductProperties?: string[];
  }

  export interface GetOrderSummaryResponse {
    /**
     * Entity type: Order
     */
    ID: number;
    ShippingAddress: GetOrderSummaryResponse.AddressModel;
    BillingAddress: GetOrderSummaryResponse.AddressModel;
    Amounts: OpenOrderAmounts;
    Lines: GetOrderSummaryResponse.OrderLineModel[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetOrderSummaryResponse {
    export interface AddressModel {
      Address1: string;
      Address2: string;
      ZipCode: string;
      City: string;
      CountryID: string;
    }

    export interface OrderLineModel {
      /**
       * Entity type: OrderLine
       */
      ID: number;
      /**
       * Entity type: OrderLine
       */
      ParentID?: number;
      Product: any;
      /**
       * Entity type: Product
       */
      ProductID?: number;
      Description: string;
      QuantityOrdered: number;
      QuantityCancelled: number;
      UnitPriceInTax: number;
      DiscountAmount: number;
      NetTotalAmountInTax: number;
      OriginalTotalAmountInTax?: number;
      Type: OrderLineTypes;
      QuantityExported: number;
      IsPlaced: boolean;
    }

  }

  /**
   * Get tax details on the specified order.
   */
  export interface GetOrderTaxDetails {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetOrderTaxDetailsResponse {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Lines: ReceiptTaxDetailLine[];
    SummaryLines: ReceiptTaxSummaryLine[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ReceiptTaxDetailLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    Name: string;
    Type: string;
    Rate: number;
    Amount: number;
  }

  export interface ReceiptTaxSummaryLine {
    Name: string;
    Type: string;
    Rate: number;
    Amount: number;
  }

  /**
   * Returns the quantity that is to be shipped for order lines. Includes pending shipments.
   */
  export interface GetPendingShipmentInformationForOrderLines {
    Lines: GetPendingShipmentInformationForOrderLines.OrderLine[];
  }

  export namespace GetPendingShipmentInformationForOrderLines {
    export interface OrderLine {
      /**
       * Entity type: OrderLine
       */
      ID: number;
    }

  }

  export interface GetPendingShipmentInformationForOrderLinesResponse {
    Result: GetPendingShipmentInformationForOrderLinesResponse.LineInfo[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetPendingShipmentInformationForOrderLinesResponse {
    export interface LineInfo {
      /**
       * Entity type: OrderLine
       */
      ID: number;
      /**
       * Total quantity of the line that is and needed to be shipped.
       */
      QuantityOpen: number;
      /**
       * This is what has already been shipped for this line
       */
      QuantityShipped: number;
      /**
       * This is what is currently in a shipment, but not shipped yet
       */
      QuantityShippedWithPending: number;
      /**
       * This is what currently still needs to be shipped for this line
       */
      QuantityOpenWithPending: number;
    }

  }

  /**
   * List all the related orderlines for the given OrderLineID.
   * 
   * The orderlines will be sorted by CreationTime.
   */
  export interface GetRelatedOrderLines {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
  }

  export interface GetRelatedOrderLinesResponse {
    Result: GetRelatedOrderLinesResponse.Model[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetRelatedOrderLinesResponse {
    export interface Model {
      OrderType: OrderTypes;
      SoldFromOrganizationUnit: GetRelatedOrderLinesResponse.OrganizationUnit;
      ShipFromOrganizationUnit: GetRelatedOrderLinesResponse.OrganizationUnit;
      /**
       * Entity type: OrderLine
       */
      ID: number;
      BackendReference: string;
      /**
       * Entity type: Order
       */
      OrderID: number;
      /**
       * Entity type: OrderLine
       */
      ParentID?: number;
      Children?: OrderLineDto[];
      Type: OrderLineTypes;
      /**
       * Entity type: StockLabel
       */
      StockLabel: number;
      Description: string;
      AdditionalDescription: string;
      /**
       * This is the quantity that was ordered. Make sure you really need this property, the total of the line is TotalQuantityToShip.
       */
      QuantityOrdered: number;
      QuantityOpen: number;
      QuantityCommitted: number;
      CommitmentStatus: OrderLineCommitmentStatus;
      QuantityShipped: number;
      QuantityDelivered: number;
      QuantityReserved: number;
      QuantityBackordered: number;
      QuantityReturned: number;
      QuantityCancelled: number;
      QuantityInvoiced: number;
      /**
       * Entity type: Product
       */
      ProductID?: number;
      Product?: ProductDto;
      StockProduct?: ProductDto;
      UnitPrice: number;
      UnitPriceBeforeCorrection?: number;
      UnitPriceBeforeCorrectionInTax?: number;
      UnitPriceCorrectionReason?: EnumDto;
      TaxRate: number;
      TaxCode: EnumDto;
      ShowTaxInfo: boolean;
      SerialNumber?: string;
      UnitPriceInTax: number;
      IsCancelled: boolean;
      TotalQuantityToShip: number;
      TotalAmountInTax: number;
      TotalAmount: number;
      NetTotalAmountInTax: number;
      NetTotalAmount: number;
      TotalTaxAmount: number;
      NetTotalTaxAmount: number;
      OriginalTotalAmountInTax?: number;
      OriginalTotalAmount?: number;
      EcoTaxInTax?: number;
      TotalEcoTaxInTax?: number;
      DisplayPriceInTax?: number;
      DisplayPrice?: number;
      ModificationAllowed: boolean;
      Remark: string;
      Reference: string;
      LineActionType: LineActionTypes;
      /**
       * Entity type: Order
       */
      ReturnedOrderID?: number;
      /**
       * Entity type: OrderLine
       */
      ReturnedOrderLineID?: number;
      ExportStatus: OrderExportStatuses;
      ContractNumber: string;
      IsCompleted: boolean;
      IsShipped: boolean;
      IsInvoiced: boolean;
      ExpectedAvailabilityDate?: string;
      RequestedDate?: string;
      CreationTime: string;
      /**
       * Entity type: User
       */
      CreatedByID: number;
      LastModificationTime?: string;
      IsDigitalGiftCard: boolean;
      /**
       * Entity type: Discount
       */
      DiscountID?: number;
      DiscountBackendID: string;
      DiscountCouponCode: string;
      DiscountCampaignName: string;
      DiscountAmount: number;
      /**
       * Entity type: ShippingMethod
       */
      ShippingMethodID?: number;
      ShippingMethod?: ShippingMethodDto;
      ExternalModificationStatus: ExternalModificationStatuses;
      CustomOrderLineType: string;
      /**
       * Entity type: OrderLine
       */
      RelatedOrderLineID?: number;
      /**
       * Entity type: Currency
       */
      CurrencyID: string;
      ProductVariation: { [key: string]: string };
      /**
       * Entity type: ProductBundleLine
       */
      ProductBundleLineID?: number;
      TaxExemptionCode: string;
      TaxExemptionReason: string;
      TaxExemptionVerification: string;
      FulfillmentStatus: OrderLineFulfillmentStatuses;
      AvailabilityStatus?: OrderLineAvailabilityStatus;
      ReturnReason?: EnumWithBackendIDDto;
      RefundCorrectionReason?: RefundCorrectionReasonDto;
      /**
       * Entity type: User
       */
      SoldByID?: number;
      /**
       * Properties that should be used for display in the frontends to keep a matching experience in all apps.
       */
      DisplayProperties: OrderLineDisplayProperties;
      /**
       * Entity type: CustomField
       */
      CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
      /**
       * Entity type: PriceList
       */
      UnitPricePriceListID?: number;
      Discounts: OrderLineDiscount[];
      LoyaltyWithdrawals?: OrderLineLoyaltyMutation[];
      LoyaltyDeposits?: OrderLineLoyaltyMutation[];
      GroupID?: string;
      ImageBlobID?: string;
      /**
       * Entity type: OrganizationUnit
       */
      FulfillmentOrganizationUnitID?: number;
      FulfillmentOrganizationUnitName?: string;
      FulfillmentOrganizationUnitBackendID?: string;
      IsPricedByLoyaltyProgram?: boolean;
      IsLimitedByLoyaltyProgram?: boolean;
      PreSaleDate?: string;
      ProductSubscription?: ProductSubscriptionDto;
      /**
       * Entity type: Product
       */
      StockProductID?: number;
    }

    export interface OrganizationUnit {
      ID: number;
      Name: string;
    }

  }

  /**
   * Get all the related orders for the given OrderID.
   * 
   * The orders will be sorted by CreationTime.
   */
  export interface GetRelatedOrders {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetRelatedOrdersResponse {
    Result: GetRelatedOrdersResponse.Model[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetRelatedOrdersResponse {
    export interface Model {
      /**
       * Entity type: Order
       */
      RelatedOrderID: number;
      BackendID: string;
      Description: string;
      CreationTime: string;
      TypeID: number;
      Properties: OrderProperties;
      SoldFromOrganizationUnit: GetRelatedOrdersResponse.NamedDto;
      ShipFromOrganizationUnit?: GetRelatedOrdersResponse.NamedDto;
      SoldToOrganizationUnit?: GetRelatedOrdersResponse.NamedDto;
      ShipToOrganizationUnit?: GetRelatedOrdersResponse.NamedDto;
    }

    export interface NamedDto {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Get the required data for the order
   */
  export interface GetRequiredDataForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    RequiredFor?: RequiredFor;
  }

  export interface GetRequiredDataForOrderResponse {
    RequiredData: RequiredData;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Gets whether or not an Order is currently returnable.
   * 
   * For each OrderLine on the Order you'll get back a result that specifies whether or not it can be returned,
   * how much can be returned and which (if any) other OrderLines must be returned before the line itself can be returned
   * (think of parent-child lines where you can't return a child OrderLine without also returning the parent OrderLine).
   * 
   * In addition, this service may return `ReturnSets` which specify that 'if you return these OrderLines (specified by `OrderLineIDs`) then
   * you must *also* return these lines (specified by `RequiredOrderLineIDsToReturn`). For example, if you return all normal OrderLines on an Order
   * then you must also return all the free products you have received.
   * 
   * Finally, specify the `ReturningQuantities` parameter as an object where the key is an `OrderLineID` with a (positive) `Quantity` you wish to be
   * returned. The `Result` can be affected in case rules have been configured to, for example, allow _returns without products_ only when the total
   * return order amount is below a certain amount.
   */
  export interface GetReturnableStatusForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderLine
     */
    ReturningQuantities?: { [key: number]: number };
    RequireLoginFunctionality?: boolean;
    HideCancelledLines?: boolean;
  }

  export interface GetReturnableStatusForOrderResponse {
    Result: ReturnableStatusForOrderLine[];
    ReturnSets: OrderLinesReturnSet[];
    StockOrganizationUnits: StockOrganizationUnit[];
    /**
     * Indicates whether the order needs to use the special return procedure for in-store returns. This is done using the `CreateInStoreReturn` service.
     */
    RequiresSpecialInStoreReturn: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ReturnableStatusForOrderLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    ReturnableQuantity: number;
    ReasonCode: string;
    Reason: string;
    IsReturnable: boolean;
    OverrideFunctionality?: FunctionalityWithScope;
    /**
     * When present, this OrderLine can only be returned when the OrderLines specified in this collection are also being returned.
     * Entity type: OrderLine
     */
    MustBeReturnedWithOrderLineIDs: number[];
    OrderLineType: OrderLineTypes;
    ReturnableAmount?: number;
    ReturnWithoutProducts: ReturnWithoutProductsResult;
    SerialNumberRequired: boolean;
    /**
     * Entity type: SerialNumberConfiguration
     */
    SerialNumberConfigurationID?: number;
    NonReturnableStockLabels?: ReturnableStatusForOrderLine.NonReturnableStockLabel[];
  }

  export namespace ReturnableStatusForOrderLine {
    export interface NonReturnableStockLabel {
      ID: number;
      Name: string;
      Description: string;
      DisplayName: string;
    }

  }

  export interface FunctionalityWithScope {
    Functionality: string;
    Scope: FunctionalityScope;
  }

  export const enum ReturnWithoutProductsResult {
    None = 0,
    ReturnWithoutProducts = 1,
    ReturnWithProducts = 2
  }

  export interface OrderLinesReturnSet {
    /**
     * Entity type: OrderLine
     */
    OrderLineIDs: number[];
    /**
     * Entity type: OrderLine
     */
    RequiredOrderLineIDsToReturn: number[];
  }

  export interface StockOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    Reason: ReturnableStockOrganizationUnitReasons;
  }

  export const enum ReturnableStockOrganizationUnitReasons {
    CurrentOrganizationUnit = 0,
    ShipFromOrganizationUnit = 1,
    SupplierOrganizationUnit = 2,
    ReturnOrganizationUnit = 3,
    SoldFromOrganizationUnit = 4
  }

  /**
   * Returns all of the shipping methods that are being used on the order.
   */
  export interface GetShippingMethodsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetShippingMethodsForOrderResponse {
    ShippingMethods: ShippingMethodByOrderLineDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Allows customers to grab a token to be able to view their order for a limited amount of time. The token is
   * obtained through the user of either `OrderID` or both a `BackendSystemID` and a `BackendID` in combination
   * with the `EmailAddress` of the customer that is attached to the order.
   */
  export interface GetTemporaryTokenForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    EmailAddress: string;
  }

  export interface GetTemporaryTokenForOrderResponse {
    Token: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Returns a set of all the shipping methods that can be used for the given order. Use `SetShippingMethod` to update the shipping method on the order.
   */
  export interface ListAvailableShippingMethods {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineIDs?: number[];
  }

  export interface ListAvailableShippingMethodsResponse {
    AvailableShippingMethods: ShippingMethodByOrderLineDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Lists the available custom order types that exists which can be used in the order editing process.
   */
  export interface GetCustomOrderTypes {
  }

  export interface GetCustomOrderTypesResponse {
    CustomOrderTypes: GetCustomOrderTypesResponse.CustomOrderType[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetCustomOrderTypesResponse {
    export interface CustomOrderType {
      /**
       * Entity type: CustomOrderType
       */
      ID: number;
      Name: string;
      Description: string;
    }

  }

  /**
   * List external status updates for the order specified by OrderID.
   */
  export interface ListExternalOrderStatusForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface ListExternalOrderStatusForOrderResponse {
    Result: ListExternalOrderStatusForOrderResponse.ExternalOrderStatus[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListExternalOrderStatusForOrderResponse {
    export interface ExternalOrderStatus {
      Name: string;
      Status: string;
      CanPollStatus: boolean;
    }

  }

  /**
   * List all invoices generated for the order identified by OrderID.
   */
  export interface ListInvoicesForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface ListInvoicesForOrderResponse {
    Result: ListInvoicesForOrderResponse.Invoice[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListInvoicesForOrderResponse {
    export interface Invoice {
      /**
       * Entity type: Invoice
       */
      ID: number;
      InvoiceNumber: string;
      InvoiceDate?: string;
      CreatedByID: number;
      CreationTime: string;
      TotalAmount: number;
      PaidAmount: number;
      OpenAmount: number;
      Payments: Invoice.Payment[];
    }

    export namespace Invoice {
      export interface Payment {
        /**
         * Entity type: PaymentTransaction
         */
        PaymentTransactionID: number;
        Amount: number;
      }

    }

  }

  /**
   * Retrieves a paged list of Order Ledgers for specified OrderID.
   */
  export interface ListOrderLedgerForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    PageConfig?: PageConfig<ListOrderLedgerFilter>;
  }

  export interface ListOrderLedgerFilter {
    /**
     * Entity type: OrderLedgerType
     */
    TypeIDs: number[];
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
  }

  export interface ListOrderLedgerForOrderResponse {
    Result?: PagedResult<ListOrderLedgerForOrderResponse.OrderLedgerDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListOrderLedgerForOrderResponse {
    export interface OrderLedgerDto {
      /**
       * Entity type: OrderLedger
       */
      ID: number;
      /**
       * Entity type: Order
       */
      OrderID: number;
      OrderDisplayID?: string;
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      Type: ListOrderLedgerForOrderResponse.OrderLedgerTypeDto;
      /**
       * Entity type: OrderLedgerType
       */
      TypeID: number;
      OldValue: string;
      NewValue: string;
      Description: string;
      /**
       * Entity type: User
       */
      CreatedByID: number;
      CreationTime: string;
      CreatedBy: ListOrderLedgerForOrderResponse.UserDto;
    }

    export interface UserDto {
      /**
       * Entity type: User
       */
      ID: number;
      FullName: string;
    }

    export interface OrderLedgerTypeDto {
      /**
       * Entity type: OrderLedgerType
       */
      ID: number;
      Name: string;
      Description: string;
      IsCustom: boolean;
    }

  }

  /**
   * List Order Lines Invoice Summary
   */
  export interface ListOrderLinesInvoiceSummary {
    /**
     * Entity type: Order
     */
    OrderID: number;
    PageConfig?: PageConfig<ListOrderLinesFilter>;
  }

  export interface ListOrderLinesFilter {
    /**
     * Entity type: OrderLine
     */
    IDs: number[];
    Shippable: boolean;
    Invoiceable: boolean;
    OnlyShippableLines: boolean;
    ProductTypes?: ProductTypes;
    Query: string;
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
  }

  export interface ListOrderLinesInvoiceSummaryResponse {
    Result?: PagedResult<ListOrderLinesInvoiceSummaryResponse.Model>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListOrderLinesInvoiceSummaryResponse {
    export interface Model {
      QuantityLeftToInvoice: number;
      /**
       * Entity type: OrderLine
       */
      ID: number;
      BackendReference: string;
      /**
       * Entity type: Order
       */
      OrderID: number;
      /**
       * Entity type: OrderLine
       */
      ParentID?: number;
      Children?: OrderLineDto[];
      Type: OrderLineTypes;
      /**
       * Entity type: StockLabel
       */
      StockLabel: number;
      Description: string;
      AdditionalDescription: string;
      /**
       * This is the quantity that was ordered. Make sure you really need this property, the total of the line is TotalQuantityToShip.
       */
      QuantityOrdered: number;
      QuantityOpen: number;
      QuantityCommitted: number;
      CommitmentStatus: OrderLineCommitmentStatus;
      QuantityShipped: number;
      QuantityDelivered: number;
      QuantityReserved: number;
      QuantityBackordered: number;
      QuantityReturned: number;
      QuantityCancelled: number;
      QuantityInvoiced: number;
      /**
       * Entity type: Product
       */
      ProductID?: number;
      Product?: ProductDto;
      StockProduct?: ProductDto;
      UnitPrice: number;
      UnitPriceBeforeCorrection?: number;
      UnitPriceBeforeCorrectionInTax?: number;
      UnitPriceCorrectionReason?: EnumDto;
      TaxRate: number;
      TaxCode: EnumDto;
      ShowTaxInfo: boolean;
      SerialNumber?: string;
      UnitPriceInTax: number;
      IsCancelled: boolean;
      TotalQuantityToShip: number;
      TotalAmountInTax: number;
      TotalAmount: number;
      NetTotalAmountInTax: number;
      NetTotalAmount: number;
      TotalTaxAmount: number;
      NetTotalTaxAmount: number;
      OriginalTotalAmountInTax?: number;
      OriginalTotalAmount?: number;
      EcoTaxInTax?: number;
      TotalEcoTaxInTax?: number;
      DisplayPriceInTax?: number;
      DisplayPrice?: number;
      ModificationAllowed: boolean;
      Remark: string;
      Reference: string;
      LineActionType: LineActionTypes;
      /**
       * Entity type: Order
       */
      ReturnedOrderID?: number;
      /**
       * Entity type: OrderLine
       */
      ReturnedOrderLineID?: number;
      ExportStatus: OrderExportStatuses;
      ContractNumber: string;
      IsCompleted: boolean;
      IsShipped: boolean;
      IsInvoiced: boolean;
      ExpectedAvailabilityDate?: string;
      RequestedDate?: string;
      CreationTime: string;
      /**
       * Entity type: User
       */
      CreatedByID: number;
      LastModificationTime?: string;
      IsDigitalGiftCard: boolean;
      /**
       * Entity type: Discount
       */
      DiscountID?: number;
      DiscountBackendID: string;
      DiscountCouponCode: string;
      DiscountCampaignName: string;
      DiscountAmount: number;
      /**
       * Entity type: ShippingMethod
       */
      ShippingMethodID?: number;
      ShippingMethod?: ShippingMethodDto;
      ExternalModificationStatus: ExternalModificationStatuses;
      CustomOrderLineType: string;
      /**
       * Entity type: OrderLine
       */
      RelatedOrderLineID?: number;
      /**
       * Entity type: Currency
       */
      CurrencyID: string;
      ProductVariation: { [key: string]: string };
      /**
       * Entity type: ProductBundleLine
       */
      ProductBundleLineID?: number;
      TaxExemptionCode: string;
      TaxExemptionReason: string;
      TaxExemptionVerification: string;
      FulfillmentStatus: OrderLineFulfillmentStatuses;
      AvailabilityStatus?: OrderLineAvailabilityStatus;
      ReturnReason?: EnumWithBackendIDDto;
      RefundCorrectionReason?: RefundCorrectionReasonDto;
      /**
       * Entity type: User
       */
      SoldByID?: number;
      /**
       * Properties that should be used for display in the frontends to keep a matching experience in all apps.
       */
      DisplayProperties: OrderLineDisplayProperties;
      /**
       * Entity type: CustomField
       */
      CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
      /**
       * Entity type: PriceList
       */
      UnitPricePriceListID?: number;
      Discounts: OrderLineDiscount[];
      LoyaltyWithdrawals?: OrderLineLoyaltyMutation[];
      LoyaltyDeposits?: OrderLineLoyaltyMutation[];
      GroupID?: string;
      ImageBlobID?: string;
      /**
       * Entity type: OrganizationUnit
       */
      FulfillmentOrganizationUnitID?: number;
      FulfillmentOrganizationUnitName?: string;
      FulfillmentOrganizationUnitBackendID?: string;
      IsPricedByLoyaltyProgram?: boolean;
      IsLimitedByLoyaltyProgram?: boolean;
      PreSaleDate?: string;
      ProductSubscription?: ProductSubscriptionDto;
      /**
       * Entity type: Product
       */
      StockProductID?: number;
    }

  }

  /**
   * List the OrderLines of an Order in a paginated fashion, allowing you to filter with a `PageConfig` and include product properties using `ProductProperties`.
   * 
   * Use this service when an Order contains a lot of lines, and the `GetOrder` service doesn't cut it - it will tell you it's time to switch using a property called `HasMoreLines`.
   */
  export interface ListOrderLines {
    /**
     * Entity type: Order
     */
    OrderID: number;
    ProductProperties?: string[];
    PageConfig?: PageConfig<ListOrderLinesFilter>;
    /**
     * When specified, order lines are returned nested under their parents recursively within their `Children` property. Filters will only be applied to the parent.
     */
    UseHierarchy?: boolean;
  }

  export interface ListOrderLinesResponse {
    Result?: PagedResult<OrderLineDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * List orders for specific customer.
   */
  export interface ListOrdersForCustomer {
    /**
     * Entity type: User
     */
    ID: number;
    PageConfig?: PageConfig<ListOrdersForCustomerFilter>;
  }

  export interface ListOrdersForCustomerFilter {
    /**
     * Entity type: Order
     */
    ID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    IsShipped?: boolean;
    /**
     * @default false
     */
    OpenOrdersOnly?: boolean;
    /**
     * @default false
     */
    ShowOrdersWithoutLines?: boolean;
    /**
     * @default false
     */
    ModifiableOrdersOnly?: boolean;
    IsPlaced?: boolean;
    /**
     * @default EVA.Core.DataModels.OrderTypes[]
     */
    Type?: OrderTypes[];
    /**
     * @default EVA.Core.DataModels.OrderStatus[]
     */
    Status?: OrderStatus[];
    OrderProperties?: OrderProperties;
    ExcludeOrderProperties?: OrderProperties;
    /**
     * Entity type: OrganizationUnit
     */
    SoldFromOrganizationUnitID?: number;
  }

  export interface ListOrdersForCustomerResponse {
    Result?: PagedResult<OrderDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * List Order Shipments
   */
  export interface ListOrderShipments {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface ListOrderShipmentsResponse {
    Result: ListOrderShipmentsResponse.Model[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListOrderShipmentsResponse {
    export interface Model {
      /**
       * Entity type: Shipment
       */
      ID: number;
      BackendID: string;
      Status: ShipmentStatuses;
      ShipmentDate?: string;
      CompletionTime?: string;
      TrackingCode: string;
      TrackingLink: string;
      ShippedFromOrganizationUnit?: Model.OrganizationUnitModel;
      ShippedToOrganizationUnit: Model.OrganizationUnitModel;
      TotalQuantityShipped: number;
      TotalQuantityDelivered: number;
      NetTotalQuantityShipped: number;
      NetTotalQuantityDelivered: number;
      ReceiptCreatedBy: string;
      ReceiptCreatedOn?: string;
      CreationTime: string;
    }

    export namespace Model {
      export interface OrganizationUnitModel {
        /**
         * Entity type: OrganizationUnit
         */
        ID?: number;
        BackendID?: string;
        Name?: string;
        Description?: string;
      }

    }

  }

  export interface ListOrdersWithCustomerReferences {
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListOrdersWithCustomerReferencesResponse {
    Result?: PagedResult<OrderWithCustomerReferences>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface OrderWithCustomerReferences {
    ID: number;
    CustomerReference: string;
    CustomerOrderID: string;
    CreationTime: string;
  }

  /**
   * Lock the Order in order to prevent some editing functionalities on it.
   */
  export interface LockOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Unlock the Order, allowing future editing on it.
   */
  export interface UnlockOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Migrate Orders To Unified
   */
  export interface MigrateOrdersToUnified {
    /**
     * Entity type: Order
     */
    OrderIDs?: number[];
  }

  export interface MigrateOrdersToUnifiedResponse {
    MigratedOrderIDs: number[];
    NotMigratedOrderIDs: number[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update the UnitPriceInTax and optional UnitCost for a specific OrderLineID.
   */
  export interface ModifyOrderLinePrice {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Range: 0-1000000
     */
    UnitPriceInTax: number;
    /**
     * Range: 0-1000000
     */
    UnitCost?: number;
  }

  /**
   * Modify Quantity Ordered
   */
  export interface ModifyQuantityOrdered {
    Lines?: ModifyQuantityOrdered.OrderLineToModify[];
  }

  export namespace ModifyQuantityOrdered {
    export interface OrderLineToModify {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      /**
       * Min: 9000
       */
      NewQuantityOrdered: number;
    }

  }

  export interface ModifyQuantityOrderedResponse {
    Result: ModifyQuantityOrderedResponse.ModifyQuantityResult[];
    /**
     * Entity type: Order
     */
    OrderID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ModifyQuantityOrderedResponse {
    export interface QuantityMutationResultMessage {
      Code: string;
      Message: string;
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
    }

    export interface ModifyQuantityResult {
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      /**
       * Entity type: OrderLine
       */
      CreatedOrderLineIDs?: number[];
      Messages?: ModifyQuantityOrderedResponse.ModifyQuantityOrderedMessage[];
    }

    export interface ModifyQuantityOrderedMessage {
      Code: string;
      Message: string;
    }

  }

  export interface ListOrderCustomStatus {
    PageConfig?: PageConfig<ListOrderCustomStatusFilter>;
  }

  export interface ListOrderCustomStatusFilter {
    /**
     * Entity type: OrderCustomStatus
     */
    ID?: number;
    BackendID?: string;
    Name?: string;
    Description?: string;
    Color?: string;
  }

  export interface ListOrderCustomStatusResponse {
    Result?: PagedResult<ListOrderCustomStatusResponse.ListOrderCustomStatusModel>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListOrderCustomStatusResponse {
    export interface ListOrderCustomStatusModel {
      /**
       * Entity type: OrderCustomStatus
       */
      ID: number;
      BackendID?: string;
      Name: string;
      Description?: string;
      Color?: string;
    }

  }

  /**
   * Create Order Custom Status
   */
  export interface CreateOrderCustomStatus {
    BackendID?: string;
    Name: string;
    Description?: string;
    Color?: string;
  }

  export interface CreateOrderCustomStatusResponse {
    /**
     * Entity type: OrderCustomStatus
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update Order Custom Status
   */
  export interface UpdateOrderCustomStatus {
    /**
     * Entity type: OrderCustomStatus
     */
    ID: number;
    BackendID?: string;
    Name?: string;
    Description?: string;
    Color?: string;
  }

  /**
   * Delete Order Custom Status
   */
  export interface DeleteOrderCustomStatus {
    /**
     * Entity type: OrderCustomStatus
     */
    ID: number;
  }

  export interface ListOrderCustomTypes {
    PageConfig?: PageConfig<ListOrderCustomTypesFilter>;
  }

  export interface ListOrderCustomTypesFilter {
    /**
     * Entity type: OrderCustomType
     */
    ID?: number;
    BackendID?: string;
    Name?: string;
    Description?: string;
  }

  export interface ListOrderCustomTypesResponse {
    Result?: PagedResult<ListOrderCustomTypesResponse.ListOrderCustomTypeModel>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListOrderCustomTypesResponse {
    export interface ListOrderCustomTypeModel {
      /**
       * Entity type: OrderCustomType
       */
      ID: number;
      BackendID?: string;
      Name: string;
      Description?: string;
    }

  }

  /**
   * Create Order Custom Type
   */
  export interface CreateOrderCustomType {
    BackendID?: string;
    Name: string;
    Description?: string;
  }

  export interface CreateOrderCustomTypeResponse {
    /**
     * Entity type: OrderCustomType
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update Order Custom Type
   */
  export interface UpdateOrderCustomType {
    /**
     * Entity type: OrderCustomType
     */
    ID: number;
    BackendID?: string;
    Name?: string;
    Description?: string;
  }

  /**
   * Delete Order Custom Type
   */
  export interface DeleteOrderCustomType {
    /**
     * Entity type: OrderCustomType
     */
    ID: number;
  }

  export interface ListOrderExportsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListOrderExportsForOrderResponse {
    Result?: PagedResult<ListOrderExportsForOrderResponse.OrderExportDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListOrderExportsForOrderResponse {
    export interface OrderExportDto {
      /**
       * Entity type: OrderExport
       */
      ID: number;
      ShipToOrganizationUnit: ListOrderExportsForOrderResponse.OrganizationUnitDto;
      Name: string;
      Status: TransputJobStatuses;
      CreationTime: string;
      LastModificationTime?: string;
      /**
       * Entity type: OrderFulfillment
       */
      OrderFulfillmentID?: number;
      /**
       * Entity type: TransputJob
       */
      TransputJobID: number;
    }

    export interface OrganizationUnitDto {
      ID: number;
      Name: string;
      BackendID: string;
    }

  }

  /**
   * Retrieve detailed information for a specific OrderExport ID.
   */
  export interface GetOrderExportByID {
    /**
     * Entity type: OrderExport
     */
    ID: number;
  }

  export interface GetOrderExportByIDResponse {
    ID: number;
    OrderID: number;
    Name: string;
    Status: TransputJobStatuses;
    IsDelivery: boolean;
    ShipFromOrganizationUnitID?: number;
    ShipFromOrganizationUnitName: string;
    ShipToOrganizationUnitID: number;
    ShipToOrganizationUnitName: string;
    Lines: GetOrderExportByIDResponse.OrderExportLineDto[];
    CreationTime: string;
    LastModificationTime?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetOrderExportByIDResponse {
    export interface OrderExportLineDto {
      ID: number;
      OrderLineID: number;
      QuantityExported: number;
      QuantityCancelled: number;
      QuantityBackordered: number;
      BackendReference: string;
      CreationTime: string;
      LastModificationTime?: string;
    }

  }

  /**
   * Retry processing an order export by its ID.
   */
  export interface RetryOrderExport {
    /**
     * Entity type: OrderExport
     */
    ID: number;
    Force?: boolean;
  }

  /**
   * Get request and response documents for an OrderExport by ID.
   */
  export interface GetOrderExportDocuments {
    /**
     * Entity type: OrderExport
     */
    ID: number;
  }

  export interface GetOrderExportDocumentsResponse {
    RequestDocuments: TransputJobDocument[];
    ResponseDocuments: TransputJobDocument[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Attach an identification document to an order. This will replace any existing identification document attached to the order.
   */
  export interface AttachIdentificationToOrder {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    Type?: IdentificationTypes;
    Number?: string;
    /**
     * ISO 3166-1 alpha-3 of the country
     */
    NationalityCode?: string;
    ValidTo?: string;
    IssuingDate?: string;
    IssuingCity?: string;
    /**
     * Entity type: Country
     */
    IssuingCountryID?: string;
    /**
     * Entity type: Country
     */
    OriginatingCountryID?: string;
    DocumentMimeType?: string;
    Document?: string;
  }

  export const enum IdentificationTypes {
    DiplomaticPassport = 1,
    DriverLicense = 2,
    EuropeanIdentification = 3,
    ForeignPassport = 4,
    INDSticker = 5,
    NatoPassport = 6,
    Passport = 7,
    PermanentResidencyDocument = 8,
    PrivilegedDocument = 9,
    ResidencePermitTypeEuEea = 10,
    ResidencePermitTypeI = 11,
    ResidencePermitTypeII = 12,
    ResidencePermitTypeIII = 13,
    ResidencePermitTypeIV = 14,
    ResidencePermitTypeW = 15,
    VNGCard = 16,
    ResidencePermitTypeV = 17
  }

  /**
   * Detach an identification document from an order. This will wipe the document and data.
   */
  export interface DetachIdentificationFromOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Create a link between two orders using their IDs and a link type.
   */
  export interface CreateOrderLink {
    /**
     * Entity type: Order
     */
    PrimaryOrderID: number;
    /**
     * Entity type: Order
     */
    RelatedOrderID: number;
    /**
     * Entity type: OrderLinkType
     */
    TypeID: number;
  }

  export interface CreateOrderLinkResponse {
    /**
     * Entity type: OrderLink
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Modify an existing order link identified by ID.
   */
  export interface UpdateOrderLink {
    /**
     * Entity type: OrderLink
     */
    ID: number;
    /**
     * Entity type: Order
     */
    PrimaryOrderID?: number;
    /**
     * Entity type: Order
     */
    RelatedOrderID?: number;
    /**
     * Entity type: OrderLinkType
     */
    TypeID?: number;
  }

  /**
   * Remove an order link specified by ID.
   */
  export interface DeleteOrderLink {
    /**
     * Entity type: OrderLink
     */
    ID: number;
  }

  export interface CreateOrderLinkType {
    Name: string;
    Description?: string;
    BackendID?: string;
  }

  export interface CreateOrderLinkTypeResponse {
    /**
     * Entity type: OrderLinkType
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface UpdateOrderLinkType {
    /**
     * Entity type: OrderLinkType
     */
    ID: number;
    Name: string;
    Description?: string;
    BackendID?: string;
  }

  export interface DeleteOrderLinkType {
    /**
     * Entity type: OrderLinkType
     */
    ID: number;
  }

  export interface GetOrderLinkTypeByID {
    /**
     * Entity type: OrderLinkType
     */
    ID: number;
  }

  export interface GetOrderLinkTypeByIDResponse {
    OrderLinkType: OrderLinkType;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface OrderLinkType {
    ID: number;
    Name: string;
    Description: string;
    BackendID: string;
    IsDeleted: boolean;
  }

  export interface GetOrderLinkTypes {
  }

  export interface GetOrderLinkTypesResponse {
    OrderLinkTypes: OrderLinkType[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Create a new order verification reason.
   */
  export interface CreateOrderVerificationReason {
    Name?: string;
    BackendID?: string;
    Description?: string;
  }

  export interface CreateOrderVerificationReasonResponse {
    /**
     * Entity type: OrderVerificationReason
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Lists order verification reasons.
   */
  export interface ListOrderVerificationReasons {
    InitialPageConfig?: PageTokenConfig<ListOrderVerificationReasonFilter>;
    PageToken?: string;
  }

  export interface ListOrderVerificationReasonFilter {
    Name: string;
    Description: string;
  }

  export interface ListOrderVerificationReasonsResponse {
    Results?: ListOrderVerificationReasonsResponse.OrderVerificationReason[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListOrderVerificationReasonsResponse {
    export interface OrderVerificationReason {
      /**
       * Entity type: OrderVerificationReason
       */
      ID: number;
      BackendID?: string;
      Name: string;
      Description: string;
    }

  }

  /**
   * Get order verification reason.
   */
  export interface GetOrderVerificationReason {
    /**
     * Entity type: OrderVerificationReason
     */
    ID: number;
  }

  export interface GetOrderVerificationReasonResponse {
    /**
     * Entity type: OrderVerificationReason
     */
    ID: number;
    BackendID?: string;
    Name: string;
    Description: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update an order verification reason
   */
  export interface UpdateOrderVerificationReason {
    /**
     * Entity type: OrderVerificationReason
     */
    ID: number;
    Name?: string;
    BackendID?: string;
    Description?: string;
  }

  /**
   * Delete an order verification reason
   */
  export interface DeleteOrderVerificationReason {
    /**
     * Entity type: OrderVerificationReason
     */
    ID: number;
  }

  /**
   * Placing an order means it is final for all parties; both agree on the exchange in goods, services and/or money that this order implies.
   * 
   * Will set the `Order`.`IsPlaced` flag.
   * 
   * This service can be used to place a single order, or to place a batch at once.
   */
  export interface PlaceOrder {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: Order
     */
    OrderIDs?: number[];
  }

  export interface PlaceOrderResponse {
    ValidationResult?: OrderExportValidationResult;
    ValidationResults?: OrderExportValidationResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Poll External Order Status
   */
  export interface PollExternalOrderStatus {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Name?: string;
  }

  /**
   * Prepare the order to go into the checkout
   * 
   * If the order still has status ShoppingCart, update it to Order and:
   *  - Validate lineactiontypes (customer are not allowed to use ShipLine p/a)
   *  - Set the SoldBy on the lines to the current user
   *  - Set the addresses of the customer on the order, if not already set
   *  - (Re)calculate the taxes
   *  - Recalculate the order: discounts, shippingcosts, giftwrappingcosts etc.
   */
  export interface PrepareOrderForCheckout {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Produce Tracking Information
   */
  export interface ProduceTrackingInformation {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface ProduceTrackingInformationResponse {
    Result: ProduceTrackingInformationResponse.TrackingInformation;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ProduceTrackingInformationResponse {
    export interface TrackingInformation {
      Link: string;
      Code: string;
    }

  }

  /**
   * Creates a returnorder with all specified data
   * 
   * It is required to send the identifier for the ReturnOrder of the external system by providing a BackendSystemID and a BackendID.
   * 
   * A return is based of an OriginalOrder. This order can be identifier by the OriginalBackendID or the OriginalOrderID. One of those is required.
   * 
   * If the stock is already received, set the `AlreadyReceived` to true. This will ship the order immediately.
   * 
   * If the stock is already received and the open amount should be refunded directly, set `AutoRefund` to true.
   * 
   * The Lines have to be identified by the original line, this should be done by providing the OriginalBackendID or the OriginalOrderLineID.
   * If those are not available the CustomID of the product can be set, but matching based on that is not advised.
   */
  export interface PushReturnOrder {
    /**
     * A code, free of choice for the calling 3rd party application creating the order
     */
    BackendSystemID: string;
    /**
     * A unique identifier for the order, within the context of given `BackendSystemID`
     */
    BackendID: string;
    /**
     * The unique identifier of the original order, within the context of given `BackendSystemID`
     */
    OriginalBackendID?: string;
    /**
     * Entity type: Order
     */
    OriginalOrderID?: number;
    /**
     * Remark on the order (optional)
     */
    Remark?: string;
    /**
     * Where the return will be booked. If not set, the logged in OU will be used.
     */
    ReturnToOrganizationUnitBackendID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    StockOrganizationUnitID?: number;
    /**
     * Ship the order immediately
     */
    AlreadyReceived?: boolean;
    /**
     * Try to refund the order immediately. Unreferenced returns cannot be auto refunded.
     */
    AutoRefund?: boolean;
    /**
     * Sends an invoice (credit note) - this is only done if AutoRefund or AlreadyReceived are also true, and requires a customer to be set
     */
    SendInvoice?: boolean;
    /**
     * If this order pending a customer return
     */
    IsCustomerReturn?: boolean;
    /**
     * Specifies if the order is an offer - this is only happening if AutoRefund or AlreadyReceived are set to false. If no value is specified, the default is false.
     * @default false
     */
    IsOffer?: boolean;
    /**
     * Specifies the offer expiration date.
     */
    OfferExpirationDate?: string;
    Lines: PushReturnOrder.PushReturnOrderLine[];
    ReturnCosts?: PushReturnOrder.PushReturnCostsLine;
    CustomFields?: { [key: string]: any };
    /**
     * Specify the customer for an unreferenced return.
     * Entity type: User
     */
    CustomerID?: number;
  }

  export namespace PushReturnOrder {
    export interface PushReturnOrderLine {
      /**
       * ID of the original orderline from the 3rd party
       */
      OriginalBackendID?: string;
      /**
       * Entity type: OrderLine
       */
      OriginalOrderLineID?: number;
      /**
       * Article number of the product from the 3rd party
       */
      CustomID?: string;
      /**
       * Entity type: Product
       */
      ProductID?: number;
      /**
       * Quantity that has been returned, positive
       */
      Quantity: number;
      /**
       * Remark describing something return related
       */
      Remark?: string;
      /**
       * Entity type: ReturnReason
       */
      ReturnReasonID?: number;
      SerialNumber?: string;
      /**
       * Return stock label. Only relevant for unreferenced returns.
       * Entity type: StockLabel
       */
      ReturnStockLabel?: number;
    }

    export interface PushReturnCostsLine {
      Description: string;
      UnitPrice: number;
      /**
       * Range: 1-2
       */
      TaxRate?: number;
      TaxAmount?: number;
    }

  }

  export interface PushReturnOrderResponse {
    /**
     * Entity type: Order
     */
    ID: number;
    /**
     * If the order with the specified BackendID already existed
     */
    AlreadyExists: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Creates an order with all specified data, places it, and raises all follow-up events.
   * 
   * Whenever the order already exists with the same BackendSystemID/BackendID combination, nothing will be modified.
   */
  export interface PushSalesOrder {
    /**
     * A code, free of choice for the calling 3rd party application creating the order
     */
    BackendSystemID?: string;
    /**
     * A unique identifier for the order, within the context of given `BackendSystemID`
     */
    BackendID?: string;
    /**
     * ISO code of the currency of the order
     */
    CurrencyID?: string;
    /**
     * Identifier for the (web)shop that made the sale (`OrganizationUnit.BackendID`)
     */
    SoldFromOrganizationUnitBackendID?: string;
    /**
     * Identifier for the shop where the order will be picked up, if any (`OrganizationUnit.BackendID`
     */
    PickupOrganizationUnitBackendID?: string;
    /**
     * Identifier for the shop where the order will be shipped to, if any (`OrganizationUnit.BackendID`
     */
    ShipToOrganizationUnitBackendID?: string;
    /**
     * How this order is fulfilled, this can be overridden on line level. Default to Delivery or Pickup (when a PickupOrganizationUnit is defined)
     */
    FulfillmentMethod?: OrderImportFulfillmentMethod;
    /**
     * The reason for this ReturnToSupplier order, used in combination with Properties.ReturnToSupplier. Required for ReturnToSupplier orders
     */
    ReturnToSupplierReason?: string;
    /**
     * Enabling this will try to suppress as many eventexports as possible that might result from this call.
     */
    DisableEventExports?: boolean;
    /**
     * Lock Order and block any future changes on it.
     */
    LockOrder?: boolean;
    LoyaltyProgramBackendID?: string;
    Customer?: PushSalesOrderCustomer;
    ShippingAddress?: PushSalesOrderAddress;
    BillingAddress?: PushSalesOrderAddress;
    PickupAddress?: PushSalesOrderAddress;
    Lines?: PushSalesOrderLine[];
    BackfillInformation?: PushSalesOrderBackfillInformation;
    Remark?: string;
    CustomData?: { [key: string]: any };
    CustomFields?: { [key: string]: any };
    Discounts?: PushSalesOrderDiscount[];
    Payments?: PushSalesOrderPayment[];
    Shipments?: PushSalesOrderShipment[];
    ShippingInformation?: PushSalesOrderShippingInformation;
    Properties?: PushSalesOrderProperties;
    Options?: PushSalesOrderOptions;
    Coupons?: PushSalesOrderCoupon[];
    /**
     * @default false
     */
    IsOffer?: boolean;
    OfferExpirationDate?: string;
    Company?: PushSalesOrderConsumerCompany;
  }

  export const enum OrderImportFulfillmentMethod {
    Delivery = 1,
    Pickup = 2,
    CarryOut = 3
  }

  export interface PushSalesOrderCustomer {
    BackendID?: string;
    EmailAddress?: string;
    /**
     * Possible values are: M, F, O
     */
    Gender?: string;
    Initials?: string;
    FirstName?: string;
    LastName?: string;
    PhoneNumber?: string;
    DateOfBirth?: string;
    PlaceOfBirth?: string;
    BankAccount?: string;
    Nickname?: string;
    /**
     * ISO 639-1
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * ISO 3166-1
     * Entity type: Country
     */
    CountryID?: string;
    FiscalID?: string;
    SocialSecurityNumber?: string;
    Title?: string;
    Salutation?: string;
    /**
     * Is this a Standard/Basic/Incognito account?
     * @default Standard
     */
    AccountType?: UserAccountType;
    /**
     * @deprecated Use PushSalesOrder.Company instead
     */
    Company?: PushSalesOrderCustomerCompany;
    BackendRelationID?: string;
  }

  export interface PushSalesOrderCustomerCompany {
    Name?: string;
    RegistrationNumber?: string;
    VatNumber?: string;
    FiscalID?: string;
  }

  export interface PushSalesOrderAddress {
    /**
     * House number, including possible extensions
     */
    HouseNumber?: string;
    Address1?: string;
    Address2?: string;
    FirstName?: string;
    LastName?: string;
    ZipCode?: string;
    City?: string;
    Region?: string;
    District?: string;
    Subdistrict?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    /**
     * ISO 3166-2
     */
    State?: string;
    /**
     * ISO 3166-1
     * Entity type: Country
     */
    CountryID?: string;
  }

  export interface PushSalesOrderLine {
    /**
     * Optional grouping identifier to keep lines 'together'.
     */
    GroupID?: string;
    /**
     * Child lines for this line
     */
    ChildLines?: ChildPushSalesOrderLine[];
    /**
     * ID of the order line from the 3rd party
     */
    BackendID?: string;
    /**
     * Article number of the product from the 3rd party
     */
    CustomID?: string;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Price of a single unit, before discounts, based on the SoldFromOrganizationUnit settings this should be in or ex tax. See service documentation.
     */
    Amount?: number;
    /**
     * Original price of a single unit, before discounts, based on the SoldFromOrganizationUnit settings this should be in or ex tax. See service documentation.
     */
    OriginalAmount?: number;
    Quantity?: number;
    /**
     * When no tax rate is provided, the taxrate will be based on what is known in Eva. When no rate can be determined, an error will be thrown.
     */
    TaxRate?: number;
    /**
     * When known the exact TaxAmount can be specified. Used when tax calculations are done by an external party like Avatax.
     */
    TaxAmount?: number;
    Description?: string;
    RequestedDeliveryDate?: string;
    Discounts?: PushSalesOrderDiscount[];
    CustomData?: { [key: string]: any };
    FulfillmentMethod?: OrderImportFulfillmentMethod;
    Shipments?: PushSalesOrderLineShipment[];
    /**
     * Used for passing in the serial number of, for example, a gift card. This is used to support refunding and other operations on the gift card.
     */
    SerialNumber?: string;
    /**
     * Used for passing in the data for a digital giftcard.
     */
    GiftcardData?: GiftCardData;
    /**
     * Used for passing in the media information for a digital giftcard.
     */
    GiftcardMedia?: GiftCardMedia;
    /**
     * Used for passing the identifier used to identify this line at the payment provider. This is required for payments that need capture on line level like Klarna.
     */
    PaymentLineIdentifier?: string;
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
    /**
     * Product requirements
     */
    ProductRequirements?: PushSalesOrderProductRequirement[];
    /**
     * Marks the line as a final sale line, making it non returnable.
     */
    IsFinalSale?: boolean;
    /**
     * A code identifying the tax exemption.
     */
    TaxExemptionCode?: string;
    /**
     * A longer description with the justification for the tax exemption.
     */
    TaxExemptionReason?: string;
    TaxRateCategory?: TaxRateCategory;
    /**
     * Allows you to specify a preferred organization for doing the physical fulfillment of the OrderLine.
     * Depending on your order orchestration configuration this can be a hard filter or merely a preference.
     */
    PreferredFulfillmentOrganizationUnitBackendID?: string;
  }

  export interface ChildPushSalesOrderLine {
    /**
     * ID of the order line from the 3rd party
     */
    BackendID?: string;
    /**
     * Article number of the product from the 3rd party
     */
    CustomID?: string;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Price of a single unit, before discounts, based on the SoldFromOrganizationUnit settings this should be in or ex tax. See service documentation.
     */
    Amount?: number;
    /**
     * Original price of a single unit, before discounts, based on the SoldFromOrganizationUnit settings this should be in or ex tax. See service documentation.
     */
    OriginalAmount?: number;
    Quantity?: number;
    /**
     * When no tax rate is provided, the taxrate will be based on what is known in Eva. When no rate can be determined, an error will be thrown.
     */
    TaxRate?: number;
    /**
     * When known the exact TaxAmount can be specified. Used when tax calculations are done by an external party like Avatax.
     */
    TaxAmount?: number;
    Description?: string;
    RequestedDeliveryDate?: string;
    Discounts?: PushSalesOrderDiscount[];
    CustomData?: { [key: string]: any };
    FulfillmentMethod?: OrderImportFulfillmentMethod;
    Shipments?: PushSalesOrderLineShipment[];
    /**
     * Used for passing in the serial number of, for example, a gift card. This is used to support refunding and other operations on the gift card.
     */
    SerialNumber?: string;
    /**
     * Used for passing in the data for a digital giftcard.
     */
    GiftcardData?: GiftCardData;
    /**
     * Used for passing in the media information for a digital giftcard.
     */
    GiftcardMedia?: GiftCardMedia;
    /**
     * Used for passing the identifier used to identify this line at the payment provider. This is required for payments that need capture on line level like Klarna.
     */
    PaymentLineIdentifier?: string;
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
    /**
     * Product requirements
     */
    ProductRequirements?: PushSalesOrderProductRequirement[];
    /**
     * Marks the line as a final sale line, making it non returnable.
     */
    IsFinalSale?: boolean;
    /**
     * A code identifying the tax exemption.
     */
    TaxExemptionCode?: string;
    /**
     * A longer description with the justification for the tax exemption.
     */
    TaxExemptionReason?: string;
    TaxRateCategory?: TaxRateCategory;
    /**
     * Allows you to specify a preferred organization for doing the physical fulfillment of the OrderLine.
     * Depending on your order orchestration configuration this can be a hard filter or merely a preference.
     */
    PreferredFulfillmentOrganizationUnitBackendID?: string;
  }

  export interface PushSalesOrderDiscount {
    /**
     * Reference to the discount of the 3rd party
     */
    BackendID?: string;
    /**
     * Amount of the discount, typically with a negative value
     */
    Amount?: number;
    Description?: string;
    CampaignName?: string;
    CouponCode?: string;
  }

  export interface PushSalesOrderLineShipment {
    /**
     * Identifier of the shipment, must exist in the Order.Shipments
     */
    ShipmentBackendID: string;
    /**
     * Identifier of the shipment line
     */
    BackendID?: string;
    /**
     * Date when this shipment line was shipped, will fall-back to the Shipment.ShipmentDate
     */
    ShipmentDate?: string;
    Quantity: number;
  }

  export interface GiftCardData {
    Theme: GiftCardTheme;
    From: string;
    To: string;
    Text: string;
    FromEmailAddress?: string;
    ToEmailAddress?: string;
    PhoneNumber?: string;
    DeliverySchedule?: string;
    UpdateUrl: string;
    DeliveryMode?: GiftCardDeliveryMode;
  }

  export interface GiftCardTheme {
    ID: string;
    Name: string;
    Description: string;
    LongDescription: string;
    ForegroundColor: string;
    BackgroundColor: string;
    ImageUrl: string;
    ImageBlobID?: string;
    ImageWidth: number;
    ImageHeight: number;
    VideoUrl: string;
    VideoBlobID?: string;
    CloudinaryImagePublicID: string;
    CloudinaryVideoPublicID: string;
  }

  export const enum GiftCardDeliveryMode {
    Default = 0,
    Instant = 1,
    NotSet = 2
  }

  export interface GiftCardMedia {
    CloudinaryImageID?: string;
    CloudinaryImageMimeType?: string;
    CloudinaryVideoID?: string;
    CloudinaryVideoMimeType?: string;
  }

  export interface PushSalesOrderProductRequirement {
    Name: string;
    Value?: any;
  }

  export interface PushSalesOrderBackfillInformation {
    /**
     * Original date when this order was created
     */
    OriginalCreationDate?: string;
    /**
     * Original date when this order was invoiced
     */
    OriginalInvoiceDate?: string;
    /**
     * Original invoicenumber of this order
     */
    OriginalInvoiceNumber?: string;
  }

  export interface PushSalesOrderPayment {
    /**
     * Identifier of the payment by the 3rd party (e.g. the one from the payment service provider (PSP))
     */
    BackendID?: string;
    /**
     * Code of the payment method (e.g. `ADYEN_IDEAL`)
     */
    Method?: string;
    /**
     * Amount of the payment that was actually paid
     */
    Amount?: number;
    /**
     * Part (or all) of the amount that has already been captured for this payment.
     * This amount should always be in the base currency of the order.
     */
    CapturedAmount?: number;
    /**
     * If this is set to not None, the Payment will not be considered captured, but only Authorized. This means the capture will be done based on this value.
     * If it's not set, the CaptureMoment will be determined based on the PaymentType.
     */
    CaptureMoment?: PaymentTypeCaptureMoment;
    /**
     * Data that can be used to store anything that may be required later to verify the payment for example
     */
    Data?: string;
    /**
     * This property is optional but becomes mandatory when a payment is made in a currency different from the order base currency.
     * It indicates the currency used for the payment.
     */
    ForeignCurrencyID?: string;
    /**
     * This property is optional but becomes mandatory when a payment is made in a currency different from the order base currency.
     * It indicates the specific amount paid in the foreign currency.
     */
    ForeignAmount?: number;
    /**
     * Whether to automatically confirm the payment or adhere to the payment type configuration.
     * The default value is set to true.
     */
    AutoConfirm?: boolean;
  }

  export interface PushSalesOrderShipment {
    /**
     * Identifier of the shipment; should also be filled on Line.Shipments.ShipmentBackendID
     */
    BackendID?: string;
    /**
     * Date when this shipment was shipped
     */
    ShipmentDate?: string;
    TrackingCode?: string;
    TrackingLink?: string;
  }

  export interface PushSalesOrderShippingInformation {
    /**
     * Method that is used to ship the order (e.g. UPS, DHL, etc.)
     */
    Method?: string;
    /**
     * ShippingCosts, before discounts, based on the SoldFromOrganizationUnit settings this should be in or ex tax. See service documentation.
     */
    Amount?: number;
    /**
     * Tax rate of the shipping method, when `Amount` / `UnitPriceInTax` is set and it's not provided, the taxrate will be based on what is known in Eva. When no rate can be determined, an error will be thrown.
     */
    TaxRate?: number;
    /**
     * When known the exact TaxAmount can be specified. Used when tax calculations are done by an external party like Avatax.
     */
    TaxAmount?: number;
    Discount?: PushSalesOrderDiscount;
    /**
     * Used for passing the identifier used to identify the shipping costs at the payment provider. This is required for payments that need capture on line level like Klarna.
     */
    PaymentLineIdentifier?: string;
  }

  export interface PushSalesOrderProperties {
    IsInterbranch?: boolean;
    Replenishment?: boolean;
    ReturnToSupplier?: boolean;
  }

  export interface PushSalesOrderOptions {
    /**
     * Never generate an invoice for this order. The order will be completed when it's Paid+Shipped
     */
    DoNotInvoice?: boolean;
    /**
     * Allow the order to be fulfilled in multiple shipments
     */
    AllowPartialFulfillment?: boolean;
    /**
     * When true, this service call return with an error when the order does not end up with an open amount of exactly 0
     */
    CheckOpenAmountIsZero?: boolean;
  }

  export interface PushSalesOrderCoupon {
    DiscountBackendID: string;
    CouponCode: string;
  }

  export interface PushSalesOrderConsumerCompany {
    /**
     * If provided and valid, the existing company data will be updated
     * Entity type: Company
     */
    ID?: number;
    /**
     * Only applicable when a new company is created
     */
    BackendID?: string;
    /**
     * If not provided on create, the creation of a new company will be skipped
     */
    Name?: string;
    RegistrationNumber?: string;
    RegistrationCountryID?: string;
    RegistrationCountrySubdivisionID?: string;
    TaxRegistrationNumber?: string;
    FiscalID?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    TaxRecipientCode?: string;
    TaxRecipientEmail?: string;
    /**
     * Only applicable when a new company is created
     */
    SingleUse?: boolean;
    IsInvoicing?: boolean;
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
    /**
     * Only applicable when a new company is created
     * Entity type: User
     */
    UserID?: number;
  }

  export interface PushSalesOrderResponse {
    /**
     * Entity type: Order
     */
    ID: number;
    /**
     * Entity type: User
     */
    CustomerID?: number;
    /**
     * Entity type: Company
     */
    CompanyID?: number;
    AlreadyExists: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Remove offer expiration date for an order specified by `OrderID`.
   */
  export interface RemoveOfferStatusFromOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Reserve an Order.
   * 
   * The Lines on the Order with LineActionType ReserveLine will be reserved:
   * - The Stock will be moved from Sellable to Reserved
   * - A receipt will be printed
   */
  export interface ReserveOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Station to print the receipt on
     * Entity type: Station
     */
    StationID?: number;
  }

  /**
   * Search for any type of orders by providing the filter details properties
   * Important search criterias are: OrganizationUnitID, CurrentOrganizationUnitType, OrderIDs, CustomerID(ClientContext.Type), PaymentStatus.
   * 
   * When no StartTime is provided this will be defaulted to 3 months ago. The only exception is when specific OrderIDs are provided, then it's allowed to not specify a Date.
   * 
   * To include the custom fields of the customer, the property `AdditionalOrderDataOptions.CustomerCustomFields` can be set to `true`.
   * 
   * E.g. request:
   * {
   *   "OrderIDs": [
   *     "orderID1",
   *     "orderID2"
   *   ],
   *   "PaymentStatus": "PaymentStatus",
   *   "IsShipped": "isShipped"
   * }
   * 
   * 
   * Payment status options:
   *     NotPaid = 0,
   *     Paid = 1,
   *     Partial = 2
   */
  export interface SearchOrders {
    Query?: string;
    IsConfirmed?: boolean;
    IsPlaced?: boolean;
    IsShipped?: boolean;
    IsCompleted?: boolean;
    IsCaptured?: boolean;
    IsSuspended?: boolean;
    HasShipLines?: boolean;
    HasDeliveryLines?: boolean;
    HasReserveLines?: boolean;
    HasOrderLines?: boolean;
    HasPreSaleLines?: boolean;
    /**
     * The StartTime will default to 3 months ago if not provided and OrderIDs are not provided.
     */
    StartTime?: string;
    EndTime?: string;
    StartCreationTime?: string;
    EndCreationTime?: string;
    StartPlacementDate?: string;
    EndPlacementDate?: string;
    StartRequestedDate?: string;
    EndRequestedDate?: string;
    StartShipmentDate?: string;
    EndShipmentDate?: string;
    StartConfirmationDate?: string;
    EndConfirmationDate?: string;
    StartMinExpectedAvailabilityDate?: string;
    EndMinExpectedAvailabilityDate?: string;
    StartMaxExpectedAvailabilityDate?: string;
    EndMaxExpectedAvailabilityDate?: string;
    /**
     * Entity type: Order
     */
    OrderIDs?: number[];
    OrderBackendID?: string;
    OrderDisplayID?: string;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    PaymentStatus?: PaymentStatus;
    InvoiceNumber?: string;
    CompanyName?: string;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    SerialNumber?: string;
    /**
     * Entity type: Discount
     */
    DiscountIDs?: number[];
    IsReserved?: boolean;
    IsOrder?: boolean;
    IsInvoiced?: boolean;
    IsEmpty?: boolean;
    IsExported?: boolean;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID?: number;
    PaymentTypeName?: string;
    PaymentTransactionBackendID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    MinTotalAmountInTax?: number;
    MaxTotalAmountInTax?: number;
    MinOpenAmountInTax?: number;
    MaxOpenAmountInTax?: number;
    MinTotalItems?: number;
    MaxTotalItems?: number;
    ProductVariation?: { [key: string]: string[] };
    Data?: { [key: string]: OrderSearchDataFilterModel };
    /**
     * Entity type: CustomField
     */
    CustomFields?: { [key: number]: string };
    CustomFieldsByBackendID?: { [key: string]: string };
    HasCancelledLines?: boolean;
    HasDisputedPayments?: boolean;
    HasUnresolvedDisputedPayments?: boolean;
    HasCustomer?: boolean;
    /**
     * Defaults to OrderSearchOrderTypes.Sales
     */
    Type?: OrderSearchOrderTypes;
    /**
     * Defaults to OrderTypes.Sales
     * @deprecated Replaced with Type
     */
    OrderType?: OrderTypes;
    OrderStatus?: OrderStatus;
    /**
     * Entity type: OrganizationUnit
     */
    ShipFromOrganizationUnitID?: number;
    /**
     * Entity type: User
     */
    CustomerID?: number;
    /**
     * Entity type: User
     */
    CustomerIDs?: number[];
    CustomerBackendID?: string;
    /**
     * Entity type: User
     */
    CreatedByID?: number;
    /**
     * Entity type: User
     */
    LastModifiedByID?: number;
    CustomerReference?: string;
    /**
     * Entity type: OrganizationUnit
     */
    ShipToOrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    FulfillmentOrganizationUnitIDs?: number[];
    /**
     * Entity type: Country
     */
    ShipToCountryID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    SoldFromOrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    SoldToOrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OriginatingOrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    PickupOrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    ShippingOrganizationUnitID?: number;
    IncludeChildOrganizationUnits?: boolean;
    /**
     * Properties that should be present on the order
     */
    Properties?: number[];
    /**
     * Properties that should not be present on the order
     */
    NotProperties?: number[];
    CustomStatus?: number[];
    UserAgentApplication?: string[];
    FulfillmentStatus?: OrderSearchFulfillmentStatusFilterModel;
    /**
     * Entity type: Carrier
     */
    CarrierID?: number;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    IsOffer?: boolean;
    IsExpiredOffer?: boolean;
    StartOfferExpirationDate?: string;
    EndOfferExpirationDate?: string;
    CustomerOrderStatus?: string[];
    CustomerOrderStatusBackendID?: string[];
    CustomerOrderTypeBackendID?: string[];
    /**
     * Entity type: ReturnToSupplierRequest
     */
    ReturnToSupplierRequestID?: number;
    OrderFulfillmentReferenceNumbers?: string[];
    /**
     * Entity type: CustomOrderType
     */
    CustomOrderTypeID?: number;
    /**
     * Entity type: OrderCustomStatus
     */
    OrderCustomStatusID?: number;
    /**
     * Entity type: OrderCustomType
     */
    OrderCustomTypeID?: number;
    IsCrossChannelReturn?: boolean;
    IsClickAndCollect?: boolean;
    IsEndlessAisle?: boolean;
    HasSoldToOrganizationUnit?: boolean;
    AdditionalOrderDataOptions?: SearchOrders.AdditionalSearchOrderDataOptions;
    IsReturnToSupplier?: boolean;
    HasPriceCorrection?: boolean;
    /**
     * Use only when really needed. This will include the first order line description in the search result.
     */
    IncludeFirstOrderLineDescription?: boolean;
    /**
     * Find the generated renewal orders for a specific subscription
     * Entity type: UserProductSubscription
     */
    UserProductSubscriptionID?: number;
    HasProductSubscriptions?: boolean;
    AggregationOptions?: OrderSearchAggregationOptions;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export namespace SearchOrders {
    export interface AdditionalSearchOrderDataOptions {
      CustomerCustomFields?: boolean;
    }

  }

  export const enum PaymentStatus {
    NotPaid = 0,
    Paid = 1,
    Partial = 2
  }

  export interface OrderSearchDataFilterModel {
    StringValue: string;
    BooleanValue?: boolean;
    StartDateTime?: string;
    EndDateTime?: string;
    StartDecimal?: number;
    EndDecimal?: number;
  }

  export const enum OrderSearchOrderTypes {
    Sales = 0,
    Purchase = 1,
    ReturnToSupplier = 2,
    Interbranch = 3
  }

  export interface OrderSearchFulfillmentStatusFilterModel {
    CanFulfill?: boolean;
    IsBlocked?: boolean;
  }

  export interface OrderSearchAggregationOptions {
    UserAgentApplication?: boolean;
    ProductVariations?: boolean;
  }

  /**
   * The Result propery contains the paged orders.
   * Result.Page contains the first sequence of the paged result.
   * Result.Page.ID is the orderID.
   */
  export interface SearchOrdersResponse {
    ProductVariations: { [key: string]: { [key: string]: number } };
    UserAgents: { [key: string]: { [key: string]: number } };
    CustomerOrderStatuses: { [key: string]: number };
    Result?: PagedResult<OrderSearchResultItem>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface OrderSearchResultItem {
    CreatedBy: OrderSearchResultItemUser;
    LastModifiedBy: OrderSearchResultItemUser;
    Customer: OrderSearchResultItemCustomer;
    OrganizationUnits: OrderSearchResultItemOrganizationUnit[];
    SoldFromOrganizationUnit: OrderSearchResultItemOrganizationUnit;
    SoldToOrganizationUnit: OrderSearchResultItemOrganizationUnit;
    ShipFromOrganizationUnit: OrderSearchResultItemOrganizationUnit;
    ShipToOrganizationUnit: OrderSearchResultItemOrganizationUnit;
    ShippingAddress: OrderSearchResultItemAddress;
    OriginatingOrganizationUnit: OrderSearchResultItemOrganizationUnit;
    PickupOrganizationUnitID: OrderSearchResultItemOrganizationUnit;
    PriceListIDs: number[];
    IsCompleted: boolean;
    IsPaid: boolean;
    IsCaptured: boolean;
    IsSuspended: boolean;
    IsPlaced: boolean;
    IsConfirmed: boolean;
    IsShipped: boolean;
    IsReserved: boolean;
    IsInvoiced: boolean;
    HasShipLines?: boolean;
    HasDeliveryLines?: boolean;
    HasReserveLines?: boolean;
    HasOrderLines?: boolean;
    HasPreSaleLines?: boolean;
    /**
     * Entity type: Order
     */
    ID: number;
    BackendID: string;
    TotalAmountInTax: number;
    TotalAmount: number;
    PaidAmount: number;
    ForeignPaidAmount: number;
    OpenAmountInTax: number;
    OpenAmount: number;
    LastModificationTime: string;
    CreationTime: string;
    CurrencyID: string;
    Type: OrderTypes;
    Status: OrderStatus;
    IsOffer?: boolean;
    IsExpiredOffer?: boolean;
    CustomerReference: string;
    HasCancelledLines: boolean;
    HasPriceCorrection: boolean;
    HasDisputedPayments: boolean;
    HasUnresolvedDisputedPayments: boolean;
    TotalItems: number;
    TotalQuantityToShip: number;
    TotalQuantityShipped: number;
    Properties: OrderProperties;
    PropertiesIDs: number[];
    CustomStatus: number;
    CustomStatusIDs: number[];
    OrderCustomTypeID?: number;
    OrderCustomStatusID?: number;
    RequestedDate?: string;
    ConfirmationDate?: string;
    Data: OrderSearchResultItemData[];
    IsEmpty: boolean;
    UserAgentApplication: string;
    UserAgentVersion: string;
    ProductImage: string;
    ProductImageUrl: string;
    FirstOrderLineDescription?: string;
    Definition: OrderSearchResultItemDefinition;
    ReturnToSupplierRequest: OrderSearchResultItemReturnToSupplierRequest;
    /**
     * Entity type: CustomOrderType
     */
    CustomOrderTypeID?: number;
    MinExpectedAvailabilityDate?: string;
    MaxExpectedAvailabilityDate?: string;
    PlacementDate?: string;
    DisplayID?: string;
  }

  export interface OrderSearchResultItemUser {
    /**
     * Entity type: User
     */
    ID: number;
    FullName: string;
  }

  export interface OrderSearchResultItemCustomer {
    EmailAddress: string;
    /**
     * Entity type: CustomField
     */
    CustomFieldValues: { [key: number]: CustomFieldValue };
    /**
     * Entity type: User
     */
    ID: number;
    FullName: string;
  }

  export interface OrderSearchResultItemOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
    Name: string;
  }

  export interface OrderSearchResultItemAddress {
    CountryID: string;
  }

  export interface OrderSearchResultItemData {
    Name: string;
    StringValue: string;
    DecimalValue?: number;
    BooleanValue?: boolean;
    DateValue?: string;
  }

  export interface OrderSearchResultItemDefinition {
    Status: OrderSearchResultItemDefinition.Value;
    Type: OrderSearchResultItemDefinition.Value;
  }

  export namespace OrderSearchResultItemDefinition {
    export interface Value {
      BackendID: string;
      Title: string;
    }

  }

  export interface OrderSearchResultItemReturnToSupplierRequest {
    ID: number;
    Name: string;
  }

  /**
   * Update the serial number on an order line - when no serialnumber is provided, it will be removed.
   */
  export interface UpdateSerialNumber {
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    SerialNumber?: string;
  }

  /**
   * Sets the first serial number on given order line, and splits off new order lines for each additional serial number given.
   */
  export interface SetSerialNumbers {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    SerialNumbers: string[];
  }

  /**
   * This service can be used when in local mode to set some UserIdentifiers on an Order
   * 
   * If ParseBarcode responds with ParsedButNotFound, this service can be used to set the UserIdentifiers on the Order.
   * Or an EmailAddress can be manually set.
   * 
   * When the order is exported to the cloud, the UserIdentifiers will be used to match the order to the correct user.
   */
  export interface SetCustomerIdentifiersOnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    UserID?: string;
    UserSubscriptionID?: string;
    UserBackendID?: string;
    UserCustomID?: string;
    EmailAddress?: string;
  }

  /**
   * Add or update customer reference values on an order using OrderID.
   */
  export interface SetCustomerReferencesOnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    CustomerReference?: string;
    CustomerOrderID?: string;
  }

  /**
   * Sets `BackendID`/`BackendSystemID` on specified `OrderID`.
   * 
   * This combination may not already exist, and the targeted order may not be completed, or  already have a `BackendID`/`BackendSystemID` set.
   * 
   * :warning: Careful! Use at your own risk!
   * 
   * An order may already have any of the following things, which will not automatically be regenerated/resent because of this identifier change, and could
   * result in mapping issues on any external system listening in on these. Any of these would also apply to return orders referencing this order, or stock
   * mutations that have been caused by this order.
   * 
   * * Order exports to third parties
   * * Event exports (order created, order updated, ...)
   * * Data Lake exports
   * * Shipment labels with third party carriers
   * * Financial exports (Cookbook)
   * * Created documents (receipts, invoices, ...)
   */
  export interface SetOrderBackendIdentifier {
    /**
     * The EVA order identifier
     * Entity type: Order
     */
    OrderID: number;
    /**
     * A code, free of choice for the calling 3rd party application creating the order
     */
    BackendSystemID: string;
    /**
     * A unique identifier for the order, within the context of given `BackendSystemID`
     */
    BackendID: string;
  }

  /**
   * Sets the `SoldBy` of the specified sales order to the provided `UserID`.
   * 
   * - The user must have type `Employee`
   * - This service can only be called on orders that have not been invoiced yet
   * - As `SoldBy` is a line-level property this service will update all lines on the order that have not been invoiced yet
   */
  export interface SetOrderSoldBy {
    /**
     * The order to set the `SoldBy` for - must be of type `Sales`.
     * Entity type: Order
     */
    OrderID: number;
    /**
     * The user that will become the `SoldBy`- must be of type `Employee`.
     * Entity type: User
     */
    UserID: number;
    /**
     * If specified, sets the `SoldBy` only for the given order lines.
     * 
     * :warning: If `SetOrderSoldBy` is called again for the whole order (so without specifying `OrderLineIDs`) this value is overwritten
     * :notebook: Newly created order lines will not automatically inherit `SoldBy` set on invidivual order lines
     * Entity type: OrderLine
     */
    OrderLineIDs?: number[];
  }

  /**
   * Set Pickup Organization Unit
   */
  export interface SetPickupOrganizationUnit {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  /**
   * Set Remark On Order
   */
  export interface SetRemarkOnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Remark?: string;
  }

  /**
   * Set the `RequestedDate` on OrderLines.
   * The RequestedDate is the date on which the OrderLine should be ready for shipping/pickup/etc.
   * 
   * It is required to provide an `OrderID`.
   * If the RequestedDate is null, it will be removed from the lines.
   */
  export interface SetRequestedDate {
    /**
     * Entity type: Order
     */
    OrderID: number;
    OrderLines?: SetRequestedDate.OrderLineDto[];
    RequestedDate?: string;
  }

  export namespace SetRequestedDate {
    export interface OrderLineDto {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      Quantity?: number;
      RequestedDate?: string;
    }

  }

  /**
   * Sets the shipping method for the given order(lines). Use `ListAvailableShippingMethods` to request the shipping methods that can be used as input to this service.
   */
  export interface SetShippingMethod {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineIDs?: number[];
    /**
     * This date can be used to request a specific delivery date. If null, it will be sent at the first available date.
     */
    RequestedDeliveryDate?: string;
  }

  /**
   * Updates the StockProductID for an OrderLine
   */
  export interface SetStockProductForOrderLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Entity type: Product
     */
    StockProductID?: number;
  }

  /**
   * Ships an order that has been exported to an external system by another proces
   */
  export interface ShipExternalOrder {
    /**
     * ID of the order that is being shipped - required when `BackendID` and `BackendSystemID` are omitted
     * Entity type: Order
     */
    ID?: number;
    /**
     * Reference to the order that is being shipped - required when `ID` is omitted
     */
    BackendID?: string;
    /**
     * Reference to the system from which the order originated - required when `ID` is omitted
     */
    BackendSystemID?: string;
    Shipments: ShipExternalOrder.Shipment[];
    /**
     * Indicates if this is the last shipment - when set to true will cancel any remaining lines that are not shipped
     */
    FinalShipment?: boolean;
  }

  export namespace ShipExternalOrder {
    export interface Shipment {
      /**
       * Reference number of the shipment
       */
      BackendID: string;
      /**
       * Identifier of the system that created the shipment
       */
      BackendSystemID: string;
      /**
       * Optional tracking code that is stored on the shipment.
       */
      TrackingCode?: string;
      /**
       * Optional tracking link that is stored on the shipment
       */
      TrackingLink?: string;
      /**
       * Entity type: Package
       */
      PackageID?: number;
      Lines?: ShipExternalOrder.ShipmentLine[];
      Packages?: ShipExternalOrder.ShipmentPackage[];
      /**
       * Optional additional custom fields
       */
      CustomFields?: CustomFieldKeyValue[];
      /**
       * Create shipment as being shipped from this OU, which affects which stock is mutated and the financial consequences of that
       * Entity type: OrganizationUnit
       */
      ShipFromOrganizationUnitID?: number;
    }

    export interface ShipmentLine {
      /**
       * Used to identify the order line - required if BackendID and Barcode are omitted
       * Entity type: OrderLine
       */
      ID?: number;
      /**
       * Used to identify the order line - required if ID and Barcode are omitted
       */
      BackendID?: string;
      /**
       * Used to identify the order line - required if ID and BackendID are omitted
       */
      Barcode?: string;
      /**
       * Number of products that have been shipped
       */
      Quantity: number;
      /**
       * In case of serial number products (like gift cards), this field is required and indicates the shipped serial number
       */
      SerialNumber?: string;
      /**
       * In case of shipping multiple serial numbers at once
       */
      SerialNumbers?: string[];
      /**
       * Entity type: Product
       */
      StockProductID?: number;
    }

    export interface ShipmentPackage {
      /**
       * Entity type: Package
       */
      PackageID: number;
      Lines: ShipExternalOrder.ShipmentLine[];
    }

  }

  export interface ShipExternalOrderResponse {
    /**
     * Entity type: Shipment
     */
    ShipmentIDs: number[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ShipOrderLines {
    ShipmentBackendID?: string;
    TrackingCode?: string;
    ShipmentDate: string;
    Lines: ShipOrderLines.Line[];
    /**
     * The OrganizationUnit the shipment was physically shipped from.
     * Entity type: OrganizationUnit
     */
    ShippedFromOrganizationUnitID?: number;
  }

  export namespace ShipOrderLines {
    export interface Line {
      /**
       * Entity type: OrderLine
       */
      ID: number;
      Quantity: number;
      BackendReference: string;
      /**
       * Entity type: Product
       */
      StockProductID?: number;
    }

  }

  export interface ShipOrderLinesResponse {
    ShipmentID?: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Ships the specified order. When Lines are specified, only those lines will be shipped.
   * 
   * Shipping of Lines includes:
   * - Activating giftcards
   * - Mutating the stock of the products
   * - Potentially invoicing of the lines
   * - Validating requirements
   */
  export interface ShipOrder {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    Lines?: ShipOrder.ShipmentOrderLine[];
    /**
     * Use with caution.
     * Set this to true if you want to skip requirements that would otherwise cause validation errors. Like shipping delivery lines, which you usually don't want from a shop.
     */
    Force?: boolean;
    FinalShipment?: boolean;
    /**
     * The OrganizationUnit the shipment was physically shipped from.
     * Entity type: OrganizationUnit
     */
    ShippedFromOrganizationUnitID?: number;
    /**
     * The BackendID used for the shipment. Can be overridden on each line.
     */
    ShipmentBackendID?: string;
    /**
     * The TrackingCode used for the shipment. Can be overridden on each line.
     */
    TrackingCode?: string;
    /**
     * The TrackingLink used for the shipment. Can be overridden on each line.
     */
    TrackingLink?: string;
  }

  export namespace ShipOrder {
    export interface ShipmentOrderLine {
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      QuantityShipped?: number;
      /**
       * The BackendID used for the shipment, lines will be grouped on this to create Shipments. Will fallback to the ShipmentBackendID on the root of the request.
       */
      ShipmentBackendID?: string;
      /**
       * The TrackingCode used for the shipment. Will fallback to the TrackingCode on the root of the request.
       */
      TrackingCode?: string;
      /**
       * The TrackingLink used for the shipment. Will fallback to the TrackingLink on the root of the request.
       */
      TrackingLink?: string;
      /**
       * Entity type: Product
       */
      StockProductID?: number;
    }

  }

  export interface ShipOrderResponse {
    /**
     * Entity type: Shipment
     */
    ShipmentIDs: number[];
    /**
     * Entity type: OrderLine
     */
    ShippedOrderLineIDs: number[];
    Messages: ShipmentResultMessage[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ShipmentResultMessage {
    Code: string;
    Message: string;
  }

  /**
   * Split an OrderLine in two lines.
   * 
   * The new line will have a QuantityOrdered of QuantityToSplit and on the existing line there will be QuantityToShip items cancelled.
   * If the OrderLine has a negative QuantityToShip, the QuantityOrdered of the new line will be -QuantityToSplit.
   * 
   * The QuantityToSplit should always be greather than 0 and smaller than the absolute value of the QuantityToShip of the OrderLine.
   */
  export interface SplitOrderLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    QuantityToSplit: number;
  }

  export interface SplitOrderLineResponse {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Marks the provided Order or OrderLine as exempt from tax, with specified code and reason.
   * 
   * When exempting the Order, this also marks all current OrderLines of the Order that haven't been invoiced yet as tax-exempt. All future
   * OrderLines created on this Order will then also automatically be made tax-exempt.
   * 
   * Calling this service is irreversible; once the Order is marked as tax exempt, it cannot be undone and can only be worked around by creating a new Order.
   */
  export interface ExemptOrderFromTax {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * A code identifying the tax exemption.
     */
    TaxExemptionCode?: string;
    /**
     * A longer description with the justification for the tax exemption.
     */
    TaxExemptionReason: string;
    /**
     * This verification number is a confirmation of the tax exemption reason.
     */
    TaxExemptionVerification?: string;
  }

  /**
   * Will return the estimated tax for specified order, but does not persist through the order amounts retrieved elsewhere.
   */
  export interface GetSalesTaxEstimateForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface SalesTaxEstimateForOrderResponse {
    IsSuccess: boolean;
    TotalTaxAmount: number;
    TaxTable: SalesTaxEstimateForOrderResponse.OrderLineTaxCalculationTaxAmountModel[];
    OrderLines: SalesTaxEstimateForOrderResponse.OrderLineTaxCalculationModel[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace SalesTaxEstimateForOrderResponse {
    export interface OrderLineTaxCalculationTaxAmountModel {
      TaxRate: number;
      TaxAmount: number;
    }

    export interface OrderLineTaxCalculationModel {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      TaxRate: number;
      TaxAmount: number;
    }

  }

  /**
   * Will apply and return the estimated tax for specified order. Its effect is persistent through all subsequent calls for this orders' amounts.
   */
  export interface ApplySalesTaxEstimateForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Transfers the provided Order to the OrganizationUnit of the currently logged in user, updating both the SoldFromOrganizationUnit and PickupOrganizationUnit.
   * 
   * If this is already the case, calling this service has no effect. In case the order cannot be transferred, this service will return an error.
   */
  export interface TransferOrderToOrganizationUnit {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Get additional order line information intended for transport data.
   */
  export interface GetTransportOrderLineData {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
  }

  export interface GetTransportOrderLineDataResponse {
    TransportOrderLineData: TransportOrderLineData;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface TransportOrderLineData {
    TransportID: string;
    Priority?: number;
    PlannedDate?: string;
    Timeslot: string;
  }

  /**
   * Set additional order line information intended for transport data. Supports a single `OrderLineID`, or a list of `OrderLineIDs`.
   */
  export interface SetTransportOrderLineData {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineIDs?: number[];
    TransportOrderLineData?: TransportOrderLineData;
  }

  /**
   * Update Contract Number
   */
  export interface UpdateContractNumber {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    ContractNumber?: string;
  }

  /**
   * Get Contract Number
   */
  export interface GetContractNumber {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
  }

  export interface GetContractNumberResponse {
    ContractNumber: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update Order Addresses
   */
  export interface UpdateOrderAddresses {
    /**
     * Entity type: Order
     */
    OrderID: number;
    CopyShippingAddressFromCustomer?: boolean;
    CopyBillingAddressFromCustomer?: boolean;
    ShipToAddress?: AddressDataDto;
    BillToAddress?: AddressDataDto;
    PickupAddress?: AddressDataDto;
  }

  export interface UpdateOrderAddressesResponse {
    CreditcardAllowed: boolean;
    ShipToAddress: AddressDto;
    BillToAddress: AddressDto;
    PickupAddress: AddressDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update the ShippingAddress on an Order.
   * 
   * This can be done by providing a full Address in the Address property, or by referencing an Address in an AddressBook in the AddressBookID property.
   */
  export interface UpdateOrderShippingAddress {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Address?: AddressDataDto;
    /**
     * Entity type: AddressBook
     */
    AddressBookID?: number;
  }

  export interface UpdateOrderAddressResponse {
    ShippingAddress?: AddressDto;
    BillingAddress?: AddressDto;
    PickupAddress?: AddressDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update the BillingAddress on an Order.
   * 
   * This can be done by providing a full Address in the Address property, or by referencing an Address in an AddressBook in the AddressBookID property.
   */
  export interface UpdateOrderBillingAddress {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Address?: AddressDataDto;
    /**
     * Entity type: AddressBook
     */
    AddressBookID?: number;
  }

  /**
   * Update the PickupAddress on an Order.
   * 
   * This can be done by providing a full Address in the Address property, or by referencing an Address in an AddressBook in the AddressBookID property.
   */
  export interface UpdateOrderPickupAddress {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    Address?: AddressDataDto;
    /**
     * Entity type: AddressBook
     */
    AddressBookID?: number;
  }

  /**
   * Update the data for the checkout options returned in the `AdditionalData` of a `GetOrder` or `GetShoppingCart` call
   */
  export interface UpdateOrderCheckoutOptions {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Options: UpdateOrderCheckoutOptions.UpdateOrderCheckoutOption[];
  }

  export namespace UpdateOrderCheckoutOptions {
    export interface UpdateOrderCheckoutOption {
      /**
       * Entity type: CheckoutOption
       */
      ID: number;
      ValueData?: { [key: string]: any };
    }

  }

  /**
   * Change the currency of an order given its OrderID and target CurrencyID.
   */
  export interface UpdateOrderCurrency {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
  }

  /**
   * Create or update existing custom field on order
   */
  export interface UpdateOrderCustomFields {
    /**
     * Entity type: Order
     */
    OrderID: number;
    CustomFields?: CustomFieldKeyValue[];
    CustomFieldsByBackendID?: CustomFieldByBackendValue[];
  }

  export interface CustomFieldByBackendValue {
    BackendID: string;
    /**
     * Used for datatype String, Text and Enum
     */
    StringValue?: string;
    /**
     * Used for datatype Blob
     */
    BlobValue?: string;
    /**
     * Used for datatype Integer and Decimal
     */
    NumberValue?: number;
    /**
     * Used for datatype Bool
     */
    BoolValue?: boolean;
    /**
     * Used for datatype DateTime and Date
     */
    DateTimeValue?: string;
    /**
     * Used for multiple values
     */
    ArrayValues?: CustomFieldValue[];
  }

  /**
   * Create or update existing custom field on order line level by ID
   */
  export interface UpdateOrderLineCustomFields {
    /**
     * Entity type: OrderLine
     */
    ID: number;
    CustomFields: CustomFieldKeyValue[];
  }

  /**
   * Update the StockLabel for a single `OrderLine` or for the complete `Order`. It is required to supply an `OrderID` or an `OrderLineID`.
   * If one of the lines cannot be updated, it will be skipped.
   * 
   * Only unshipped orderlines with LineActionType Ship can be updated.
   */
  export interface UpdateOrderLineStockLabel {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID: number;
  }

  /**
   * This services can be used to toggle some of the OrderOptions.
   * 
   * - IgnoreDiscounts: Discounts will not be added/removed/recalculated
   * - IgnoreShippingCosts: ShippingCosts will not be added/removed/recalculated
   * - IgnoreGiftWrappingCosts: GiftWrappingCosts will not be added/removed/recalculated
   * - AllowPartialFulfillment: The order will potentially be fulfilled in multiple batches
   */
  export interface UpdateOrderOptions {
    /**
     * Entity type: Order
     */
    OrderID: number;
    IgnoreDiscounts?: boolean;
    IgnoreShippingCosts?: boolean;
    IgnoreGiftWrappingCosts?: boolean;
    AllowPartialFulfillment?: boolean;
  }

  /**
   * Update various fields on an Order.
   */
  export interface UpdateOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    AutomaticCancellationDate?: string;
    /**
     * Entity type: CustomOrderType
     */
    CustomOrderTypeID?: number;
    /**
     * Entity type: OrderCustomType
     */
    OrderCustomTypeID?: number;
    /**
     * Entity type: OrderCustomStatus
     */
    OrderCustomStatusID?: number;
  }

  /**
   * Updates the order shipping status, creating ledger entries on order level.
   * 
   * Will be processed as a whole; a single failing line in `Lines` will prevent all other updates in a single call from persisting.
   */
  export interface UpdateOrderShippingStatus {
    Lines: UpdateOrderShippingStatusLine[];
  }

  export interface UpdateOrderShippingStatusLine {
    /**
     * Identifier of the EVA order this update is specific for
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Unique identifier for the order, in respect to the `BackendSystemID`
     */
    BackendOrderID?: string;
    /**
     * Owner of the `BackendOrderID`
     */
    BackendSystemID?: string;
    /**
     * Type of order shipping status update; 0 = Picked, 1 = Packed, 2 = CarrierStatus
     */
    Type: OrderShippingStatusType;
    /**
     * Identifier of the EVA order line this update is specific for
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * BackendID of the EVA order line this update is specific for
     */
    BackendOrderLineID?: string;
    /**
     * Date the event occurred - leave empty for 'now'.
     */
    Date?: string;
    /**
     * Optional, additional information, most commonly for the carrier status update code (B01, D01, ...) for CarrierStatus types
     */
    Value?: string;
    /**
     * Optional, additional description, most commonly for the carrier status update code description for CarrierStatus types
     */
    Description?: string;
  }

  export const enum OrderShippingStatusType {
    Picked = 0,
    Packed = 1,
    CarrierStatus = 2
  }

  /**
   * Validate if all conditions are met to schedule the (specified lines of) specified order.
   * 
   * _Will check the default ExportValidator and check OrderRequirements for all actions._
   */
  export interface ValidateExportSchedule {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineIDs?: number[];
  }

  export interface ValidateExportScheduleResponse {
    ValidationResult: OrderExportValidationResult;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Validates if a (part of an) Order can be shipped in the current state.
   * 
   * Returns if it is valid (`IsValid`) and if not, how much still needs to be paid (`OpenAmountForShipment`).
   */
  export interface ValidateOrderShipment {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Lines?: ValidateOrderShipment.ShipmentOrderLine[];
  }

  export namespace ValidateOrderShipment {
    export interface ShipmentOrderLine {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      QuantityShipped?: number;
    }

  }

  export interface ValidateOrderShipmentResponse {
    PaidAmount: number;
    OpenAmountForShipment: number;
    IsValid: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Validate the required data for the order
   */
  export interface ValidateRequiredDataForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    RequiredFor?: RequiredFor;
  }

  export interface ValidateRequiredDataForOrderResponse {
    ValidatedData: RequiredDataValidationResult;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface RequiredDataValidationResult {
    ValidationErrors: ValidationError[];
  }

  export interface ValidationError {
    Field: string;
    Message: string;
    Context: string;
  }

  /**
   * Verify the customer of an order by a QR code check. This process is used to validate that the person that picks up an order is really the person that ordered it.
   */
  export interface VerifyCustomer {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Retrieved from the `ParseBarcode` result `VerificationCode`
     */
    VerificationCode: string;
  }

  /**
   * Verify the customer of an order without QR code check.
   */
  export interface ForceVerifyCustomer {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetCustomerOrderVerificationCode {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetVerificationCodeResponse {
    VerificationCode: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface GetEmployeeOrderVerificationCode {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Verify an Order that has been flagged with a CustomOrderStatus `NeedsEmployeeVerification`. Will try to place the order after the verification.
   */
  export interface VerifyOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Get additional order information intended for warehouse data.
   */
  export interface GetWarehouseOrderData {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetWarehouseOrderDataResponse {
    WarehouseOrderData: WarehouseOrderData;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface WarehouseOrderData {
    AllowPartialPick: boolean;
  }

  /**
   * Set additional order information intended for warehouse data.
   */
  export interface SetWarehouseOrderData {
    /**
     * Entity type: Order
     */
    OrderID: number;
    WarehouseOrderData?: WarehouseOrderData;
  }

  /**
   * Gets the available reasons for tax exemption.
   * The `Code` property of each result can then be supplied to `ExemptOrderFromTax` as the `TaxExemptionCode`.
   */
  export interface GetTaxExemptionReasons {
    /**
     * If you have an OrderID available it can be specified to get a more accurate list of tax exemption reasons that is independent of your current OrganizationUnit.
     * For example if you have a US order but you are currently logged into a non-US organization, the result of this service won't be accurate unless you specify the OrderID.
     * Entity type: Order
     */
    OrderID?: number;
  }

  export interface GetTaxExemptionReasonsResponse {
    Reasons: GetTaxExemptionReasonsResponse.TaxExemptionReason[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetTaxExemptionReasonsResponse {
    export interface TaxExemptionReason {
      Code: string;
      Name: string;
      Description: string;
      RequiresVerification: boolean;
    }

  }

  /**
   * Get the signature for an Order
   */
  export interface GetOrderSignature {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Type: SignatureTypes;
  }

  export const enum SignatureTypes {
    Untyped = 0,
    Shipping = 1,
    Scripted = 2,
    AMLEmployee = 3,
    AMLCustomer = 4
  }

  /**
   * Add a signature to an Order.
   */
  export interface SignOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Type: SignatureTypes;
    Signature: string;
    MimeType: string;
  }

  /**
   * Convert the given `Order` to a ReturnToSupplierOrder. Existing none-product lines will be cancelled.
   */
  export interface CreateReturnToSupplierOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Create a new ReturnToSupplierRequest
   * 
   * A ReturnToSupplierRequest is used to generate ReturnToSupplier orders for Shops
   * 
   * - Name: For identification of the request (required)
   * - OrganizationUnitSetID: The organizationunits (filtered on Type = Shop) that will get a RTS (required)
   * - ProductSearchTemplateID: Only products matching this template will be added to the orders, if supplied (optional)
   * - RecallPercentage: Percentage of the current stock to recall. Value should be between 0.00 and 1.00. (required)
   * - Filters, CountryID, LanguageID: Instead of a productsearchtemplate, products can also be defined by providing a manual filter (all optional)
   */
  export interface CreateReturnToSupplierRequest {
    Name?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    /**
     * Range: 0.01-1
     */
    RecallPercentage?: number;
    Filters?: { [key: string]: FilterModel };
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * ReturnReason of type OrganizationUnit to indicate why these ReturnToSupplier orders are created
     * Entity type: ReturnReason
     */
    ReturnReasonID?: number;
    Remark?: string;
  }

  export interface CreateReturnToSupplierRequestResponse {
    /**
     * Entity type: ReturnToSupplierRequest
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Delete a ReturnToSupplierRequest
   * 
   * This is only allowed for Request in the state New or Error
   */
  export interface DeleteReturnToSupplierRequest {
    /**
     * Entity type: ReturnToSupplierRequest
     */
    ID: number;
  }

  /**
   * Get Return To Supplier Data
   */
  export interface GetReturnToSupplierData {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetReturnToSupplierDataResponse {
    Reason: EnumDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get a ReturnToSupplierRequest
   */
  export interface GetReturnToSupplierRequestByID {
    /**
     * Entity type: ReturnToSupplierRequest
     */
    ID: number;
  }

  export interface GetReturnToSupplierRequestByIDResponse {
    Name: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    OrganizationUnitSetName: string;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    ProductSearchTemplateName: string;
    RecallPercentage: number;
    Filters?: { [key: string]: FilterModel };
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    Status: ReturnToSupplierRequestStatus;
    /**
     * Entity type: ReturnReason
     */
    ReturnReasonID?: number;
    ReturnReasonName?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum ReturnToSupplierRequestStatus {
    New = 0,
    Processing = 1,
    Processed = 2,
    Error = 9
  }

  /**
   * List Returnable Suppliers For Order
   */
  export interface ListReturnableSuppliersForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface ListReturnableSuppliersForOrderResponse {
    Result: ListReturnableSuppliersForOrderResponse.Model[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListReturnableSuppliersForOrderResponse {
    export interface Model {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      BackendID: string;
      Name: string;
    }

  }

  /**
   * List ReturnToSupplierRequests
   * 
   * Available filters:
   * - Name
   * - Status
   * 
   * Results are limited to organization unit sets you have view rights for.
   */
  export interface ListReturnToSupplierRequests {
    PageConfig?: PageConfig<ListReturnToSupplierRequestsFilter>;
  }

  export interface ListReturnToSupplierRequestsFilter {
    Name?: string;
    /**
     * This will only match requests that have the exact specified organization unit set.
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Status?: ReturnToSupplierRequestStatus;
  }

  export interface ListReturnToSupplierRequestsResponse {
    Result?: PagedResult<ReturnToSupplierRequestModel>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ReturnToSupplierRequestModel {
    /**
     * Entity type: ReturnToSupplierRequest
     */
    ID: number;
    Name: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    OrganizationUnitSetName: string;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    ProductSearchTemplateName: string;
    RecallPercentage: number;
    Filters?: { [key: string]: FilterModel };
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    Status: ReturnToSupplierRequestStatus;
  }

  /**
   * Print the return to supplier order label.
   */
  export interface PrintReturnToSupplierOrderTicket {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Station
     */
    StationID: number;
  }

  /**
   * Print the return to supplier order receipt.
   */
  export interface PrintReturnToSupplierReceipt {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Station
     */
    StationID: number;
  }

  /**
   * Start the processing of a ReturnToSupplierRequest
   * 
   * This will put the request in a processing state and will generate the orders based on the set options.
   */
  export interface ProcessReturnToSupplierRequest {
    /**
     * Entity type: ReturnToSupplierRequest
     */
    ID: number;
  }

  /**
   * Set the suppliers for OrganizationUnit where this could not be automatically determined
   * 
   * To view the available suppliers, sue the ValidateReturnToSupplierRequest service.
   * 
   * The SupplierOrganizationUnitID is nullable, if it is set to `null`, the OrganizationUnit will be skipped when generating the orders.
   */
  export interface SetSuppliersForReturnToSupplierRequest {
    /**
     * Entity type: ReturnToSupplierRequest
     */
    ID: number;
    Suppliers: SupplierSet[];
  }

  export interface SupplierSet {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID?: number;
  }

  /**
   * Update the return to supplier order with Reason, ShipFrom- and ShipTo organization unit
   */
  export interface UpdateReturnToSupplierOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: ReturnReason
     */
    ReasonID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    ShipFromOrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    ShipToOrganizationUnitID?: number;
  }

  /**
   * Update a ReturnToSupplierRequest
   * 
   * This is only allowed for requests in the state New
   * 
   * Properties that are not provided in the request, will not be updated.
   */
  export interface UpdateReturnToSupplierRequest {
    /**
     * Entity type: ReturnToSupplierRequest
     */
    ID: number;
    Name?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    RecallPercentage?: number;
    Filters?: { [key: string]: FilterModel };
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * ReturnReason of type OrganizationUnit to indicate why these ReturnToSupplier orders are created
     * Entity type: ReturnReason
     */
    ReturnReasonID?: number;
    Remark?: string;
  }

  /**
   * Validate a ReturnToSupplierRequest
   * 
   * This will check if for all OrganizationUnits in the set a Supplier could be determined.
   * 
   * The service will return all available suppliers for each OrganizationUnit and will pick it when a single one is available.
   * When no Suppliers are available, no Order can be generated.
   * If more than one Supplier is available, the correct one should be picked with the SetSuppliersForReturnToSupplierRequest service.
   */
  export interface ValidateReturnToSupplierRequest {
    /**
     * Entity type: ReturnToSupplierRequest
     */
    ID: number;
  }

  export interface ValidateReturnToSupplierRequestResponse {
    OrganizationUnits: OrganizationUnitValidationModel[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface OrganizationUnitValidationModel {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    OrganizationUnitBackendID: string;
    PickedSupplier?: SupplierValidationModel;
    Skipped: boolean;
    AvailableSuppliers: SupplierValidationModel[];
  }

  export interface SupplierValidationModel {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    OrganizationUnitBackendID: string;
  }

  /**
   * Get all refund reasons available in the current context
   */
  export interface GetRefundCorrectionReasons {
  }

  export interface GetRefundCorrectionReasonsResponse {
    Reasons: GetRefundCorrectionReasonsResponse.RefundCorrectionReasonDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetRefundCorrectionReasonsResponse {
    export interface RefundCorrectionReasonDto {
      /**
       * Entity type: RefundCorrectionReason
       */
      ID?: number;
      Name?: string;
      Description?: string;
      BackendID?: string;
    }

  }

  /**
   * Automatically places, ships and receives an interbranch order between 2 organization units.
   */
  export interface AutoTransferInterbranchOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrganizationUnit
     */
    ShipFromOrganizationUnitID: number;
    /**
     * Entity type: OrganizationUnit
     */
    ShipToOrganizationUnitID: number;
  }

  /**
   * Convert the given `Order` to a InterbranchOrder.
   */
  export interface CreateInterbranchOrder {
    /**
     * The Order to convert to an interbranch order.
     * Entity type: Order
     */
    OrderID: number;
    /**
     * The destination OrganizationUnit of this Interbranch order. This will become the SoldToOrganizationUnit of the order.
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * The date when the shipment is expected in the other store
     */
    ExpectedDeliveryDate?: string;
  }

  /**
   * Print the InterbranchOrder receipt.
   */
  export interface PrintInterbranchOrderReceipt {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Station
     */
    StationID: number;
  }

  /**
   * Lists the OrganizationUnits that are available for the given OrderID to be used as the target for an interbranch order.
   */
  export interface ListInterbranchOrganizationUnitForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    ExcludeClosed?: boolean;
  }

  export interface ListInterbranchOrganizationUnitForOrderResponse {
    OrganizationUnits: InterbranchOrganizationUnit[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface InterbranchOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
    Name: string;
  }

  /**
   * Mutate Interbranch properties on the given `Order`.
   */
  export interface UpdateInterbranchOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * The date when the shipment is expected in the other store
     */
    ExpectedDeliveryDate?: string;
  }

  /**
   * Set the GiftWrapping options on an Order.
   * 
   * There are 4 options:
   * 
   *  - Wrap the complete order: set `WrapOrder` to `true`
   *  - Wrap the complete order individually: set `WrapIndividually` to `true`
   *  - Wrap parts of the order: set `GiftWraps` with a set of wraps
   *  - Wrap nothing: set everything to `null`
   * 
   * A `GiftWrap` consists out of an optional `Message` (could be printed on a card), an optional `GreetingCardProductID` and a set of `WrapLines`. A
   * `WrapLine` has an `OrderLineID` and a `Quantity`.
   * 
   * If a `GreetingCardProductID` and/or `Message` is desired when the order should be completely wrapped, or without any giftwrapping at all, set these
   * properties on root level. In all other cases they should be set on the `GiftWraps`.
   */
  export interface SetGiftWrappingOptionsOnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    WrapOrder?: boolean;
    WrapIndividually?: boolean;
    GiftWraps?: GiftWrapDto[];
    /**
     * Entity type: Product
     */
    GreetingCardProductID?: number;
    Message?: string;
  }

  /**
   * Get the GiftWrapping options for an Order.
   */
  export interface GetGiftWrappingOptionsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetGiftWrappingOptionsForOrderResponse {
    WrapOrder: boolean;
    WrapIndividually: boolean;
    GiftWraps: GiftWrapDto[];
    GreetingCardProductID?: number;
    Message: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get the available GiftWrapping options for an Order.
   */
  export interface GetAvailableGiftWrappingLinesForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetAvailableGiftWrappingLinesForOrderResponse {
    Lines: GiftWrappingLineAvailabilityDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * This service is used only for downloading invoices.
   */
  export interface DownloadInvoice {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
  }

  /**
   * This service is used only for downloading offers.
   */
  export interface DownloadOffer {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * This service is used only for printing paper invoices.
   */
  export interface DownloadOrderConfirmation {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface DownloadOrderConfirmationResponse {
    Url: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * This service is used only for emailing invoices.
   */
  export interface EmailInvoice {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
    EmailAddress?: string;
  }

  /**
   * This service is used for emailing all invoices linked to an order ID.
   */
  export interface EmailInvoices {
    /**
     * Entity type: Order
     */
    OrderID: number;
    EmailAddress?: string;
  }

  /**
   * This service is used only for emailing offers.
   */
  export interface EmailOffer {
    /**
     * Entity type: Order
     */
    OrderID: number;
    EmailAddress: string;
  }

  /**
   * This service is used only for printing paper invoices.
   */
  export interface EmailOrderConfirmation {
    /**
     * Entity type: Order
     */
    OrderID: number;
    EmailAddress?: string;
  }

  /**
   * This service is used to retrieve the TaxFreeForms associated with an order & send them to the specified email address.
   */
  export interface EmailOrderTaxFreeForm {
    /**
     * Entity type: Order
     */
    OrderID: number;
    EmailAddress?: string;
  }

  /**
   * This service is used only for emailing thermal invoices
   */
  export interface EmailThermalInvoice {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
    EmailAddress: string;
  }

  /**
   * This service is used only for emailing thermal invoices based on an order ID.
   */
  export interface EmailThermalInvoices {
    /**
     * Entity type: Order
     */
    OrderID: number;
    EmailAddress: string;
  }

  /**
   * Returns a list of available outputs for an order by taking an `OrderID`.
   */
  export interface GetAvailableDocumentsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetAvailableDocumentsForOrderResponse {
    /**
     * List of order document outputs available for a specific order.
     * Each document contains information regarding the following categories:
     * 
     * `Receipt`           - physically printing the order invoice
     * `Paper`             - printing the order invoice on a paper printer
     * `Email`             - sending the order invoice by email
     * `Digital`           - providing a downloadable version of the order invoice
     * `ElectronicReceipt` - providing an electronic receipt version of the order invoice
     * `Metadata`          - providing information about the order invoice.
     * 
     * The document category contains information on whether it's available for the order
     * and a reason code in case it's not available.
     */
    Documents: GetAvailableDocumentsForOrderResponse.OrderDocument[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetAvailableDocumentsForOrderResponse {
    export interface DocumentStation {
      /**
       * ID of the Station in EVA. Can be used directly in services
       * Entity type: Station
       */
      ID: number;
      /**
       * Name of the station for display purposes
       */
      Name: string;
    }

    export interface DocumentOutput {
      /**
       * Indicates if this output should be preferred by the frontend. Can be used to, for example, set a checkbox or radio button by default so the user does not have to toggle it themselves
       */
      Preferred?: boolean;
      /**
       * Allowed is false when this option cannot be used, true otherwise
       */
      Allowed?: boolean;
      /**
       * Optional reason code that is included if Allowed is set to false
       */
      ReasonCode?: string;
      /**
       * Possbile stations where the document can be output
       */
      Stations?: GetAvailableDocumentsForOrderResponse.DocumentStation[];
    }

    export interface OrderDocument {
      Type: string;
      Email: GetAvailableDocumentsForOrderResponse.DocumentOutput;
      Receipt: GetAvailableDocumentsForOrderResponse.DocumentOutput;
      Digital: GetAvailableDocumentsForOrderResponse.DocumentOutput;
      Paper: GetAvailableDocumentsForOrderResponse.DocumentOutput;
      ElectronicReceipt: GetAvailableDocumentsForOrderResponse.DocumentOutput;
      Metadata: { [key: string]: any };
    }

  }

  /**
   * This is service is used only for printing couopons.
   */
  export interface PrintCouponsForOrder {
    /**
     * Entity type: Station
     */
    StationID: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * This service is used only for printing paper invoices.
   */
  export interface PrintPaperInvoice {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
    /**
     * Entity type: Station
     */
    StationID: number;
  }

  /**
   * This is service is used for printing sales paper invoices for one order.
   */
  export interface PrintPaperInvoices {
    /**
     * Entity type: Station
     */
    StationID: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * This service is used only for printing offers.
   */
  export interface PrintPaperOffer {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Station
     */
    StationID?: number;
  }

  /**
   * This service is used only for printing paper invoices.
   */
  export interface PrintPaperOrderConfirmation {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Station
     */
    StationID: number;
  }

  /**
   * Print a *gift* receipt; a regular receipt, but without any price- or payment details. This document is intended to accompany the purchase when gifted, so the recipient can return or exchange it without (direct) knowledge of the price.
   *     The `Lines` property is optional, when omitted the entire order (from `OrderID`) will be printed. Also, `Name` and `Remark` are optional and intended for the gift recipient, only.
   */
  export interface PrintThermalGiftReceipt {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Station
     */
    StationID: number;
    Lines: PrintThermalGiftReceiptLine[];
    Name?: string;
    Remark?: string;
  }

  export interface PrintThermalGiftReceiptLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    Quantity: number;
  }

  /**
   * This is service is used only for printing thermal invoices.
   */
  export interface PrintThermalInvoice {
    /**
     * Entity type: Station
     */
    StationID: number;
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
  }

  /**
   * This is service is used for printing sales thermal invoices for one order.
   */
  export interface PrintThermalInvoices {
    /**
     * Entity type: Station
     */
    StationID: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Print Thermal Order Confirmation
   */
  export interface PrintThermalOrderConfirmation {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Station
     */
    StationID: number;
  }

  /**
   * Print an order summary as a thermal non-fiscal receipt.
   * It can be used when a payment is refunded or canceled during the sale process, the cashier needs to hand a proof to the customer with the current state of the order.
   */
  export interface PrintThermalOrderSummary {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Station
     */
    StationID: number;
  }

  /**
   * Produce Documents
   */
  export interface ProduceDocuments {
    PrintInvoice?: boolean;
    EmailInvoice?: boolean;
    PrintReceipt?: boolean;
    DownloadInvoice?: boolean;
    /**
     * Entity type: Station
     */
    StationID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    EmailAddress?: string;
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
  }

  export interface ProduceDocumentsResponse {
    InvoiceUrl?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Produce Invoice
   */
  export interface ProduceInvoice {
    /**
     * Entity type: Order
     */
    OrderID: number;
    EmailAddress?: string;
    /**
     * Entity type: Station
     */
    StationID?: number;
    EmailInvoice?: boolean;
    DownloadInvoice?: boolean;
    PrintInvoice?: boolean;
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
  }

  /**
   * Produce Purchase Order Document
   */
  export interface ProducePurchaseOrderDocument {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Produce Receipt
   */
  export interface ProduceReceipt {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Station
     */
    StationID?: number;
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
  }

  export interface ProduceReceiptResponse {
    PrintSuccessful: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Generate shipment document for an order or shipment.
   * 
   * It is required to supply an `OrderID` or a `ShipmentID`.
   * 
   * When using an `OrderID` it is also required to set the `LinesToShip`.
   * 
   * When a `StationID` is supplied the documents will be printed, if not, the service will return urls for downloading the documents.
   */
  export interface ProduceShipmentDocuments {
    /**
     * Required when omitting `ShipmentID`.
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Required when omitting `OrderID`.
     * Entity type: Shipment
     */
    ShipmentID?: number;
    /**
     * Required when passing an `OrderID`.
     */
    LinesToShip?: ProduceShipmentDocuments.OrderLineDto[];
    /**
     * Entity type: Station
     */
    StationID?: number;
  }

  export namespace ProduceShipmentDocuments {
    export interface OrderLineDto {
      /**
       * Entity type: OrderLine
       */
      ID: number;
      QuantityToShip: number;
    }

  }

  export interface ProduceShipmentDocumentsResponse {
    ShipmentDocuments: ProduceShipmentDocumentsResponse.Model[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ProduceShipmentDocumentsResponse {
    export interface Model {
      Type: string;
      ID: string;
      OriginalName: string;
      MimeType: string;
      Category: string;
      ExpireDate?: string;
      LocationType: string;
      Url: string;
    }

  }

  /**
   * Creates a custom order status which can be set on an order
   */
  export interface CreateCustomOrderStatus {
    Name: string;
    Description?: string;
  }

  export interface CreateCustomOrderStatusResponse {
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Deletes a custom order status
   */
  export interface DeleteCustomOrderStatus {
    /**
     * Entity type: CustomOrderStatus
     */
    ID: number;
  }

  /**
   * List Custom Order Status
   */
  export interface ListCustomOrderStatus {
  }

  export interface ListCustomOrderStatusResponse {
    Result: ListCustomOrderStatusResponse.CustomOrderStatus[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListCustomOrderStatusResponse {
    export interface CustomOrderStatus {
      ID: number;
      Name: string;
      Description: string;
    }

  }

  /**
   * Set order custom status
   */
  export interface UpdateOrderCustomOrderStatus {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderCustomStatus
     */
    StatusID: number;
  }

  export interface UpdateOrderCustomOrderStatusResponse {
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get all unitPrice correction reasons
   */
  export interface GetUnitPriceCorrectionReasons {
  }

  export interface GetUnitPriceCorrectionReasonsResponse {
    Reasons: GetUnitPriceCorrectionReasonsResponse.UnitPriceCorrectionReasonData[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetUnitPriceCorrectionReasonsResponse {
    export interface UnitPriceCorrectionReasonData {
      /**
       * Entity type: UnitPriceCorrectionReason
       */
      ID: number;
      BackendID?: string;
      Priority: number;
      OrganizationUnitSet: UnitPriceCorrectionReasonData.OrganizationUnitSetDto;
      Name: string;
      Description?: string;
    }

    export namespace UnitPriceCorrectionReasonData {
      export interface OrganizationUnitSetDto {
        /**
         * Entity type: OrganizationUnitSet
         */
        ID?: number;
        Name?: string;
      }

    }

  }

  /**
   * Cancels the OrderFulfillmentLines for the given OrderID and provided OrderLineIDs.
   * It will cancel all not already cancelled OrderFulfillmentLines for the orderlines.
   * This will cause them to be re-routed and possible be fulfilled through another supplier or method.
   */
  export interface CancelOrderLineFulfillments {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID?: number;
    Lines: CancelOrderLineFulfillments.Line[];
  }

  export namespace CancelOrderLineFulfillments {
    export interface Line {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      /**
       * The part of the OrderLine that couldn't be fulfilled. Can be left null if you want to cancel the entire fulfillment.
       * If a value is specified and splitting fulfillment lines is not enabled (so setting `OrderFulfillment:AllowPartialCancellation` is false or not defined) an error will be returned.
       * Min: 1
       */
      QuantityToCancel?: number;
    }

  }

  /**
   * Get Order Fulfillment Options
   */
  export interface GetOrderFulfillmentOptions {
    /**
     * The order to get the fulfillment options for.
     * Entity type: Order
     */
    OrderID: number;
    /**
     * The options the client supports for picking the fulfillment options.
     * This is for backwards compatibility purposes if a new option is added in the future so existing
     * options don't move to another set of options that the client can't handle yet.
     */
    SupportedOptions: GetOrderFulfillmentOptions.SupportedOptionFlags;
  }

  export namespace GetOrderFulfillmentOptions {
    export const enum SupportedOptionFlags {
      NormalDelivery = 0,
      PickupDropoff = 1
    }

  }

  export interface GetOrderFulfillmentOptionsResponse {
    AvailableFulfillmentOptions: GetOrderFulfillmentOptionsResponse.AvailableFulfillmentOptionsForOrder;
    BlockedFulfillmentOptions?: GetOrderFulfillmentOptionsResponse.BlockedFulfillmentOptionsForOrder;
    /**
     * @deprecated Not used anymore
     */
    FulfillmentOptions: GetOrderFulfillmentOptionsResponse.FulfillmentOption[];
    /**
     * @deprecated Not used anymore
     */
    PotentialFulfillmentOptions: GetOrderFulfillmentOptionsResponse.PotentialFulfillmentOption[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetOrderFulfillmentOptionsResponse {
    export interface AvailableFulfillmentOptionsForOrder {
      SameDayDelivery: AvailableFulfillmentOptionsForOrder.SameDayDeliveryShipping;
      NormalDelivery: AvailableFulfillmentOptionsForOrder.NormalDeliveryShipping;
      PickupDropoff: AvailableFulfillmentOptionsForOrder.PickupDropoffShipping;
    }

    export namespace AvailableFulfillmentOptionsForOrder {
      export interface CarrierMetadata {
        DisplayName: string;
        LogoUrl: string;
      }

      export interface LeadTime {
        Range?: LeadTime.LeadTimeRange;
        Custom?: string;
      }

      export namespace LeadTime {
        export interface LeadTimeRange {
          Type: LeadTime.LeadTimeType;
          From?: number;
          To?: number;
        }

        export const enum LeadTimeType {
          Days = 0,
          BusinessDays = 1
        }

      }

      export interface SameDayDeliveryShippingBase {
        Price: number;
        /**
         * Entity type: OrderLine
         */
        AvailableForOrderLineIDs: number[];
        CutoffTime?: string;
        EstimatedDeliveryTimeframeFrom?: string;
        EstimatedDeliveryTimeframeTo?: string;
      }

      export interface SameDayDeliveryShipping {
        IsAvailable: boolean;
        Options: AvailableFulfillmentOptionsForOrder.SameDayDeliveryShippingOption[];
        Carriers: AvailableFulfillmentOptionsForOrder.CarrierMetadata[];
        Price: number;
        /**
         * Entity type: OrderLine
         */
        AvailableForOrderLineIDs: number[];
        CutoffTime?: string;
        EstimatedDeliveryTimeframeFrom?: string;
        EstimatedDeliveryTimeframeTo?: string;
      }

      export interface SameDayDeliveryShippingOption {
        OptionID?: string;
        Name: string;
        Carriers: AvailableFulfillmentOptionsForOrder.CarrierMetadata[];
        Sequence: number;
        SubOptions: AvailableFulfillmentOptionsForOrder.SameDayDeliveryShippingSubOption[];
        Price: number;
        /**
         * Entity type: OrderLine
         */
        AvailableForOrderLineIDs: number[];
        CutoffTime?: string;
        EstimatedDeliveryTimeframeFrom?: string;
        EstimatedDeliveryTimeframeTo?: string;
      }

      export interface SameDayDeliveryShippingSubOption {
        OptionID: string;
        Name: string;
        CarrierMetadata?: AvailableFulfillmentOptionsForOrder.CarrierMetadata;
        Price: number;
        /**
         * Entity type: OrderLine
         */
        AvailableForOrderLineIDs: number[];
        CutoffTime?: string;
        EstimatedDeliveryTimeframeFrom?: string;
        EstimatedDeliveryTimeframeTo?: string;
      }

      export interface NormalDeliveryShippingBase {
        Price: number;
        LeadTime: AvailableFulfillmentOptionsForOrder.LeadTime[];
        /**
         * Entity type: OrderLine
         */
        AvailableForOrderLineIDs: number[];
      }

      export interface NormalDeliveryShipping {
        IsAvailable: boolean;
        Options: AvailableFulfillmentOptionsForOrder.NormalDeliveryShippingOption[];
        Carriers: AvailableFulfillmentOptionsForOrder.CarrierMetadata[];
        Price: number;
        LeadTime: AvailableFulfillmentOptionsForOrder.LeadTime[];
        /**
         * Entity type: OrderLine
         */
        AvailableForOrderLineIDs: number[];
      }

      export interface NormalDeliveryShippingOption {
        OptionID?: string;
        Name: string;
        Carriers: AvailableFulfillmentOptionsForOrder.CarrierMetadata[];
        Sequence: number;
        SubOptions: AvailableFulfillmentOptionsForOrder.NormalDeliveryShippingSubOption[];
        Price: number;
        LeadTime: AvailableFulfillmentOptionsForOrder.LeadTime[];
        /**
         * Entity type: OrderLine
         */
        AvailableForOrderLineIDs: number[];
      }

      export interface NormalDeliveryShippingSubOption {
        OptionID: string;
        Name: string;
        CarrierMetadata?: AvailableFulfillmentOptionsForOrder.CarrierMetadata;
        Price: number;
        LeadTime: AvailableFulfillmentOptionsForOrder.LeadTime[];
        /**
         * Entity type: OrderLine
         */
        AvailableForOrderLineIDs: number[];
      }

      export interface PickupDropoffShippingBase {
        Price: number;
        LeadTime: AvailableFulfillmentOptionsForOrder.LeadTime[];
        /**
         * Entity type: OrderLine
         */
        AvailableForOrderLineIDs: number[];
        Locations: AvailableFulfillmentOptionsForOrder.PickupDropoffLocation[];
      }

      export interface PickupDropoffShipping {
        IsAvailable: boolean;
        Options: AvailableFulfillmentOptionsForOrder.PickupDropoffShippingOption[];
        Carriers: AvailableFulfillmentOptionsForOrder.CarrierMetadata[];
        Price: number;
        LeadTime: AvailableFulfillmentOptionsForOrder.LeadTime[];
        /**
         * Entity type: OrderLine
         */
        AvailableForOrderLineIDs: number[];
        Locations: AvailableFulfillmentOptionsForOrder.PickupDropoffLocation[];
      }

      export interface PickupDropoffShippingOption {
        /**
         * Only set if this option has no suboptions
         */
        OptionID?: string;
        Name: string;
        Carriers: AvailableFulfillmentOptionsForOrder.CarrierMetadata[];
        Sequence: number;
        SubOptions: AvailableFulfillmentOptionsForOrder.PickupDropoffShippingSubOption[];
        Price: number;
        LeadTime: AvailableFulfillmentOptionsForOrder.LeadTime[];
        /**
         * Entity type: OrderLine
         */
        AvailableForOrderLineIDs: number[];
        Locations: AvailableFulfillmentOptionsForOrder.PickupDropoffLocation[];
      }

      export interface PickupDropoffShippingSubOption {
        OptionID: string;
        Name: string;
        CarrierMetadata?: AvailableFulfillmentOptionsForOrder.CarrierMetadata;
        Price: number;
        LeadTime: AvailableFulfillmentOptionsForOrder.LeadTime[];
        /**
         * Entity type: OrderLine
         */
        AvailableForOrderLineIDs: number[];
        Locations: AvailableFulfillmentOptionsForOrder.PickupDropoffLocation[];
      }

      export interface PickupDropoffLocation {
        ID: string;
        Name: string;
        Latitude: number;
        Longitude: number;
        CountryID: string;
        City: string;
        OpeningHours: AvailableFulfillmentOptionsForOrder.PickupDropoffLocationOpeningHours;
        ZipCode: string;
        AddressLines: string[];
        Distance: AvailableFulfillmentOptionsForOrder.PickupDropoffLocationDistance;
        CarrierMetadata?: AvailableFulfillmentOptionsForOrder.CarrierMetadata;
      }

      export interface PickupDropoffLocationDistance {
        CarDistanceInMeters?: number;
        CarDistanceInMinutes?: number;
        WalkingDistanceInMeters?: number;
        WalkingDistanceInMinutes?: number;
      }

      export interface PickupDropoffLocationOpeningHours {
        Monday: string[];
        Tuesday: string[];
        Wednesday: string[];
        Thursday: string[];
        Friday: string[];
        Saturday: string[];
        Sunday: string[];
      }

    }

    export interface BlockedFulfillmentOptionsForOrder {
      BlockingReason: PotentialFulfillmentOptionBlockingReasons;
      FulfillmentOptions: GetOrderFulfillmentOptionsResponse.AvailableFulfillmentOptionsForOrder;
      /**
       * Entity type: OrderLine
       */
      BlockingOrderLineIDs: number[];
    }

    export interface FulfillmentOption {
      SameDayDelivery: FulfillmentOption.SameDayDeliveryOption;
      ShippingCosts: number;
      /**
       * Entity type: OrderLine
       */
      ApplicableToOrderLineIDs: number[];
      ID: string;
    }

    export namespace FulfillmentOption {
      export interface SameDayDeliveryOption {
        IsAvailable: boolean;
        CutoffTime?: string;
        EstimatedDeliveryTimeframeFrom?: string;
        EstimatedDeliveryTimeframeTo?: string;
      }

    }

    export interface PotentialFulfillmentOption {
      BlockingReason: PotentialFulfillmentOptionBlockingReasons;
      PotentialFulfillmentOptions: GetOrderFulfillmentOptionsResponse.FulfillmentOption[];
      /**
       * Entity type: OrderLine
       */
      BlockingOrderLineIDs: number[];
    }

  }

  export const enum PotentialFulfillmentOptionBlockingReasons {
    NoPartialFulfillmentAllowed = 0
  }

  /**
   * Gets the details of an OrderFulfillment, except for its Lines which can be paged in through ListOrderFulfillmentLines with a filter on OrderFulfillmentID.
   */
  export interface GetOrderFulfillment {
    /**
     * Entity type: OrderFulfillment
     */
    ID: number;
    /**
     * Whether or not to include the details on how this OrderFulfillment came to be. This information is by default only stored for 14 days. Defaults to false.
     */
    IncludeOrchestrationDetails?: boolean;
  }

  export interface GetOrderFulfillmentResponse {
    /**
     * Entity type: OrderFulfillment
     */
    ID: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
    ReferenceNumber: string;
    SupplierOrganizationUnit: GetOrderFulfillmentResponse.OrderFulfillmentOrganizationUnit;
    FulfillmentMethod: string;
    Data: { [key: string]: any };
    Source: string;
    /**
     * Entity type: TransputJob
     */
    TransputJobID?: number;
    Statuses: OrderFulfillmentLineStatuses[];
    CreationTime: string;
    LastModificationTime?: string;
    OrderSoldFromOrganizationUnit: GetOrderFulfillmentResponse.OrderFulfillmentOrganizationUnit;
    TotalLineCount: number;
    OrchestrationDetails?: OrderFulfillmentOrchestrationData;
    ShippingOption?: GetOrderFulfillmentResponse.ShippingOptionInfo;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetOrderFulfillmentResponse {
    export interface OrderFulfillmentOrganizationUnit {
      ID: number;
      Name: string;
      Type: OrganizationUnitTypes;
      BackendID: string;
    }

    export interface ShippingOptionInfo {
      ExternalID?: string;
      NormalDelivery?: GetOrderFulfillmentResponse.NormalDeliveryInfo;
      SameDayDelivery?: GetOrderFulfillmentResponse.SameDayDeliveryInfo;
      PickupDelivery?: GetOrderFulfillmentResponse.PickupDeliveryInfo;
    }

    export interface NormalDeliveryInfo {
      OptionID?: string;
      OptionName?: string;
      SubOptionID?: string;
      SubOptionName?: string;
    }

    export interface SameDayDeliveryInfo {
      OptionID?: string;
      OptionName?: string;
      SubOptionID?: string;
      SubOptionName?: string;
    }

    export interface PickupDeliveryInfo {
      Location: GetOrderFulfillmentResponse.PickupLocationInfo;
      OptionID?: string;
      OptionName?: string;
      SubOptionID?: string;
      SubOptionName?: string;
    }

    export interface SharedInfo {
      OptionID?: string;
      OptionName?: string;
      SubOptionID?: string;
      SubOptionName?: string;
    }

    export interface PickupLocationInfo {
      ID: string;
      ExternalID?: string;
      Name: string;
      City: string;
      CountryID: string;
      ZipCode: string;
      AddressLines: string[];
    }

  }

  export const enum OrderFulfillmentLineStatuses {
    New = 0,
    Deactivated = 50,
    Cancelled = 100,
    WaitingForStock = 500,
    Pending = 600,
    InProgress = 900,
    Completed = 1000
  }

  export interface OrderFulfillmentOrchestrationData {
    Fulfillments?: OrderFulfillmentOrchestrationData.Fulfillment[];
    OrderLines?: OrderFulfillmentOrchestrationData.OrderLineResult[];
    Rejections?: OrderFulfillmentOrchestrationData.SupplierRejection[];
    ValidSuppliers?: OrderFulfillmentOrchestrationData.ValidSupplier[];
    Sheets?: OrderFulfillmentOrchestrationData.Sheet[];
  }

  export namespace OrderFulfillmentOrchestrationData {
    export interface Sheet {
      ID?: number;
      Name?: string;
    }

    export interface Supplier {
      ID?: number;
      Name?: string;
      BackendID?: string;
    }

    export interface OrderLine {
      ID?: number;
      Score?: number;
      Quantity?: number;
      ScoreExplanations?: OrderFulfillmentOrchestrationData.ScoreExplanation[];
    }

    export interface OrderLineResult {
      ID?: number;
      GroupID?: string;
      PotentialSuppliers?: OrderLineResult.PotentialSupplier[];
    }

    export namespace OrderLineResult {
      export interface PotentialSupplier {
        OrganizationUnitID?: number;
        Score?: number;
        Sheet?: string;
      }

    }

    export interface Shipment {
      Score?: number;
      ScoreExplanation?: OrderFulfillmentOrchestrationData.FulfillmentScoreExplanation;
      FulfillmentAction?: string;
      Data?: { [key: string]: any };
      Sheet?: OrderFulfillmentOrchestrationData.Sheet;
      Supplier?: OrderFulfillmentOrchestrationData.Supplier;
      OrderLines?: OrderFulfillmentOrchestrationData.OrderLine[];
    }

    export interface Fulfillment {
      Shipments?: OrderFulfillmentOrchestrationData.Shipment[];
      Score?: number;
      ScoreExplanation?: OrderFulfillmentOrchestrationData.FulfillmentScoreExplanation;
    }

    export interface FulfillmentScoreExplanation {
      Description?: string;
      ScoreExplanations?: OrderFulfillmentOrchestrationData.ScoreExplanation[];
    }

    export interface ScoreExplanation {
      Description?: string;
      Expression?: string;
      PreviousScore?: number;
      NewScore?: number;
      DeltaScore?: number;
      Variables?: { [key: string]: any };
    }

    export interface RejectionReason {
      Description?: string;
      Reason?: string;
      ProductIDs?: number[];
      OrderLineIDs?: number[];
    }

    export interface FulfillmentMethod {
      Name?: string;
      Reasons?: OrderFulfillmentOrchestrationData.RejectionReason[];
    }

    export interface ValidSupplier {
      Score?: number;
      FulfillmentMethod?: string;
      SupplierID?: number;
      SupplierName?: string;
      ScoreExplanations?: OrderFulfillmentOrchestrationData.ScoreExplanation[];
      FulfillableOrderLineIDs?: number[];
    }

    export interface SupplierRejection {
      SupplierOrganizationUnitID?: number;
      SupplierOrganizationUnitName?: string;
      FulfillmentMethods?: OrderFulfillmentOrchestrationData.FulfillmentMethod[];
    }

  }

  /**
   * Get Order Fulfillment Supplier Performance
   */
  export interface GetOrderFulfillmentSupplierPerformance {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetOrderFulfillmentSupplierPerformanceResponse {
    CancellationRate: number;
    AverageCompletionTime: string;
    FromDate: string;
    ToDate: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Lists the OrderFulfillmentLines for a given OrderID or OrderFulfillmentID.
   */
  export interface ListOrderFulfillmentLines {
    /**
     * Either provide OrderID or OrderFulfillmentID
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Either provide OrderID or OrderFulfillmentID
     * Entity type: OrderFulfillment
     */
    OrderFulfillmentID?: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProductProperties?: string[];
    InitialPageConfig?: PageTokenConfig<ListOrderFulfillmentLinesFilter>;
    PageToken?: string;
  }

  export interface ListOrderFulfillmentLinesFilter {
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * @deprecated Use `Statuses` instead.
     */
    Status?: OrderFulfillmentLineStatuses;
    Statuses?: OrderFulfillmentLineStatuses[];
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID?: number;
  }

  export interface ListOrderFulfillmentLinesResponse {
    Results?: ListOrderFulfillmentLineItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListOrderFulfillmentLineItem {
    /**
     * Entity type: OrderFulfillmentLine
     */
    ID: number;
    /**
     * Entity type: OrderFulfillment
     */
    OrderFulfillmentID: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
    OrderDisplayID?: string;
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    Product?: ListOrderFulfillmentLineItem.OrderLineProduct;
    SupplierOrganizationUnit: OrderFulfillmentLineOrganizationUnit;
    FulfillmentMethod: string;
    Data: { [key: string]: any };
    Status: OrderFulfillmentLineStatuses;
    Source: string;
    /**
     * Entity type: TransputJob
     */
    TransputJobID?: number;
    CreationTime: string;
    LastModificationTime?: string;
    FinancialOrderFulfillmentLines: ListOrderFulfillmentLineItem.FinancialOrderFulfillmentLine[];
    UnitPrice: number;
    Quantity: number;
    CurrencyID?: string;
    EarliestPossibleStartTime?: string;
    StartTime?: string;
    CompletionTime?: string;
  }

  export namespace ListOrderFulfillmentLineItem {
    export interface OrderLineProduct {
      /**
       * Entity type: Product
       */
      ID?: number;
      BackendID?: string;
      CustomID?: string;
      Description?: string;
      Details?: any;
    }

    export interface FinancialOrderFulfillmentLine {
      ID: number;
      SourceOrganizationUnit: OrderFulfillmentLineOrganizationUnit;
      DestinationOrganizationUnit: OrderFulfillmentLineOrganizationUnit;
      CurrencyID?: string;
      SequenceID?: number;
      UnitPrice?: number;
      Status: OrderFulfillmentLineStatuses;
    }

  }

  export interface OrderFulfillmentLineOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    ID: number;
    Name: string;
    Type: OrganizationUnitTypes;
    BackendID: string;
  }

  /**
   * List fulfillment rejections for one order.
   * Filter on: OrderID, SupplierOrganizationUnitID, OrderLineID, Reason, FulfillmentMethod
   */
  export interface ListOrderFulfillmentRejections {
    InitialPageConfig?: PageTokenConfig<ListOrderFulfillmentRejectionsFilter>;
    PageToken?: string;
  }

  export interface ListOrderFulfillmentRejectionsFilter {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID?: number;
    Reason: string;
    FulfillmentMethod: string;
  }

  export interface ListOrderFulfillmentRejectionsResponse {
    Results?: ListOrderFulfillmentRejectionsItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListOrderFulfillmentRejectionsItem {
    /**
     * Entity type: OrderFulfillmentRejectionLedger
     */
    ID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    SupplierOrganizationUnit?: OrderFulfillmentLineOrganizationUnit;
    FulfillmentMethod?: string;
    Reason?: string;
    Description?: string;
    CreationTime?: string;
    ShippingAddress?: AddressDto;
  }

  /**
   * Lists OrderFulfillments, optionally filtered. Results are limited to organization units you have view rights for.
   */
  export interface ListOrderFulfillments {
    InitialPageConfig?: PageTokenConfig<ListOrderFulfillmentsFilter>;
    PageToken?: string;
  }

  export interface ListOrderFulfillmentsFilter {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID?: number;
    OrderFulfillmentReferenceNumber?: string;
    /**
     * Entity type: OrganizationUnit
     */
    SoldFromOrganizationUnitID?: number;
    Statuses?: OrderFulfillmentLineStatuses[];
  }

  export interface ListOrderFulfillmentsResponse {
    Results?: ListOrderFulfillmentItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListOrderFulfillmentItem {
    /**
     * Entity type: OrderFulfillment
     */
    ID: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
    OrderType: OrderTypes;
    OrderDisplayID?: string;
    ReferenceNumber: string;
    SupplierOrganizationUnit: OrderFulfillmentLineOrganizationUnit;
    FulfillmentMethod: string;
    Data: { [key: string]: any };
    Source: string;
    /**
     * Entity type: TransputJob
     */
    TransputJobID?: number;
    Statuses: OrderFulfillmentLineStatuses[];
    CreationTime: string;
    LastModificationTime?: string;
    OrderSoldFromOrganizationUnit: OrderFulfillmentLineOrganizationUnit;
  }

  /**
   * Set Order Fulfillment Options
   */
  export interface SetOrderFulfillmentOptions {
    /**
     * Entity type: Order
     */
    OrderID: number;
    FulfillmentOptionsSelection?: SetOrderFulfillmentOptions.FulfillmentOptionsSelectionForOrder;
    /**
     * @deprecated Not used anymore
     */
    SelectedFulfillmentOptions: SetOrderFulfillmentOptions.SelectedFulfillmentOption[];
  }

  export namespace SetOrderFulfillmentOptions {
    export interface FulfillmentOptionsSelectionForOrder {
      NormalDelivery: FulfillmentOptionsSelectionForOrder.NormalDeliverySelection;
      SameDayDelivery: FulfillmentOptionsSelectionForOrder.SameDayDeliverySelection;
      PickupDropoff: FulfillmentOptionsSelectionForOrder.PickupDropoffSelection;
    }

    export namespace FulfillmentOptionsSelectionForOrder {
      export interface NormalDeliverySelection {
        /**
         * Entity type: OrderLine
         */
        OrderLineIDs?: number[];
        OptionID?: string;
        SubOptionID?: string;
      }

      export interface SameDayDeliverySelection {
        /**
         * Entity type: OrderLine
         */
        OrderLineIDs?: number[];
        OptionID?: string;
        SubOptionID?: string;
      }

      export interface PickupDropoffSelection {
        /**
         * Entity type: OrderLine
         */
        OrderLineIDs: number[];
        OptionID?: string;
        SubOptionID?: string;
        LocationID: string;
      }

    }

    export interface SelectedFulfillmentOption {
      ID?: string;
      /**
       * Entity type: OrderLine
       */
      OrderLineIDs: number[];
    }

  }

  /**
   * Ships an OrderFulfillment, thereby creating one or more Shipments for the underlying Order.
   */
  export interface ShipOrderFulfillment {
    /**
     * Entity type: OrderFulfillment
     */
    OrderFulfillmentID: number;
    Lines?: ShipOrderFulfillment.ShipmentOrderFulfillmentLine[];
    FinalShipment?: boolean;
  }

  export namespace ShipOrderFulfillment {
    export interface ShipmentOrderFulfillmentLine {
      /**
       * Entity type: OrderFulfillmentLine
       */
      OrderFulfillmentLineID?: number;
      QuantityShipped?: number;
      ShipmentBackendID?: string;
      TrackingCode?: string;
      TrackingLink?: string;
      /**
       * Entity type: Product
       */
      StockProductID?: number;
    }

  }

  export interface ShipOrderFulfillmentResponse {
    Shipments: ShipOrderFulfillmentResponse.Shipment[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ShipOrderFulfillmentResponse {
    export interface Shipment {
      /**
       * Entity type: Shipment
       */
      ID?: number;
      TrackingCode?: string;
      TrackingLink?: string;
    }

  }

  /**
   * Updates the price and/or quantity of a fulfillment line based on its ID.
   * 
   * When modifying the quantity, it's not possible currently to increase the quantity, only to decrease it. The modification must also happen on the physical fulfillment line,
   * that is a fulfillment line with Type = Physical.
   */
  export interface UpdateOrderFulfillmentLine {
    /**
     * Entity type: OrderFulfillmentLine
     */
    ID: number;
    Quantity?: number;
    UnitPrice?: number;
  }

  /**
   * Download a sample Excel file which can be filled with special opening hours. The populated Excel file can be uploaded through the `ImportSpecialOpeningHours` service.
   */
  export interface DownloadSpecialOpeningHoursExcelTemplate {
  }

  /**
   * Upload a filled Excel file with special opening hours for an opening hour template. The template Excel file should be downloaded from the `DownloadSpecialOpeningHoursSample` service.
   */
  export interface UploadSpecialOpeningHoursExcel {
    /**
     * Entity type: OpeningHoursTemplate
     */
    OpeningHoursTemplateID: number;
    Data: string;
  }

  /**
   * Validate an OpeningHoursTemplate
   */
  export interface ValidateOpeningHoursTemplate {
    /**
     * Entity type: OpeningHoursType
     */
    OpeningHoursTypeID: number;
    Sunday?: OpeningHoursTemplateDay;
    Monday?: OpeningHoursTemplateDay;
    Tuesday?: OpeningHoursTemplateDay;
    Wednesday?: OpeningHoursTemplateDay;
    Thursday?: OpeningHoursTemplateDay;
    Friday?: OpeningHoursTemplateDay;
    Saturday?: OpeningHoursTemplateDay;
  }

  export interface OpeningHoursTemplateDay {
    IsClosed: boolean;
    Description?: string;
    DayOpeningTimes?: OpeningHoursTemplateTimeSlot[];
  }

  export interface OpeningHoursTemplateTimeSlot {
    StartTime: string;
    EndTime: string;
  }

  export interface ValidateOpeningHoursTemplateResponse {
    Successful: boolean;
    ValidationErrors: Error[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface Error {
    Type: string;
    Message: string;
    Prefix: string;
    MessageArguments: any[];
    Data: any;
    Identifier: string;
  }

  /**
   * Create a new OpeningHoursTemplate
   */
  export interface CreateOpeningHoursTemplate {
    /**
     * Entity type: OpeningHoursType
     */
    OpeningHoursTypeID: number;
    Description: string;
    Sunday?: OpeningHoursTemplateDay;
    Monday?: OpeningHoursTemplateDay;
    Tuesday?: OpeningHoursTemplateDay;
    Wednesday?: OpeningHoursTemplateDay;
    Thursday?: OpeningHoursTemplateDay;
    Friday?: OpeningHoursTemplateDay;
    Saturday?: OpeningHoursTemplateDay;
  }

  export interface CreateOpeningHoursTemplateResponse {
    /**
     * Entity type: OpeningHoursTemplate
     */
    OpeningHoursTemplateID: number;
    Successful: boolean;
    ValidationErrors: Error[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update an existing OpeningHoursTemplate
   */
  export interface UpdateOpeningHoursTemplate {
    /**
     * Entity type: OpeningHoursTemplate
     */
    OpeningHoursTemplateID: number;
    Description: string;
    Sunday?: OpeningHoursTemplateDay;
    Monday?: OpeningHoursTemplateDay;
    Tuesday?: OpeningHoursTemplateDay;
    Wednesday?: OpeningHoursTemplateDay;
    Thursday?: OpeningHoursTemplateDay;
    Friday?: OpeningHoursTemplateDay;
    Saturday?: OpeningHoursTemplateDay;
  }

  /**
   * Delete an OpeningHoursTemplate
   */
  export interface DeleteOpeningHoursTemplate {
    /**
     * Entity type: OpeningHoursTemplate
     */
    OpeningHoursTemplateID: number;
  }

  /**
   * Add or update a special date on an OpeningHoursTemplate
   */
  export interface SetSpecialDateOnOpeningHoursTemplate {
    /**
     * Entity type: OpeningHoursTemplate
     */
    OpeningHoursTemplateID: number;
    Date: string;
    Description: string;
    StoreDescriptionAsTranslationKey?: boolean;
    IsClosed: boolean;
    DayOpeningTimes?: OpeningHoursTemplateTimeSlot[];
  }

  /**
   * Remove a special date from an OpeningHoursTemplate
   */
  export interface RemoveSpecialDateFromOpeningHoursTemplate {
    /**
     * Entity type: OpeningHoursTemplate
     */
    OpeningHoursTemplateID: number;
    Date: string;
  }

  /**
   * List OpeningHoursTemplates
   */
  export interface ListOpeningHoursTemplates {
    PageConfig?: PageConfig<ListOpeningHoursTemplatesFilter>;
  }

  export interface ListOpeningHoursTemplatesFilter {
    /**
     * Entity type: OpeningHoursType
     */
    OpeningHoursTypeID?: number;
    Description?: string;
  }

  export interface ListOpeningHoursTemplatesResponse {
    Result?: PagedResult<ListOpeningHoursTemplatesResponse.Data>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListOpeningHoursTemplatesResponse {
    export interface Data {
      /**
       * Entity type: OpeningHoursTemplate
       */
      OpeningHoursTemplateID?: number;
      /**
       * Entity type: OpeningHoursType
       */
      OpeningHoursTypeID: number;
      Description: string;
      IsImported: boolean;
    }

  }

  /**
   * List all the attached OrganizationUnitSets for OpeningHoursTemplates
   */
  export interface ListOpeningHoursTemplatesOrganizationUnitSets {
    PageConfig?: PageConfig<ListOpeningHoursTemplatesOrganizationUnitSetsFilter>;
  }

  export interface ListOpeningHoursTemplatesOrganizationUnitSetsFilter {
    /**
     * Entity type: OpeningHoursTemplate
     */
    OpeningHoursTemplateID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: OpeningHoursType
     */
    OpeningHoursTypeID?: number;
  }

  export interface ListOpeningHoursTemplatesOrganizationUnitSetsResponse {
    Result?: PagedResult<ListOpeningHoursTemplatesOrganizationUnitSetsResponse.Data>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListOpeningHoursTemplatesOrganizationUnitSetsResponse {
    export interface Data {
      /**
       * Entity type: OpeningHoursTemplate
       */
      OpeningHoursTemplateID?: number;
      /**
       * Entity type: OpeningHoursType
       */
      OpeningHoursTypeID: number;
      Description: string;
      OrganizationUnitSets: ListOpeningHoursTemplatesOrganizationUnitSetsResponse.OrganizationUnitSetData[];
      IsImported: boolean;
    }

    export interface OrganizationUnitSetData {
      /**
       * Entity type: OrganizationUnitSet
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Get OpeningHoursTemplate by ID
   */
  export interface GetOpeningHoursTemplateByID {
    /**
     * Entity type: OpeningHoursTemplate
     */
    OpeningHoursTemplateID: number;
  }

  export interface GetOpeningHoursTemplateResponseByID {
    /**
     * Entity type: OpeningHoursTemplate
     */
    OpeningHoursTemplateID?: number;
    /**
     * Entity type: OpeningHoursType
     */
    OpeningHoursTypeID: number;
    Description: string;
    Sunday: OpeningHoursTemplateDay;
    Monday: OpeningHoursTemplateDay;
    Tuesday: OpeningHoursTemplateDay;
    Wednesday: OpeningHoursTemplateDay;
    Thursday: OpeningHoursTemplateDay;
    Friday: OpeningHoursTemplateDay;
    Saturday: OpeningHoursTemplateDay;
    SpecialDays: GetOpeningHoursTemplateResponseByID.SpecialDay[];
    IsImported: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetOpeningHoursTemplateResponseByID {
    export interface SpecialDay {
      Date: string;
      OpeningHours: OpeningHoursTemplateDay;
    }

  }

  /**
   * Attaches an OpeningHoursTemplate to the given OrganizationUnitSets.
   * When `OverrideIfOpeningHoursTypeAlreadyAttached` is set to true, the service detaches the template of the same type before attaching the new template.
   * When `OverrideIfOpeningHoursTypeAlreadyAttached` is set to false, the service will fail if one of the given OrganizationUnitSets is already attached to a OpeningHoursTemplate of the same Type.
   */
  export interface AttachOpeningHoursTemplateToOrganizationUnitSets {
    /**
     * Entity type: OpeningHoursTemplate
     */
    OpeningHoursTemplateID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetIDs: number[];
    OverrideIfOpeningHoursTypeAlreadyAttached?: boolean;
  }

  /**
   * Attaches an OpeningHoursTemplate to the given OrganizationUnitSets.
   */
  export interface DetachOpeningHoursTemplateToOrganizationUnitSets {
    /**
     * Entity type: OpeningHoursTemplate
     */
    OpeningHoursTemplateID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetIDs?: number[];
  }

  /**
   * Get flattened organization unit opening hours
   */
  export interface GetOrganizationUnitOpeningHours {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetOrganizationUnitOpeningHoursResponse {
    OpeningHours: GetOrganizationUnitOpeningHoursResponse.Data[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetOrganizationUnitOpeningHoursResponse {
    export interface Data {
      /**
       * Entity type: OpeningHoursType
       */
      OpeningHoursTypeID: number;
      Sunday: OpeningHoursTemplateDay;
      Monday: OpeningHoursTemplateDay;
      Tuesday: OpeningHoursTemplateDay;
      Wednesday: OpeningHoursTemplateDay;
      Thursday: OpeningHoursTemplateDay;
      Friday: OpeningHoursTemplateDay;
      Saturday: OpeningHoursTemplateDay;
      SpecialDays: Data.SpecialDay[];
    }

    export namespace Data {
      export interface SpecialDay {
        Date: string;
        OpeningHours: OpeningHoursTemplateDay;
      }

    }

  }

  /**
   * Get detailed organization unit opening hours
   */
  export interface GetDetailedOrganizationUnitOpeningHours {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetDetailedOrganizationUnitOpeningHoursResponse {
    OpeningHours: GetDetailedOrganizationUnitOpeningHoursResponse.Data[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetDetailedOrganizationUnitOpeningHoursResponse {
    export interface Data {
      /**
       * Entity type: OpeningHoursType
       */
      OpeningHoursTypeID: number;
      Sunday: Data.RegularDay;
      Monday: Data.RegularDay;
      Tuesday: Data.RegularDay;
      Wednesday: Data.RegularDay;
      Thursday: Data.RegularDay;
      Friday: Data.RegularDay;
      Saturday: Data.RegularDay;
      SpecialDays: Data.SpecialDay[];
    }

    export namespace Data {
      export interface RegularDay {
        IsFromTemplate: boolean;
        ElectedTemplateID?: number;
        ExceptionData: OpeningHoursTemplateDay;
        TemplateData: OpeningHoursTemplateDay;
      }

      export interface SpecialDay {
        Date: string;
        IsFromTemplate: boolean;
        ElectedTemplateID?: number;
        ExceptionData: OpeningHoursTemplateDay;
        TemplateData: OpeningHoursTemplateDay;
      }

    }

  }

  /**
   * Gets the organization unit visiting opening hours for the given period.
   */
  export interface GetOrganizationUnitOpeningHoursForPeriod {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    From: string;
    To: string;
  }

  export interface GetOrganizationUnitOpeningHoursForPeriodResponse {
    OpeningHours: { [key: number]: GetOrganizationUnitOpeningHoursForPeriodResponse.OrganizationUnitOpeningHours };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetOrganizationUnitOpeningHoursForPeriodResponse {
    export interface OrganizationUnitOpeningHours {
      DayOfWeek: DayOfWeek;
      SpecialReason: string;
      StartTime?: string;
      EndTime?: string;
    }

  }

  /**
   * Add or update an Organization's openinghours exception
   */
  export interface SetOrganizationUnitOpeningHoursException {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: OpeningHoursType
     */
    OpeningHoursTypeID: number;
    DayOfWeek?: DayOfWeek;
    Date?: string;
    OpeningHours: OpeningHoursTemplateDay;
  }

  /**
   * Remove an Organization's openinghours exception. When neither a DayOfWeek or Date is given, all openinghours exception for the given type will be removed and all openinghours will revert to the template value (if present).
   */
  export interface RemoveOrganizationUnitOpeningHoursException {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: OpeningHoursType
     */
    OpeningHoursTypeID: number;
    DayOfWeek?: DayOfWeek;
    Date?: string;
  }

  /**
   * Get a list of all OpeningHoursTemplates translation keys for description translation.
   */
  export interface GetOpeningHoursTemplatesTranslationKeys {
  }

  export interface GetOpeningHoursTemplatesTranslationKeysResponse {
    EntityPropertyTranslations: GetOpeningHoursTemplatesTranslationKeysResponse.EntityPropertyTranslation[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetOpeningHoursTemplatesTranslationKeysResponse {
    export interface EntityPropertyTranslation {
      TranslationKey: string;
      CurrentTranslation: string;
    }

  }

  /**
   * Lists the errors from the message queue.
   */
  export interface ListMessageQueueErrors {
    PageConfig?: PageConfig<ListMessageQueueErrorsFilter>;
  }

  export interface ListMessageQueueErrorsFilter {
    Status?: MessageQueueErrorStatuses;
    StartDate?: string;
    EndDate?: string;
    MessageTypeName: string;
    MessageID?: string;
    ExceptionMessage: string;
    ErrorCode: string;
  }

  export const enum MessageQueueErrorStatuses {
    New = 0,
    Republished = 1,
    SuccessAfterRetry = 2,
    FailureAfterRetry = 3,
    Ignored = 4
  }

  export interface ListMessageQueueErrorsResponse {
    Result?: PagedResult<MessageQueueErrorDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface MessageQueueErrorDto {
    ID: number;
    Status: MessageQueueErrorStatuses;
    MessageID?: string;
    MessageBody: string;
    MessageTypeName: string;
    ExceptionMessage: string;
    StackTrace: string;
    ErrorCode: string;
    HostInfo: string;
    Headers: string;
    Addresses: string;
    CreationTime: string;
    RetryCount: number;
    NextRetry?: string;
  }

  /**
   * Requeues specified error message(s).
   */
  export interface RequeueErrorMessage {
    /**
     * Entity type: MessageQueueError
     */
    MessageQueueErrorID?: number;
    /**
     * Entity type: MessageQueueError
     */
    MessageQueueErrorIDs?: number[];
  }

  /**
   * Books the given invoice by its `ID`.
   * 
   * Booking an invoice has the side effect of creating a payment on the order for the amount of the invoice.
   */
  export interface BookInvoice {
    /**
     * Entity type: Invoice
     */
    ID: number;
  }

  /**
   * Creates lines on the given invoice (`InvoiceID`).
   * 
   * It is required to supply an OrderLine or a ShipmentLine. All other properties are optional and will be copied from the shipment-/order- line.
   */
  export interface CreateInvoiceLines {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
    Lines?: CreateInvoiceLine[];
  }

  export interface CreateInvoiceLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Entity type: ShipmentLine
     */
    ShipmentLineID?: number;
    Quantity?: number;
    ExpectedQuantity?: number;
    UnitPrice?: number;
    /**
     * Range: 1-2
     */
    TaxRate?: number;
  }

  /**
   * Creates a new invoice for the given `OrganizationUnitID` (the one who writes the invoice)
   * and the `SupplierOrganizationUnitID` (the one who receives good/services).
   * 
   * - `InvoiceDate` is the date on which the invoice was created.
   * - `InvoiceNumber` is the unique number for the invoice.
   * - `Blobs` can contain PDF's or other media that can for example be a copy of the invoice
   * - `OriginalTotalAmount` is the amount that is expected on the invoice. E.g. this can differ from the amount that is computed based on the invoice lines
   * - `Type` indicates if this is an invoice for a sales or purchase orders
   */
  export interface CreateInvoice {
    /**
     * Entity type: OrganizationUnit
     */
    CreditorOrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    DebtorOrganizationUnitID?: number;
    PaymentTermStartDate?: string;
    PaymentTermDueDate?: string;
    InvoiceDate: string;
    InvoiceNumber?: string;
    Description?: string;
    Blobs?: InvoiceBlobDto[];
    OriginalTotalAmount?: number;
    Type: InvoiceTypes;
    /**
     * Entity type: InvoiceHoldStatus
     */
    HoldStatusID?: number;
    FiscalID?: string;
    TaxReverseCharge?: boolean;
    CalculationMethod?: InvoiceCalculationMethod;
  }

  export interface InvoiceBlobDto {
    BlobID: string;
  }

  export interface InvoiceAdditionalAmountDto {
    /**
     * Entity type: InvoiceAdditionalAmount
     */
    ID: number;
    Type: number;
    OriginalAmount: number;
    Amount: number;
    OriginalAmountInTax: number;
    AmountInTax: number;
    TaxRate: number;
    TaxCodeID: number;
    Disputes: InvoiceDisputeDto[];
  }

  export interface InvoiceDisputeDto {
    /**
     * Entity type: InvoiceDispute
     */
    ID: number;
    /**
     * Entity type: InvoiceDisputeReason
     */
    ReasonID: number;
    ReasonName: string;
    Amount: number;
    Description?: string;
    Type: InvoiceDisputeTypes;
    IsResolved: boolean;
    ResolvedAmount: number;
    ResolveActions: InvoiceDisputeResolveActionDto[];
    EmailAddressToSendNotificationTo?: string;
  }

  export const enum InvoiceDisputeTypes {
    Original = 0,
    Expected = 1
  }

  export interface InvoiceDisputeResolveActionDto {
    /**
     * Entity type: InvoiceDisputeResolveAction
     */
    ID: number;
    Amount: number;
    Description?: string;
    LedgerClassID?: string;
  }

  export interface CreateInvoiceResponse {
    /**
     * Entity type: Invoice
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Create invoices for an Order. Optionally specify the specific lines with quantities.
   */
  export interface CreateInvoicesForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    LinesToInvoice?: CreateInvoicesForOrder.OrderLineToInvoice[];
  }

  export namespace CreateInvoicesForOrder {
    export interface OrderLineToInvoice {
      /**
       * Entity type: OrderLine
       */
      ID: number;
      Quantity: number;
    }

  }

  export interface CreateInvoicesForOrderResponse {
    Invoices: CreateInvoicesForOrderResponse.Invoice[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace CreateInvoicesForOrderResponse {
    export interface Invoice {
      ID: number;
      InvoiceNumber: string;
      TypeID: number;
      StatusID: number;
    }

  }

  /**
   * Creates an order with a manually issued invoice. This will insert a committed Invoice with a custom sequencing number and additional
   * `InvoiceManualData`. It will be fully paid with a custom payment type.
   * 
   * The specified Order will be paid, placed, shipped and completed, but without any additional side effects like stock ledgers or commitments.
   */
  export interface CreateManualInvoice {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    Series: string;
    Number: string;
    InvoiceDate: string;
    Customer: ManualCustomer;
    Lines: ManualLine[];
  }

  export interface ManualCustomer {
    FirstName: string;
    LastName: string;
    FiscalID: string;
    CountryID: string;
    ZipCode: string;
    Address1: string;
    City: string;
  }

  export interface ManualLine {
    /**
     * Entity type: Product
     */
    ProductID?: number;
    Description: string;
    /**
     * Entity type: TaxRateInfo
     */
    TaxRateInfoID: number;
    Quantity: number;
    TotalAmountInTax: number;
  }

  export interface CreateManualInvoiceResponse {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Deletes the given invoice. Note, can only delete invoices that have not been booked yet.
   */
  export interface DeleteInvoice {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
  }

  /**
   * Returns all the details of an invoice by its ID.
   */
  export interface GetInvoice {
    /**
     * Entity type: Invoice
     */
    ID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProductProperties?: string[];
  }

  export interface GetInvoiceResponse {
    Invoice: InvoiceDetailsDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface InvoiceDetailsDto {
    CreditorOrganizationUnitName: string;
    CreditorOrganizationUnitBackendID?: string;
    DebtorOrganizationUnitName?: string;
    DebtorOrganizationUnitBackendID?: string;
    /**
     * Entity type: Language
     */
    CreditorOrganizationUnitLanguageID: string;
    /**
     * Entity type: Country
     */
    CreditorOrganizationUnitCountryID: string;
    AdditionalAmounts: InvoiceAdditionalAmountDto[];
    Disputes: InvoiceDisputeDto[];
    Lines: InvoiceDetailLineDto[];
    Blobs: InvoiceBlobDto[];
    PaidAmount?: number;
    OpenAmount?: number;
    BookStatus: InvoiceBookStatusDto;
    Shipments: InvoiceShipment[];
    /**
     * The ExpectedQuantity of all the InvoiceLines summed
     */
    ExpectedTotalQuantity?: number;
    /**
     * The Quantity of all the InvoiceLines summed
     */
    TotalQuantity: number;
    /**
     * The difference between TotalQuantity and ExpectedTotalQuantity
     */
    TotalQuantityDifference?: number;
    /**
     * The TotalAmount of the invoice minus the OriginalDisputes
     */
    SubTotalAmount: number;
    /**
     * The ExpectedTotalAmount of the invoice minus the Disputes
     */
    ExpectedSubTotalAmount?: number;
    /**
     * The Amount of the Disputes summed by Type
     */
    DisputeAmounts: DisputeAmounts;
    /**
     * The TotalAmountInvoicedInTax of all the InvoiceLines summed
     */
    TotalLineAmountInvoicedInTax: number;
    FiscalData: InvoiceFiscalData;
    ExportStatus: InvoiceFullExportStatus;
    IsIntraCompany: boolean;
    IsInterCompany: boolean;
    OrderID?: number;
    OrderDisplayID?: string;
    RecipientEmail?: string;
    RecipientCode?: string;
    PublicProjectCode?: string;
    TenderIdentificationCode?: string;
    UserData: InvoiceUserDetailsDto;
    /**
     * Entity type: Invoice
     */
    ReferencedInvoiceID?: number;
    /**
     * Entity type: Invoice
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    CreditorOrganizationUnitID: number;
    /**
     * Entity type: OrganizationUnit
     */
    DebtorOrganizationUnitID?: number;
    PaymentTermStartDate?: string;
    PaymentTermDueDate?: string;
    Type: InvoiceTypes;
    InvoiceDate?: string;
    InvoiceNumber: string;
    Description: string;
    Status: InvoiceStatuses;
    TotalAmount: number;
    CurrencyID: string;
    HoldStatusID?: number;
    /**
     * The TotalAmount on the actual Invoice as provided by the Supplier
     */
    OriginalTotalAmount?: number;
    /**
     * The difference between the TotalAmount and the OriginalTotalAmount
     */
    OriginalTotalAmountDifference?: number;
    /**
     * The ExpectedTotalAmountInTax of all the InvoiceLines + AdditionalAmounts + ExpectedDisputes
     */
    ExpectedTotalAmount?: number;
    /**
     * The difference between the TotalAmount and the ExpectedTotalAmount
     */
    ExpectedTotalAmountDifference?: number;
    TaxReverseCharge: boolean;
    ZippedSignature: string;
    Signature: string;
    EcoTax: number;
  }

  export interface InvoiceDetailLineDto {
    /**
     * Entity type: InvoiceLine
     */
    ID: number;
    OrderLine: InvoiceDetailsOrderLineDto;
    ShipmentLine: InvoiceDetailsShipmentLineDto;
    InvoiceDate?: string;
    UnitCost?: number;
    UnitPrice: number;
    TaxRate: number;
    TaxCode?: string;
    TaxRateCategory?: TaxRateCategory;
    DiscountAmount: number;
    Disputes: InvoiceDisputeDto[];
    TotalAmount: number;
    TotalAmountInTax: number;
    TotalAmountInvoicedInTax: number;
    TotalAmountInvoiced: number;
    ExpectedUnitPrice?: number;
    ExpectedQuantity?: number;
    ExpectedDiscountAmount?: number;
    ExpectedTaxRate?: number;
    ExpectedTotalAmount?: number;
    ExpectedTotalAmountInTax?: number;
    /**
     * The amount that has to be resolved with disputes: ExpectedTotalAmountInTax - TotalAmountInTax - Disputes
     */
    AmountToBeDisputed?: number;
    Quantity: number;
  }

  export interface InvoiceDetailsOrderLineDto {
    Description: string;
    UnitCost?: number;
    UnitPrice: number;
    /**
     * Entity type: OrderLine
     */
    ID: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    ProductCustomID: string;
    Product?: any;
    SupplierProductBackendID: string;
    Type: OrderLineTypes;
  }

  export interface InvoiceDetailsShipmentLineDto {
    /**
     * Entity type: ShipmentLine
     */
    ID: number;
    QuantityDelivered: number;
    TotalAmountDelivered: number;
    Shipment: InvoiceDetailsShipmentDto;
  }

  export interface InvoiceDetailsShipmentDto {
    /**
     * Entity type: Shipment
     */
    ID: number;
    BackendID: string;
  }

  export interface InvoiceBookStatusDto {
    IsBooked: boolean;
    CanBeBooked: boolean;
    Message: string;
  }

  export interface InvoiceShipment {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
    ShipmentBackendID: string;
    LastDeliveryDate?: string;
    CompletionTime?: string;
    TotalAmount: number;
    ExpectedTotalAmount?: number;
    TotalQuantity: number;
    ExpectedTotalQuantity?: number;
  }

  export interface DisputeAmounts {
    Total: number;
    Original: number;
    Expected: number;
  }

  export interface InvoiceFiscalData {
    UniqueDocumentCode: string;
    QrCodeData: string;
    DocumentSequenceNumber: string;
    FiscalDocumentID: string;
    FiscalDocumentDate: string;
    FiscalDocumentType: string;
    ExternalDocumentConfirmationNumber: string;
    ExternalFiscalDeviceID: string;
  }

  export const enum InvoiceFullExportStatus {
    None = 0,
    Complete = 1,
    NotComplete = 2
  }

  export interface InvoiceUserDetailsDto {
    FirstName: string;
    LastName: string;
    EmailAddress: string;
    PhoneNumber: string;
    FiscalID: string;
    UserBillingAddress: InvoiceAddressDto;
    UserShippingAddress: InvoiceAddressDto;
    CompanyName: string;
    TaxRegistrationNumber: string;
    RegistrationNumber: string;
    CountryID: string;
    CompanyFiscalID?: string;
  }

  export interface InvoiceAddressDto {
    Address1: string;
    Address2: string;
    HouseNumber: string;
    ZipCode: string;
    Subdistrict: string;
    District: string;
    City: string;
    State: string;
    CountryID: string;
  }

  /**
   * Create an InvoiceAdditionalAmount
   */
  export interface CreateInvoiceAdditionalAmount {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
    /**
     * Entity type: InvoiceAdditionalAmountTypes
     */
    TypeID: number;
    OriginalAmount: number;
    Amount: number;
    TaxRate?: number;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID?: number;
  }

  export interface CreateInvoiceAdditionalAmountResponse {
    /**
     * Entity type: InvoiceAdditionalAmount
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update an InvoiceAdditionalAmount
   */
  export interface UpdateInvoiceAdditionalAmount {
    /**
     * Entity type: InvoiceAdditionalAmount
     */
    ID: number;
    /**
     * Entity type: InvoiceAdditionalAmountTypes
     */
    TypeID: number;
    OriginalAmount: number;
    Amount: number;
    TaxRate?: number;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID?: number;
  }

  /**
   * Delete an InvoiceAdditionalAmount
   */
  export interface DeleteInvoiceAdditionalAmount {
    /**
     * Entity type: InvoiceAdditionalAmount
     */
    ID: number;
  }

  /**
   * Get all AdditionalAmounts for an Invoice
   */
  export interface GetInvoiceAdditionalAmountsForInvoice {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
  }

  export interface GetInvoiceAdditionalAmountsForInvoiceResponse {
    InvoiceAdditionalAmounts: GetInvoiceAdditionalAmountsForInvoiceResponse.InvoiceAdditionalAmountDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetInvoiceAdditionalAmountsForInvoiceResponse {
    export interface InvoiceAdditionalAmountDto {
      /**
       * Entity type: InvoiceAdditionalAmount
       */
      ID: number;
      /**
       * Entity type: InvoiceAdditionalAmountTypes
       */
      TypeID: number;
      TypeName: string;
      OriginalAmount: number;
      Amount: number;
      OriginalAmountInTax: number;
      AmountInTax: number;
      TaxRate: number;
      /**
       * Entity type: TaxCode
       */
      TaxCodeID: number;
      TaxCodeName: string;
    }

  }

  /**
   * Get a InvoiceAdditionalAmountType by ID
   */
  export interface GetInvoiceAdditionalAmountTypeByID {
    /**
     * Entity type: InvoiceAdditionalAmountTypes
     */
    ID: number;
  }

  export interface GetInvoiceAdditionalAmountTypeByIDResponse {
    /**
     * Entity type: InvoiceAdditionalAmountTypes
     */
    ID: number;
    Name: string;
    Description?: string;
    LedgerClassID?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Create a InvoiceAdditionalAmountType
   */
  export interface CreateInvoiceAdditionalAmountType {
    Name: string;
    Description?: string;
    LedgerClassID?: string;
  }

  export interface CreateInvoiceAdditionalAmountTypeResponse {
    /**
     * Entity type: InvoiceAdditionalAmountTypes
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update the Description and LedgerClassID of a InvoiceAdditionalAmountType
   */
  export interface UpdateInvoiceAdditionalAmountType {
    /**
     * Entity type: InvoiceAdditionalAmountTypes
     */
    ID: number;
    Description?: string;
    LedgerClassID?: string;
  }

  /**
   * Delete a InvoiceAdditionalAmountType, this is only allowed if the type is never used
   */
  export interface DeleteInvoiceAdditionalAmountType {
    /**
     * Entity type: InvoiceAdditionalAmountTypes
     */
    ID: number;
  }

  /**
   * Get all InvoiceAdditionalAmountTypes
   */
  export interface GetInvoiceAdditionalAmountTypes {
  }

  export interface GetInvoiceAdditionalAmountTypesResponse {
    InvoiceAdditionalAmountTypes: GetInvoiceAdditionalAmountTypesResponse.InvoiceAdditionalAmountTypeDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetInvoiceAdditionalAmountTypesResponse {
    export interface InvoiceAdditionalAmountTypeDto {
      /**
       * Entity type: InvoiceAdditionalAmountTypes
       */
      ID: number;
      Name: string;
      Description?: string;
      LedgerClassID?: string;
    }

  }

  /**
   * Attaches a blob to an invoice, either by `BlobID` or `BlobUrl`.
   */
  export interface AttachBlobToInvoice {
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrl?: string;
  }

  /**
   * Removes a blob from an invoice, either by `BlobID` or `BlobUrl`.
   */
  export interface DeleteInvoiceBlob {
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrl?: string;
  }

  /**
   * Provides a mapping between an organization unit and a company based on a country. This mapping is used in scenarios for where delivery orders are
   * in play. E.g endless aisle (delivery order from a store) and an online order from a website for example.
   * 
   * To comply with regulations, these invoices that are generated require the tax registration number from the company that will be delivering the goods
   * with its specific registration from the country that the goods are send to.
   * 
   * If a mapping already exists for given `OrganizationUnitID` and `CountryID`, the `CompanyID` will be updated and `AlreadyExisted` in the response will be `true`.
   */
  export interface CreateOrUpdateInvoiceCompanyMapping {
    /**
     * Entity type: Country
     */
    CountryID: string;
    /**
     * Entity type: Company
     */
    CompanyID: number;
    VatNumber: string;
  }

  export interface CreateOrUpdateInvoiceCompanyMappingResponse {
    /**
     * Entity type: InvoiceCompanyMapping
     */
    ID: number;
    AlreadyExisted: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Lists the `InvoiceCompanyMapping` items.
   */
  export interface ListInvoiceCompanyMapping {
    InitialPageConfig?: PageTokenConfig<ListInvoiceCompanyMappingFilter>;
    PageToken?: string;
  }

  export interface ListInvoiceCompanyMappingFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: Company
     */
    CompanyID?: number;
  }

  export interface ListInvoiceCompanyMappingResponse {
    Results?: ListInvoiceCompanyMappingModel[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListInvoiceCompanyMappingModel {
    /**
     * Entity type: InvoiceCompanyMapping
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OrganizationUnitBackendID?: string;
    OrganizationUnitName?: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    /**
     * Entity type: Company
     */
    CompanyID: number;
    CompanyName: string;
    VatNumber: string;
  }

  /**
   * Deletes an `InvoiceCompanyMapping`.
   */
  export interface DeleteInvoiceCompanyMapping {
    /**
     * Entity type: InvoiceCompanyMapping
     */
    ID: number;
  }

  /**
   * Get a InvoiceDisputeReason by ID
   */
  export interface GetInvoiceDisputeReasonByID {
    /**
     * Entity type: InvoiceDisputeReason
     */
    ID: number;
  }

  export interface GetInvoiceDisputeReasonByIDResponse {
    /**
     * Entity type: InvoiceDisputeReason
     */
    ID: number;
    Name: string;
    Description?: string;
    LedgerClassID?: string;
    AutoResolve: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Create a InvoiceDisputeReason
   */
  export interface CreateInvoiceDisputeReason {
    Name: string;
    Description?: string;
    LedgerClassID?: string;
    AutoResolve: boolean;
  }

  export interface CreateInvoiceDisputeReasonResponse {
    /**
     * Entity type: InvoiceDisputeReason
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update the Description and LedgerClassID of a InvoiceDisputeReason
   */
  export interface UpdateInvoiceDisputeReason {
    /**
     * Entity type: InvoiceDisputeReason
     */
    ID: number;
    Description?: string;
    LedgerClassID?: string;
    AutoResolve: boolean;
  }

  /**
   * Delete a InvoiceDisputeReason, this is only allowed if the reason is never used
   */
  export interface DeleteInvoiceDisputeReason {
    /**
     * Entity type: InvoiceDisputeReason
     */
    ID: number;
  }

  /**
   * Get all InvoiceDisputeReasons
   */
  export interface GetInvoiceDisputeReasons {
  }

  export interface GetInvoiceDisputeReasonsResponse {
    InvoiceDisputeReasons: GetInvoiceDisputeReasonsResponse.InvoiceDisputeReasonDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetInvoiceDisputeReasonsResponse {
    export interface InvoiceDisputeReasonDto {
      /**
       * Entity type: InvoiceDisputeReason
       */
      ID: number;
      Name: string;
      Description?: string;
      LedgerClassID?: string;
      AutoResolve: boolean;
    }

  }

  /**
   * Create an InvoiceDisputeResolveAction
   */
  export interface CreateInvoiceDisputeResolveAction {
    /**
     * Entity type: InvoiceDispute
     */
    InvoiceDisputeID: number;
    Amount: number;
    Description?: string;
    LedgerClassID?: string;
  }

  export interface CreateInvoiceDisputeResolveActionResponse {
    /**
     * Entity type: InvoiceDisputeResolveAction
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update an InvoiceDisputeResolveAction
   */
  export interface UpdateInvoiceDisputeResolveAction {
    /**
     * Entity type: InvoiceDisputeResolveAction
     */
    ID: number;
    Amount: number;
    Description?: string;
    LedgerClassID?: string;
  }

  /**
   * Delete an InvoiceDisputeResolveAction
   */
  export interface DeleteInvoiceDisputeResolveAction {
    /**
     * Entity type: InvoiceDisputeResolveAction
     */
    ID: number;
  }

  /**
   * Create an InvoiceDispute
   */
  export interface CreateInvoiceDispute {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
    /**
     * Entity type: InvoiceLine
     */
    InvoiceLineID?: number;
    /**
     * Entity type: InvoiceAdditionalAmount
     */
    InvoiceAdditionalAmountID?: number;
    /**
     * Entity type: InvoiceDisputeReason
     */
    ReasonID: number;
    Amount: number;
    Description?: string;
    Type?: InvoiceDisputeTypes;
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Email address to send notification to. This will overwrite the selected User when set.
     */
    EmailAddressToSendNotificationTo?: string;
  }

  export interface CreateInvoiceDisputeResponse {
    /**
     * Entity type: InvoiceDispute
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update an InvoiceDispute
   */
  export interface UpdateInvoiceDispute {
    /**
     * Entity type: InvoiceDispute
     */
    ID: number;
    /**
     * Entity type: InvoiceDisputeReason
     */
    ReasonID?: number;
    Amount?: number;
    Description?: string;
    Type?: InvoiceDisputeTypes;
    /**
     * Entity type: User
     */
    UserID?: number;
  }

  /**
   * Delete an InvoiceDispute
   */
  export interface DeleteInvoiceDispute {
    /**
     * Entity type: InvoiceDispute
     */
    ID: number;
  }

  /**
   * Get all Disputes for an Invoice
   */
  export interface GetInvoiceDisputesForInvoice {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
  }

  export interface GetInvoiceDisputesForInvoiceResponse {
    InvoiceDisputes: GetInvoiceDisputesForInvoiceResponse.InvoiceDisputeDto[];
    TotalDisputedAmount: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetInvoiceDisputesForInvoiceResponse {
    export interface InvoiceDisputeDto {
      /**
       * Entity type: InvoiceDispute
       */
      ID: number;
      /**
       * Entity type: InvoiceLine
       */
      InvoiceLineID?: number;
      /**
       * Entity type: InvoiceAdditionalAmount
       */
      InvoiceAdditionalAmountID?: number;
      /**
       * Entity type: InvoiceDisputeReason
       */
      ReasonID: number;
      ReasonName: string;
      Amount: number;
      Description?: string;
      IsResolved: boolean;
      ResolvedAmount: number;
      Type: InvoiceDisputeTypes;
      /**
       * Entity type: User
       */
      UserID?: number;
      UserFullName?: string;
      EmailAddressToSendNotificationTo?: string;
      ResolveActions: InvoiceDisputeResolveActionDto[];
    }

  }

  /**
   * List the exports for the given Invoice
   */
  export interface ListInvoiceExportsForInvoice {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListInvoiceExportsForInvoiceResponse {
    Result?: PagedResult<ListInvoiceExportsForInvoiceResponse.InvoiceExportDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListInvoiceExportsForInvoiceResponse {
    export interface InvoiceExportDto {
      /**
       * Entity type: InvoiceExport
       */
      ID: number;
      Name: string;
      Status: TransputJobStatuses;
      CreationTime: string;
      LastModificationTime?: string;
    }

  }

  /**
   * Get the details of an InvoiceExport
   */
  export interface GetInvoiceExport {
    /**
     * Entity type: InvoiceExport
     */
    ID: number;
  }

  export interface GetInvoiceExportResponse {
    /**
     * Entity type: InvoiceExport
     */
    ID: number;
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
    Name: string;
    Status: TransputJobStatuses;
    CreationTime: string;
    LastModificationTime?: string;
    ExternalStatus: InvoiceExportExternalStatus;
    ExternalStatusTime?: string;
    Errors: GetInvoiceExportResponse.GetInvoiceExportError[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetInvoiceExportResponse {
    export interface GetInvoiceExportError {
      Code?: string;
      Description?: string;
      Suggestion?: string;
      Timestamp?: string;
    }

  }

  export const enum InvoiceExportExternalStatus {
    None = 0,
    Pending = 1,
    Completed = 2,
    Failed = -1
  }

  /**
   * Retry the given InvoiceExports
   */
  export interface RetryInvoiceExport {
    /**
     * Entity type: InvoiceExport
     */
    InvoiceExportIDs: number[];
    Force?: boolean;
  }

  /**
   * Get the documents for an export when available
   */
  export interface GetInvoiceExportDocuments {
    /**
     * Entity type: InvoiceExport
     */
    ID: number;
  }

  export interface GetInvoiceExportDocumentsResponse {
    RequestDocuments: TransputJobDocument[];
    ResponseDocuments: TransputJobDocument[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for retrieving a list of available `InvoiceOutputType`'s providing a `Invoice`
   */
  export interface GetInvoiceOutputTypes {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
  }

  export interface GetInvoiceOutputTypesResponse {
    OutputTypes: InvoiceOutputType[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum InvoiceOutputType {
    None = 0,
    Mail = 1,
    PDF = 2,
    Paper = 4,
    Thermal = 8,
    All = 15
  }

  /**
   * Retrieves payments for an order, with context about allocated invoices, filtered on specified optional `InvoiceID`.
   */
  export interface GetInvoicePayments {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
  }

  export interface GetInvoicePaymentsResponse {
    Result: GetInvoicePaymentsResponse.InvoicePayment[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetInvoicePaymentsResponse {
    export interface InvoicePayment {
      /**
       * Entity type: PaymentTransaction
       */
      PaymentTransactionID: number;
      /**
       * Entity type: Invoice
       */
      InvoiceID?: number;
      Amount: number;
      TypeName: string;
      TypeCode: string;
      MethodName: string;
      MethodCode: string;
    }

  }

  /**
   * Allocates a payment transaction to either a specific invoice, or to all open invoices sequentially.
   */
  export interface CreateInvoicePayment {
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID: number;
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
  }

  /**
   * List all the blobs that're attached to the given invoice (`InvoiceID`).
   */
  export interface ListBlobsForInvoice {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
  }

  export interface ListBlobsForInvoiceResponse {
    Result: ListBlobsForInvoiceResponse.Model[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListBlobsForInvoiceResponse {
    export interface Model {
      Name: string;
      MimeType: string;
      BlobID: string;
      Url: string;
      CreationTime: string;
      TypeID: number;
    }

  }

  /**
   * List Control Documents
   */
  export interface ListControlDocuments {
    PageConfig?: PageConfig<ListControlDocumentsFilter>;
  }

  export interface ListControlDocumentsFilter {
    Types: ControlDocumentTypes[];
    StartDate?: string;
    EndDate?: string;
    Number: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
  }

  export const enum ControlDocumentTypes {
    ControlDocument = 2,
    InitializationDocument = 3,
    ClosingDocument = 4,
    MonthlyControlDocument = 5,
    YearlyControlDocument = 6,
    IntegrityCheckDocument = 7,
    Unknown = 8
  }

  export interface ListControlDocumentsResponse {
    Result?: PagedResult<InvoiceControlDocumentData>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface InvoiceControlDocumentData {
    ID: number;
    Date?: string;
    Number: string;
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    Signature: string;
    ZippedSignature: string;
    Type: ControlDocumentTypes;
  }

  /**
   * List invoice exports
   */
  export interface ListInvoiceExports {
    InitialPageConfig?: PageTokenConfig<ListInvoiceExportFilter>;
    PageToken?: string;
  }

  export interface ListInvoiceExportFilter {
    /**
     * Entity type: InvoiceExport
     */
    ID?: number;
    /**
     * The organization units to list the invoices for, will be ignored if `OrganizationUnitSetID` is specified
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    StartDate?: string;
    EndDate?: string;
    ExternalStatus?: InvoiceExportExternalStatus;
    /**
     * The invoice IDs to list the invoice exports for
     * Entity type: Invoice
     */
    InvoiceIDs?: number[];
    InvoiceNumber?: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    Types?: string[];
  }

  export interface ListInvoiceExportResponse {
    Results?: ListInvoiceExportsDto[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListInvoiceExportsDto {
    /**
     * Entity type: InvoiceExport
     */
    ID?: number;
    Type?: string;
    ExternalStatus?: InvoiceExportExternalStatus;
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
    InvoiceNumber?: string;
    InvoiceDate?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OrganizationUnitName?: string;
    TotalAmount?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    OrderDisplayID?: string;
  }

  /**
   * List ledgers for invoices
   * 
   * Available filters:
   * - InvoiceID
   * - InvoiceLineID
   * - InvoiceDisputeID
   * - Type
   */
  export interface ListInvoiceLedger {
    PageConfig?: PageConfig<ListInvoiceLedgerFilter>;
  }

  export interface ListInvoiceLedgerFilter {
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
    /**
     * Entity type: InvoiceLine
     */
    InvoiceLineID?: number;
    /**
     * Entity type: InvoiceDispute
     */
    InvoiceDisputeID?: number;
    /**
     * Entity type: InvoiceLedgerType
     */
    Type?: number;
  }

  export interface ListInvoiceLedgerResponse {
    Result?: PagedResult<ListInvoiceLedgerResponse.InvoiceLedgerDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListInvoiceLedgerResponse {
    export interface InvoiceLedgerDto {
      InvoiceID: number;
      InvoiceLineID?: number;
      InvoiceDisputeID?: number;
      TypeID: number;
      TypeName: string;
      OldValue: string;
      NewValue: string;
      Description: string;
      CreatedByID: number;
      CreatedByFullName: string;
      CreationTime: string;
    }

  }

  /**
   * List Invoices
   */
  export interface ListInvoices {
    PageConfig?: PageConfig<ListInvoiceFilter>;
  }

  export interface ListInvoiceFilter {
    Type?: InvoiceTypes;
    StartDate?: string;
    EndDate?: string;
    Number: string;
    /**
     * The organization units to list the invoices for, will be ignored if `OrganizationUnitSetID` is specified
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs: number[];
    /**
     * The supplier organization units to list the invoices for, will be ignored if `SupplierOrganizationUnitSetID` is specified
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitIDs: number[];
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    SupplierOrganizationUnitSetID?: number;
    Status?: InvoiceStatuses;
    /**
     * Entity type: Order
     */
    OrderIDs: number[];
    HasUnresolvedDisputes?: boolean;
    IsMatched?: boolean;
    HasSupplierOrganizationUnit?: boolean;
  }

  export interface ListInvoicesResponse {
    Result?: PagedResult<ListInvoicesDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListInvoicesDto {
    /**
     * Entity type: Invoice
     */
    ID: number;
    InvoiceDate?: string;
    InvoiceNumber: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    BackendID: string;
    OrganizationUnitName: string;
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID?: number;
    SupplierOrganizationUnitName: string;
    Description: string;
    CurrencyID: string;
    TotalAmount: number;
    Signature: string;
    Status: InvoiceStatuses;
    StatusID: number;
    HoldStatusID?: number;
    HasUnresolvedDisputes: boolean;
    /**
     * Entity type: Invoice
     */
    ReferencedInvoiceID?: number;
  }

  /**
   * List manually created invoices. These invoices are created via the `CreateManualInvoice` service and are used as a worst-case scenario when everything has gone offline and the retailer has to make invoices on actual paper. These services are then used to enter the paper invoices back in to EVA.
   */
  export interface ListManualInvoices {
    PageConfig?: PageConfig<ListManualInvoicesFilter>;
  }

  export interface ListManualInvoicesFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Number?: string;
    StartDate?: string;
    EndDate?: string;
  }

  export interface ListManualInvoicesResponse {
    Result?: PagedResult<ManualInvoiceSummary>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ManualInvoiceSummary {
    /**
     * Entity type: Invoice
     */
    ID: number;
    InvoiceDate?: string;
    Number: string;
    Series: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    FiscalID: string;
    Name: string;
  }

  /**
   * List all of the lines of a shipment that have not been completely invoiced.
   */
  export interface ListShipmentLinesToInvoice {
    PageConfig?: PageConfig<ListShipmentLinesToInvoiceFilter>;
  }

  export interface ListShipmentLinesToInvoiceFilter {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
  }

  export interface ListShipmentLinesToInvoiceResponse {
    Result?: PagedResult<ListShipmentLinesToInvoiceResponse.Model>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListShipmentLinesToInvoiceResponse {
    export interface Model {
      ID: number;
      QuantityShipped: number;
      QuantityDelivered: number;
      QuantityInvoiced: number;
      QuantityAvailableForInvoice: number;
      CurrencyID: string;
      UnitPrice: number;
      TaxRate: number;
      TotalAmountInvoiced: number;
      TotalAmountDelivered: number;
      ProductID: number;
      CustomID: string;
      ProductName: string;
      SupplierProductBackendID: string;
      DeliveryType: ShipmentLineDeliveryTypes;
    }

  }

  /**
   * List all of the shipments that have not been completely invoiced.
   */
  export interface ListShipmentsToInvoice {
    PageConfig?: PageConfig<ListShipmentsToInvoiceFilter>;
  }

  export interface ListShipmentsToInvoiceFilter {
    /**
     * Entity type: Shipment
     */
    ID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    ShipFromOrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    ShipToOrganizationUnitID?: number;
    From?: string;
    To?: string;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    BackendID: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    OrderBackendID: string;
  }

  export interface ListShipmentsToInvoiceResponse {
    Result?: PagedResult<ListShipmentsToInvoiceResponse.Model>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListShipmentsToInvoiceResponse {
    export interface Model {
      /**
       * Entity type: Shipment
       */
      ID: number;
      /**
       * Entity type: Order
       */
      OrderIDs: number[];
      OrderBackendIDs: string[];
      ShipmentDate: string;
      LastDeliveryDate?: string;
      CompletionTime?: string;
      BackendID: string;
      TrackingCode: string;
      TotalQuantityInvoiced: number;
      TotalQuantityReceived: number;
      TotalAmountReceived: number;
      TotalAmountInvoiced: number;
      BackendReference?: string;
    }

  }

  /**
   * Update Invoice Hold Status
   */
  export interface UpdateInvoiceHoldStatus {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
    /**
     * Entity type: InvoiceHoldStatus
     */
    HoldStatusID?: number;
  }

  /**
   * Updates lines on the given invoice (`InvoiceID`).
   * 
   * When the Quantity is 0 and the ExpectedQuantity is `null`, the line will be deleted.
   */
  export interface UpdateInvoiceLines {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
    Lines: UpdateInvoiceLine[];
  }

  export interface UpdateInvoiceLine {
    /**
     * Entity type: InvoiceLine
     */
    InvoiceLineID: number;
    Quantity: number;
    ExpectedQuantity?: number;
    UnitPrice: number;
    /**
     * Range: 1-2
     */
    TaxRate: number;
  }

  /**
   * Updates an existing invoice. See the `CreateInvoice` service for more details about the request.
   */
  export interface UpdateInvoice {
    /**
     * Entity type: Invoice
     */
    ID: number;
    InvoiceDate: string;
    PaymentTermStartDate?: string;
    PaymentTermDueDate?: string;
    InvoiceNumber?: string;
    Description?: string;
    /**
     * Entity type: OrganizationUnit
     */
    CreditorOrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    DebtorOrganizationUnitID?: number;
    /**
     * Entity type: InvoiceHoldStatus
     */
    HoldStatusID?: number;
    Blobs?: InvoiceBlobDto[];
    OriginalTotalAmount?: number;
    FiscalID?: string;
    TaxReverseCharge?: boolean;
  }

  /**
   * Updates the invoice user data. To retrieve the information that has been set use: `GetInvoice`
   */
  export interface UpdateInvoiceUserData {
    /**
     * Entity type: Invoice
     */
    InvoiceID: number;
    RemoveCompany?: boolean;
    FirstName?: string;
    LastName?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    FiscalID?: string;
    Address1?: string;
    HouseNumber?: string;
    ZipCode?: string;
    City?: string;
    Subdistrict?: string;
    District?: string;
    State?: string;
    CountryID?: string;
    CompanyName?: string;
    CompanyVatNumber?: string;
    CompanyFiscalID?: string;
  }

  /**
   * Service to validate and upgrade tickets to invoices based on order details.
   */
  export interface UpgradeInvoice {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface UpgradeInvoiceResponse {
    /**
     * Entity type: Invoice
     */
    InvoiceIDs: number[];
    ValidationErrors: UpgradeInvoiceResponse.ValidationError[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace UpgradeInvoiceResponse {
    export interface ValidationError {
      Parameter: string;
      Description?: string;
    }

  }

  /**
   * Check if given `InvoiceNumber` is valid (eg. does not already exist & passes other validations).
   */
  export interface ValidateInvoiceNumber {
    InvoiceNumber: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    Type?: InvoiceTypes;
  }

  export interface ValidateInvoiceNumberResponse {
    IsValid: boolean;
    Invoices: InvoiceDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface InvoiceDto {
    /**
     * Entity type: Invoice
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    CreditorOrganizationUnitID: number;
    /**
     * Entity type: OrganizationUnit
     */
    DebtorOrganizationUnitID?: number;
    PaymentTermStartDate?: string;
    PaymentTermDueDate?: string;
    Type: InvoiceTypes;
    InvoiceDate?: string;
    InvoiceNumber: string;
    Description: string;
    Status: InvoiceStatuses;
    TotalAmount: number;
    CurrencyID: string;
    HoldStatusID?: number;
    /**
     * The TotalAmount on the actual Invoice as provided by the Supplier
     */
    OriginalTotalAmount?: number;
    /**
     * The difference between the TotalAmount and the OriginalTotalAmount
     */
    OriginalTotalAmountDifference?: number;
    /**
     * The ExpectedTotalAmountInTax of all the InvoiceLines + AdditionalAmounts + ExpectedDisputes
     */
    ExpectedTotalAmount?: number;
    /**
     * The difference between the TotalAmount and the ExpectedTotalAmount
     */
    ExpectedTotalAmountDifference?: number;
    TaxReverseCharge: boolean;
    ZippedSignature: string;
    Signature: string;
    EcoTax: number;
  }

  /**
   * Returns inquiry details
   */
  export interface GetInquiry {
    /**
     * Entity type: Inquiry
     */
    ID: number;
  }

  export interface GetInquiryResponse {
    /**
     * Entity type: Inquiry
     */
    ID: number;
    Name: string;
    Description?: string;
    PromptUser: boolean;
    OneTimeUseOnly: boolean;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    Items: GetInquiryResponse.InquiryItemData[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetInquiryResponse {
    export interface InquiryData {
      /**
       * Entity type: Inquiry
       */
      ID: number;
      Name: string;
      Description?: string;
      Items: GetInquiryResponse.InquiryItemData[];
    }

    export interface InquiryItemData {
      /**
       * Entity type: InquiryItem
       */
      ID: number;
      Name: string;
      Sequence: number;
      IsRequired: boolean;
      Description?: string;
      CustomFieldMetadata: CustomFieldMetadata;
    }

  }

  export interface CustomFieldMetadata {
    /**
     * Entity type: CustomField
     */
    CustomFieldID: number;
    Name: string;
    DisplayName?: string;
    DataType: string;
    DataTypeID: number;
    BackendID?: string;
    IsArray: boolean;
    EnumValues?: { [key: string]: string };
    Order: number;
  }

  /**
   * Returns user inquiries
   */
  export interface GetUserInquiries {
    /**
     * Entity type: User
     */
    UserID?: number;
    IgnoreSubscriptionInquiries?: boolean;
    ShowSubmittedOneTimeUseInquieries?: boolean;
  }

  export interface GetUserInquiriesResponse {
    Inquiries: UserInquiryDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Returns a user inquiry with data
   */
  export interface GetUserInquiry {
    /**
     * Entity type: Inquiry
     */
    InquiryID: number;
    /**
     * Entity type: User
     */
    UserID?: number;
  }

  export interface GetUserInquiryResponse {
    /**
     * Entity type: Inquiry
     */
    ID: number;
    Name: string;
    Description?: string;
    OneTimeUseOnly: boolean;
    PromptUser: boolean;
    SubmittedOn?: string;
    Items: GetUserInquiryResponse.InquiryItemData[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetUserInquiryResponse {
    export interface InquiryItemData {
      /**
       * Entity type: InquiryItem
       */
      ID: number;
      Name: string;
      Sequence: number;
      IsRequired: boolean;
      Description?: string;
      CustomFieldMetadata: CustomFieldMetadata;
      CustomFieldValue: CustomFieldValue;
    }

  }

  /**
   * Submit an inquiry
   */
  export interface SubmitInquiry {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Inquiry
     */
    InquiryID: number;
    /**
     * Range: 0-10
     */
    Score?: number;
    Feedback?: string;
    Items: SubmitInquiry.ItemData[];
  }

  export namespace SubmitInquiry {
    export interface ItemData {
      /**
       * Entity type: InquiryItem
       */
      ID: number;
      Value: CustomFieldValue;
    }

  }

  /**
   * Returns the available assembly names for the device types. Can optionally filter by device types.
   */
  export interface GetAssemblyNamesForDeviceTypes {
    DeviceTypes?: string[];
  }

  export interface GetAssemblyNamesForDeviceTypesResponse {
    Result: GetAssemblyNamesForDeviceTypesResponse.DeviceTypeWithAssemblyName[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetAssemblyNamesForDeviceTypesResponse {
    export interface DeviceTypeWithAssemblyName {
      DeviceType: EnumDto;
      AssemblyName: string[];
    }

  }

  /**
   * Service for retrieving a existing `Device`
   */
  export interface GetDevice {
    /**
     * Entity type: Device
     */
    ID: number;
  }

  export interface GetDeviceResponse {
    Result: GetDeviceResponse.DeviceDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetDeviceResponse {
    export interface DeviceDto {
      /**
       * Entity type: Device
       */
      ID?: number;
      Name?: string;
      BackendID?: string;
      /**
       * Entity type: DeviceType
       */
      TypeID?: number;
      Type?: FlagsEnumDto;
      Address?: string;
      ProxyAddress?: string;
      /**
       * Entity type: Station
       */
      StationID?: number;
      /**
       * Entity type: PrinterType
       */
      PrinterTypeID?: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID?: number;
      AssemblyName?: string;
      Data?: string;
      Station?: StationDto;
      OrganizationUnit?: OrganizationUnitDto;
      PrinterType?: DeviceDto.PrinterTypeModel;
    }

    export namespace DeviceDto {
      export interface PrinterTypeModel {
        /**
         * Entity type: PrinterType
         */
        ID: number;
        Name: string;
        Description?: string;
        PaperWidth: number;
      }

    }

  }

  export interface StationDto {
    /**
     * Entity type: Station
     */
    ID: number;
    GlobalID?: string;
    BackendID?: string;
    Name: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnit: OrganizationUnitDto;
    OrganizationUnitDescription?: string;
    Devices: DeviceDto[];
    HasPinDevice: boolean;
    HasThermalPrinterDevice: boolean;
    HasFiscalThermalPrinterDevice: boolean;
    HasPrinterDevice: boolean;
    HasCashDrawerDevice: boolean;
    HasZebraPrinterDevice: boolean;
    HasCustomerFacingDisplayDevice: boolean;
    HasSafeDevice: boolean;
    HasVoidDevice: boolean;
    HasScannerDevice: boolean;
    FiscalSystemID?: string;
    Barcode: string;
    IsPointOfSale: boolean;
    CustomFields: CustomFieldResponse[];
    IsFiscalStationInitialized: boolean;
  }

  export interface DeviceDto {
    /**
     * Entity type: Device
     */
    ID?: number;
    GlobalID?: string;
    BackendID?: string;
    Name?: string;
    /**
     * Entity type: DeviceType
     */
    TypeID?: number;
    Address?: string;
    ProxyAddress?: string;
    /**
     * Entity type: Station
     */
    StationID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    AssemblyName?: string;
    Data?: { [key: string]: any };
    Type?: FlagsEnumDto;
    OrganizationUnit?: OrganizationUnitDto;
  }

  /**
   * Service for retrieving a list of possible `Device` types
   */
  export interface GetDeviceTypes {
  }

  export interface GetDeviceTypesResponse {
    DeviceTypes: FlagsEnumDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Gets the possible valid reasons that have been defined for opening the cash drawer manually.
   */
  export interface GetOpenCashDrawerReasons {
  }

  export interface GetOpenCashDrawerReasonsResponse {
    Reasons: GetOpenCashDrawerReasonsResponse.OpenCashDrawerReason[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetOpenCashDrawerReasonsResponse {
    export interface OpenCashDrawerReason {
      /**
       * Entity type: OpenCashDrawerReason
       */
      ID: number;
      Name: string;
      Description: string;
      /**
       * Will be localized (if a localized version has been defined) to the culture of your current user.
       */
      LocalizedName: string;
      /**
       * Will be localized (if a localized version has been defined) to the culture of your current user.
       */
      LocalizedDescription: string;
    }

  }

  /**
   * Service for retieving a existing `Station`
   */
  export interface GetStation {
    /**
     * Entity type: Station
     */
    ID: number;
  }

  export interface GetStationResponse {
    /**
     * Entity type: Station
     */
    ID: number;
    GlobalID?: string;
    BackendID?: string;
    Name: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    OrganizationUnitBackendID?: string;
    HasPinDevice: boolean;
    HasThermalPrinterDevice: boolean;
    HasFiscalThermalPrinterDevice: boolean;
    HasPrinterDevice: boolean;
    HasCashDrawerDevice: boolean;
    HasZebraPrinterDevice: boolean;
    HasCustomerFacingDisplayDevice: boolean;
    HasSafeDevice: boolean;
    HasVoidDevice: boolean;
    HasScannerDevice: boolean;
    FiscalSystemID?: string;
    Barcode: string;
    IsPointOfSale: boolean;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for retrieving a list of `Device`
   */
  export interface ListDevices {
    PageConfig?: PageConfig<ListDevicesFilter>;
  }

  export interface ListDevicesFilter {
    Name?: string;
    BackendID?: string;
    Address?: string;
    ProxyAddress?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: DeviceType
     */
    TypeID?: number;
    /**
     * Entity type: Station
     */
    StationID?: number;
    /**
     * Entity type: PrinterType
     */
    PrinterTypeID?: number;
    /**
     * Entity type: Device
     */
    DeviceIDs?: number[];
  }

  export interface ListDevicesResponse {
    Result?: PagedResult<ListDevicesModel>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListDevicesModel {
    /**
     * Entity type: Device
     */
    ID?: number;
    Name?: string;
    BackendID?: string;
    TypeID?: number;
    Type?: FlagsEnumDto;
    Address?: string;
    ProxyAddress?: string;
    /**
     * Entity type: Station
     */
    StationID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: PrinterType
     */
    PrinterTypeID?: number;
    AssemblyName?: string;
    Data?: { [key: string]: any };
    CashLimit?: number;
    Station?: ListDevicesModel.StationModel;
    OrganizationUnit?: ListDevicesModel.OrganizationUnitModel;
    PrinterType?: ListDevicesModel.PrinterTypeModel;
  }

  export namespace ListDevicesModel {
    export interface StationModel {
      /**
       * Entity type: Station
       */
      ID: number;
      BackendID?: string;
      Name: string;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      OrganizationUnit?: ListDevicesModel.OrganizationUnitModel;
    }

    export interface OrganizationUnitModel {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      BackendID?: string;
      Name: string;
    }

    export interface PrinterTypeModel {
      /**
       * Entity type: PrinterType
       */
      ID: number;
      Name: string;
      Description?: string;
      PaperWidth: number;
    }

  }

  /**
   * List stations for specified organization unit.
   */
  export interface ListStationsForOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: DeviceType
     */
    DeviceTypeID?: number;
    PageConfig?: PageConfig<ListStationsFilter>;
  }

  export interface ListStationsFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    Name?: string;
    BackendID?: string;
    FiscalSystemID?: string;
    IncludeDeleted?: boolean;
    /**
     * Entity type: DeviceType
     */
    DeviceTypeID?: number;
  }

  export interface ListStationsForOrganizationUnitResponse {
    Result?: PagedResult<StationDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * List stations
   * 
   * This service is meant for management purposes, will return all stations you're allowed to view.
   */
  export interface ListStations {
    PageConfig?: PageConfig<ListStationsFilter>;
  }

  export interface ListStationsResponse {
    Result?: PagedResult<ListStationsResponse.Station>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListStationsResponse {
    export interface Station {
      /**
       * Entity type: Station
       */
      ID: number;
      BackendID?: string;
      Name: string;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      OrganizationUnitName: string;
      FiscalSystemID?: string;
      IsPointOfSale: boolean;
    }

  }

  /**
   * Send Configuration Page
   */
  export interface SendConfigurationPage {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  /**
   * A specific implementation for `AddProductToOrder` for GiftCards. Adds a new order line for a digital GiftCard to specified order, where
   * `OrderID` identifies the order for the customer and `Amount` is the desired amount to create a GiftCard for.
   * 
   * Optionally supply a `DetailsUrl` pointing to the website you want the buyer of the GiftCard to land to see/manage the order.
   * 
   * Additionally, the `DisplayOptions` property need to be supplied, this contains a bunch of default options to personalize the giftcard.
   * It is also possible to provide some Metadata. We won't do any processing on DisplayOptions.
   * 
   * Except: DetailsUrl will be changed to include the `OrderID` in the URL as well as a `token` that can be used to access a few services.
   */
  export interface AddDigitalGiftCardToOrder {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Range: 1E-06-1000000
     */
    Amount?: number;
    /**
     * The product ID to add as a giftcard. Will fallback to GiftCards:Digital:ProductID
     * Entity type: Product
     */
    ProductID?: number;
    Data?: GiftCardData;
    UpdateUrl?: string;
    GiftCardMedia?: GiftCardMedia;
  }

  /**
   * Checks a balance of given card, where `Handler` or `Barcode` determines the giftcard provider to consult.
   */
  export interface CardBalanceCheck {
    /**
     * Entity type: GiftCardConfiguration
     */
    ConfigurationID?: number;
    CardNumber?: string;
    CardPin?: string;
    Barcode?: string;
    Handler?: string;
    CardSubType?: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
  }

  export interface CardBalanceCheckResponse {
    CardID?: string;
    Balance: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    /**
     * If the total amount on the card can be spend on this order.
     */
    CanSpendAll?: boolean;
    /**
     * The remaining balance on the card when this order is paid.
     */
    RemainingBalance?: number;
    CanRefundWithoutTransaction: boolean;
    BusinessRules?: GiftCardBusinessRulesDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Gets the GiftCard mail information identified by the `OrderID` and `GiftCardID`.
   */
  export interface GetDigitalGiftCardOptions {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    GiftCardID?: string;
    AccessToken?: string;
  }

  export interface GetDigitalGiftCardOptionsResponse {
    FromEmailAddress?: string;
    ToEmailAddress?: string;
    DeliverySchedule?: string;
    CanBeUpdated?: boolean;
    PhoneNumber?: string;
    /**
     * Available options how a digital giftcards can be delivered
     */
    AvailableCommunicationOptions?: ProductGiftCardCommunicationOptions;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum ProductGiftCardCommunicationOptions {
    Mail = 1,
    Sms = 2
  }

  /**
   * Sets the new mail values for the GiftCard identified by the `OrderID` and `GiftCardID`.
   * 
   * Omitting the `FromEmailAddress` parameter will default to the email address of the customer attached to the order.
   */
  export interface UpdateDigitalGiftCardOptions {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    GiftCardID?: string;
    AccessToken?: string;
    FromEmailAddress?: string;
    ToEmailAddress?: string;
    PhoneNumber?: string;
    DeliverySchedule?: string;
    DeliveryMode?: GiftCardDeliveryMode;
  }

  /**
   * Download the GiftCard data for a specific order, based on given `OrderID` and `GiftCardID`. This order needs to be visible for the current user. Requires
   * the order to be shipped (automatically when it is fully paid).
   * 
   * Additionally, this service can be called with an `AccessToken` and `GiftCardID` combination. In this case, no user validation is done - you know both
   * keys to the GiftCard, so you are allowed to get it's information.
   * 
   * If you want, you can specify a `LanguageID` to use for rendering the report - when omitted, the `LanguageID` of the current user.
   * 
   * See `GetDigitalGiftCardsForOrder` service for more details.
   */
  export interface DownloadDigitalGiftCard {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    AccessToken?: string;
    GiftCardID?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
  }

  /**
   * Empty the full amount of a giftcard into an empty order.
   */
  export interface EmptyGiftCard {
    /**
     * Entity type: GiftCardConfiguration
     */
    ConfigurationID: number;
    CardNumber: string;
    Pin?: string;
  }

  export interface EmptyGiftCardResponse {
    /**
     * Entity type: Order
     */
    OrderID: number;
    AmountPaid: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Retrieve the GiftCard data for a specific order, based on given `OrderID`. This order needs to be visible for the current user.
   * 
   * Will return a list of `GiftCard` data, for every orderline with a GiftCard. Will return the same data supplied in the `AddGiftCardToOrder`
   * service. When the order was shipped (automatically when it is fully paid), the details `GiftCardNumber` and
   * `Pin` are also included. An additional property `IsAvailable` let's you check if it was indeed shipped and paid.
   * 
   * The `GiftCardID` returned on the GiftCard is it's unique identifier, to be used in conjunction with the `AccessToken` to make it globally
   * unique. Using the `AccessToken` and `GiftCardID`, we are pretty sure you are allowed to see the GiftCard data. Use this data to build the link
   * to share directly, or use the approperiate services to mail/text/print this.
   * 
   * Additionally, this service can be called with an `AccessToken` and `GiftCardID` combination, as explained above. In this case, no user validation
   * is done - you know both keys to the GiftCard, so you are allowed to get it's information.
   */
  export interface GetDigitalGiftCardsForOrder {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    AccessToken?: string;
    GiftCardID?: string;
  }

  export interface GetDigitalGiftCardsForOrderResponse {
    Result: GiftCard[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface GiftCard {
    IsAvailable: boolean;
    Amount: number;
    CurrencyID: string;
    Identifiers: GiftCardIdentifiers;
    Data: GiftCardData;
    Details: GiftCardDetails;
    IsCleared: boolean;
    IsEmpty: boolean;
    CommunicationOptions?: ProductGiftCardCommunicationOptions;
  }

  export interface GiftCardIdentifiers {
    OrderID: number;
    OrderLineID: number;
    AccessToken: string;
    GiftCardID: string;
  }

  export interface GiftCardDetails {
    GiftCardNumber: string;
    PIN: string;
    DateOfPurchase?: string;
    DateOfExpiration?: string;
  }

  /**
   * Fetch the options for a giftcard to determine the value ranges, currency etc.
   */
  export interface GetGiftCardOptions {
    /**
     * Entity type: GiftCardConfiguration
     */
    GiftCardConfigurationID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    CardNumber?: string;
    /**
     * Uses current currency if not provided
     * Entity type: Currency
     */
    CurrencyID?: string;
  }

  export interface GetGiftCardOptionsResponse {
    CardID?: string;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    BusinessRules?: GetGiftCardOptionsResponse.CardBusinessRules;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetGiftCardOptionsResponse {
    export interface CardBusinessRules {
      ActivateValues: number[];
      ActivateValueMin?: number;
      ActivateValueMax?: number;
      PurchaseValueMin?: number;
      PurchaseValueMax?: number;
      Reloadable?: boolean;
      Refundable?: boolean;
    }

  }

  /**
   * This service allows updating giftcard lines created with the `AddGiftCardToOrder` service.
   *  * `Data` will overwrite all the gift card data.
   *  * `ImageWidth` and `ImageHeight` describe the image used
   */
  export interface UpdateDigitalGiftCardOrderLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Range: 1E-06-1000000
     */
    Amount?: number;
    Data?: GiftCardData;
    GiftCardMedia?: GiftCardMedia;
  }

  /**
   * Set the external full stock count result.
   * The service accepts partial or full result lists.
   * The service requires a ActualCompletionTime. There can only be one completion time. The value will be updated with every service call.
   * 
   * CountResults must either have ProductID (preferred) or ProductBarcode.
   */
  export interface SetExternalFullStockCountResult {
    /**
     * Entity type: FullStockCount
     */
    FullStockCountID: number;
    CountCompletionTime: string;
    CountResults: SetExternalFullStockCountResult.CountResult[];
    /**
     * When this property is true, the results will processed as a partial part. Matching values will be updated, new values will be added and existing values no present in the CountResults will be left as is.
     *       When this property is false, the result will be processed as a full set. Matching values will be updated, new values will be added and existing values no present in the CountResults will be removed.
     */
    IsDeltaBatch: boolean;
  }

  export namespace SetExternalFullStockCountResult {
    export interface CountResult {
      /**
       * This optional field can be used to split te count into counted zones.
       */
      Label?: string;
      /**
       * Entity type: StockLabel
       */
      StockLabelID?: string;
      /**
       * Entity type: Product
       */
      ProductID?: number;
      ProductBarcode?: string;
      /**
       * Min: 1
       */
      CountedQuantity?: number;
    }

  }

  /**
   * Download a template format for the full stock count result to upload.
   */
  export interface DownloadExternalFullStockCountResultTemplate {
  }

  /**
   * Upload full stock count result. Previous uploads will be overwritten. The service processes the data async.
   */
  export interface UploadExternalFullStockCountResult {
    /**
     * Entity type: FullStockCount
     */
    FullStockCountID: number;
    CountCompletionTime: string;
    Data: string;
    /**
     * An email address to mail the processing result to. When left empty, the logged in user context will be used
     */
    EmailAddress?: string;
  }

  /**
   * Retrieves details of a cash correction
   */
  export interface GetCashCorrection {
    /**
     * Entity type: CashCorrection
     */
    ID: number;
  }

  export interface GetCashCorrectionResponse {
    /**
     * Entity type: CashCorrection
     */
    ID?: number;
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    /**
     * Entity type: Device
     */
    DeviceID?: number;
    Type?: CashCorrectionTypes;
    Amount?: number;
    Remark?: string;
    CreationTime?: string;
    Device?: GetCashCorrectionResponse.CorrectionDevice;
    CurrencyID?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetCashCorrectionResponse {
    export interface CorrectionDevice {
      /**
       * Entity type: Device
       */
      ID: number;
      Name: string;
      Type: FlagsEnumDto;
      Station?: GetCashCorrectionResponse.CorrectionStation;
    }

    export interface CorrectionStation {
      /**
       * Entity type: Station
       */
      ID: number;
      Name: string;
    }

  }

  export const enum CashCorrectionTypes {
    CashJournalOpening = 1,
    CashJournalClosing = 2
  }

  /**
   * Creates a cash deposit for the provided device, currency and payment type.
   * 
   * When not explicitly delaying the drop-off, it will be booked to the current active cash journal and financial period.
   */
  export interface CreateCashDeposit {
    /**
     * Entity type: Device
     */
    DeviceID?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID?: number;
    /**
     * Min: 0
     */
    TotalAmount?: number;
    Coins?: { [key: number]: number };
    BankNotes?: { [key: number]: number };
    /**
     * Required for monetary deposits
     */
    Number?: string;
    /**
     * When set to `true`, the cash deposit remains on this device awaiting manual drop-off; see `DropOffCashDeposit` service
     * @default false
     */
    DelayDropOff?: boolean;
    /**
     * Optional image of the signature
     */
    SignatureBlobID?: string;
    /**
     * Optional url of the signature image
     */
    SignatureBlobUrl?: string;
  }

  export interface CreateCashDepositResponse {
    /**
     * Entity type: CashDeposit
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Lists all cash deposits for your current financial period.
   */
  export interface ListCashDeposits {
    PageConfig?: PageConfig<ListCashDepositsFilter>;
  }

  export interface ListCashDepositsFilter {
    /**
     * Entity type: Device
     */
    DeviceID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    Statuses?: CashDepositStatus[];
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    Number?: string;
  }

  export const enum CashDepositStatus {
    Done = 0,
    Pending = -1
  }

  export interface ListCashDepositsResponse {
    Result?: PagedResult<ListCashDepositsItem>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListCashDepositsItem {
    /**
     * Entity type: CashDeposit
     */
    ID: number;
    /**
     * Entity type: Device
     */
    DeviceID: number;
    DeviceName: string;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID?: number;
    PaymentTypeName?: string;
    Number: string;
    Amount: number;
    Status: CashDepositStatus;
    Type?: CashJournalTypes;
    CreatedBy: ListCashDepositsItem.ListCashDepositsItemUser;
    DroppedOffBy?: ListCashDepositsItem.ListCashDepositsItemUser;
    Coins: { [key: number]: number };
    BankNotes: { [key: number]: number };
    CreationTime: string;
    SignatureBlobID?: string;
    SignatureBlobUrl?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
  }

  export namespace ListCashDepositsItem {
    export interface ListCashDepositsItemUser {
      /**
       * Entity type: User
       */
      ID: number;
      Name: string;
      Date: string;
    }

  }

  export const enum CashJournalTypes {
    Default = 0,
    NonMonetary = 1
  }

  /**
   * Deletes a deposit for the given `ID`.
   */
  export interface DeleteCashDeposit {
    /**
     * Entity type: CashDeposit
     */
    ID: number;
  }

  /**
   * Drops-off a cash deposit previously created and stored on a device (`CreateCashDeposit.DelayDropOff`).
   * 
   * Cash deposits created this way will remain in status Pending (`-1`) until it is either dropped-off (`DropOffCashDeposit`) or deleted (`DeleteCashDeposit`).
   */
  export interface DropOffCashDeposit {
    /**
     * Entity type: CashDeposit
     */
    ID: number;
  }

  /**
   * Service for producing a cash deposit document.
   */
  export interface ProduceCashDepositDocument {
    /**
     * Entity type: CashDeposit
     */
    ID: number;
    /**
     * Entity type: Station
     */
    StationID: number;
  }

  /**
   * Retrieves details of a cash deposit.
   */
  export interface GetCashDeposit {
    /**
     * Entity type: CashDeposit
     */
    ID?: number;
    /**
     * Get a cash deposit by number, for the current organization unit
     */
    Number?: string;
  }

  export interface GetCashDepositResponse {
    Result?: GetCashDepositResponse.CashDepositSummary;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetCashDepositResponse {
    export interface CashDepositSummary {
      /**
       * Entity type: CashDeposit
       */
      ID: number;
      /**
       * Entity type: Device
       */
      DeviceID: number;
      DeviceName: string;
      /**
       * Entity type: Currency
       */
      CurrencyID: string;
      /**
       * Entity type: PaymentType
       */
      PaymentTypeID?: number;
      PaymentTypeName?: string;
      Number: string;
      Amount: number;
      Status: CashDepositStatus;
      Type?: CashJournalTypes;
      CreatedBy: GetCashDepositResponse.CashDepositSummaryUser;
      DroppedOffBy?: GetCashDepositResponse.CashDepositSummaryUser;
      Coins: { [key: number]: number };
      BankNotes: { [key: number]: number };
      CreationTime: string;
      SignatureBlobUrl?: string;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      OrganizationUnitName: string;
    }

    export interface CashDepositSummaryUser {
      /**
       * Entity type: User
       */
      ID: number;
      Name: string;
      Date: string;
    }

  }

  /**
   * Creates a cash expense.
   * 
   * This service expects:
   * - `DeviceID`, which is the cash device the money was used from.
   * - `TypeID` which is one of the available expense types.
   * - An `Amount`, which is the amount of cash that was taken from or added to the device.
   * The amount should always be positive, but the semantics of the amount depends on the AmountType of the ExpenseType:
   * if ExpenseType.AmountType = Expense, then the amount is booked as an expense, if it's Income then it's booked as income. Either way, it should be a positive number.
   * - A `TaxCodeID`, which refers to one of the available tax codes.
   * - A `Description`, which is the reason for this expense (for example: 'lunch').
   * - A `BlobID`, which contains an image of the receipt.
   * - A `SignatureBlobID`, which contains an image of the signature
   */
  export interface CreateCashExpense {
    /**
     * Entity type: Device
     */
    DeviceID: number;
    /**
     * Entity type: CashExpenseType
     */
    TypeID: number;
    /**
     * Min: 0
     */
    Amount: number;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID: number;
    Description: string;
    /**
     * Optional image of the receipt
     */
    BlobID?: string;
    /**
     * Optional image of the signature
     */
    SignatureBlobID?: string;
  }

  /**
   * Lists all cash expenses for your current financial period.
   */
  export interface ListCashExpenses {
    PageConfig?: PageConfig<ListCashExpensesFilter>;
  }

  export interface ListCashExpensesFilter {
    DeviceID?: number;
    FinancialPeriodID?: number;
  }

  export interface ListCashExpensesResponse {
    Result?: PagedResult<ListCashExpensesItem>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListCashExpensesItem {
    /**
     * Entity type: CashExpense
     */
    ID: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    Amount: number;
    TaxCode: EnumDto;
    Type: ListCashExpensesItem.ExpenseType;
    Description: string;
    /**
     * Entity type: Blob
     */
    BlobID?: string;
    BlobUrl?: string;
    CreationTime: string;
    /**
     * Entity type: CashJournal
     */
    CashJournalID: number;
    /**
     * Entity type: CashTransactionLedger
     */
    CashTransactionLedgerID: number;
    /**
     * Entity type: Blob
     */
    SignatureBlobID?: string;
    SignatureBlobUrl: string;
    Device: ListCashExpensesItem.ExpenseDevice;
  }

  export namespace ListCashExpensesItem {
    export interface ExpenseType {
      AmountType: CashExpenseAmountTypes;
      /**
       * Entity type: Enum
       */
      ID: number;
      /**
       * Usually an internal & unchangable code - for display, use `Description`
       */
      Name: string;
      Description: string;
    }

    export interface ExpenseDevice {
      /**
       * Entity type: Device
       */
      ID: number;
      Name: string;
      Type: FlagsEnumDto;
      Station: ListCashExpensesItem.ExpenseStation;
    }

    export interface ExpenseStation {
      /**
       * Entity type: Station
       */
      ID: number;
      Name: string;
    }

  }

  export const enum CashExpenseAmountTypes {
    Expense = 0,
    Income = 1
  }

  /**
   * Deletes an expense for the given `ID`. This is only possible while the cash journal and the financial period are still open.
   */
  export interface DeleteCashExpense {
    /**
     * Entity type: CashExpense
     */
    ID: number;
  }

  /**
   * Service for producing a cash expense document
   */
  export interface ProduceCashExpenseDocument {
    /**
     * Entity type: CashExpense
     */
    ID: number;
    /**
     * Entity type: Station
     */
    StationID: number;
  }

  /**
   * Retrieves details of a cash expense
   */
  export interface GetCashExpense {
    /**
     * Entity type: CashExpense
     */
    ID: number;
  }

  export interface GetCashExpenseResponse {
    /**
     * Entity type: CashExpense
     */
    ID: number;
    /**
     * Entity type: CashJournal
     */
    CashJournalID: number;
    /**
     * Entity type: CashTransactionLedger
     */
    CashTransactionLedgerID: number;
    Amount: number;
    TaxCode: EnumDto;
    Type: GetCashExpenseResponse.ExpenseType;
    Description: string;
    BlobID?: string;
    CreationTime: string;
    SignatureBlobID?: string;
    Device: GetCashExpenseResponse.ExpenseDevice;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetCashExpenseResponse {
    export interface ExpenseType {
      AmountType: CashExpenseAmountTypes;
      /**
       * Entity type: Enum
       */
      ID: number;
      /**
       * Usually an internal & unchangable code - for display, use `Description`
       */
      Name: string;
      Description: string;
    }

    export interface ExpenseDevice {
      /**
       * Entity type: Device
       */
      ID: number;
      Name: string;
      Type: FlagsEnumDto;
      Station?: GetCashExpenseResponse.ExpenseStation;
    }

    export interface ExpenseStation {
      /**
       * Entity type: Station
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Starts the opening of a cash journal for the given DeviceID.
   * 
   * It's only possible to open a cash journal when an open financial period exists and when the device is a cash device. Retrieving a list of valid devices
   * can be accomplished through the `ListDevices` service.
   * 
   * Calling this service does not yet do anything, except return the data you need to open a cash journal:
   * 
   * - The available denominations (coins and notes)
   * - The details about the previous cash journal's closing amounts (if it exists), which can be used as an extra check
   * - Possible pending cash deposits on this device
   */
  export interface StartOpenCashJournal {
    /**
     * Entity type: Device
     */
    DeviceID: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID: number;
  }

  export interface StartOpenCashJournalResponse {
    CurrencyID: string;
    CountryID: string;
    AvailableCoins: number[];
    AvailableBankNotes: number[];
    Type: CashJournalTypes;
    PaymentType: StartOpenCashJournalResponse.PaymentTypeDto;
    PreviousCashJournal: StartOpenCashJournalResponse.CashJournal;
    PendingCashDeposits: StartOpenCashJournalResponse.PendingCashDeposit[];
    ExpectedOpeningAmount?: number;
    MinimalAllowedDeviation: number;
    MaximalAllowedDeviation: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace StartOpenCashJournalResponse {
    export interface CashJournal {
      /**
       * Entity type: CashJournal
       */
      ID: number;
      OpeningTime: string;
      ClosingTime?: string;
      OpeningAmount: number;
      ClosingAmount?: number;
    }

    export interface PaymentTypeDto {
      /**
       * Entity type: PaymentType
       */
      ID: number;
      Name: string;
      Code: string;
      CashJournalMethod: PaymentCashJournalMethod;
    }

    export interface PendingCashDeposit {
      ID: number;
      Number: string;
      Amount: number;
    }

  }

  export const enum PaymentCashJournalMethod {
    None = 0,
    Close = 1,
    OpenAndClose = 2,
    Ignore = 3
  }

  /**
   * Completes the opening of a cash journal. After this service has been called, it's possible to make cash transactions on this device.
   * 
   * This service expects a list of the coins and notes that were counted.
   * 
   * When the opening amount is different from last period's closing amount, it's required that a correction is provided for this difference
   * in `OpeningDeviationCorrection`. This simply consists of a description and an amount.
   * 
   * For cash journals that either do not use or ignore cash journals, most properties will automatically be set to the expected amounts. Should you
   * want to enforce validation, regardless, specify the `ForceValidation` as `true`.
   * 
   * Pending cash deposits need to be accounted for as well - supply their `ID`s as `PendingCashDeposits`. Do not add the `Amount` of cash deposits
   * to the `TotalAmount`, as the user cannot usually verify the cash deposit content.
   */
  export interface CompleteOpenCashJournal {
    /**
     * Entity type: Device
     */
    DeviceID: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID: number;
    Coins?: { [key: number]: number };
    BankNotes?: { [key: number]: number };
    /**
     * Min: 0
     */
    TotalAmount: number;
    OpeningDeviationCorrection?: CompleteOpenCashJournal.CashCorrection;
    /**
     * Entity type: CashDeposit
     */
    PendingCashDeposits?: number[];
    ForceValidation?: boolean;
  }

  export namespace CompleteOpenCashJournal {
    export interface CashCorrection {
      Amount: number;
      Description: string;
      /**
       * Entity type: CashCorrectionReason
       */
      ReasonID?: number;
    }

  }

  /**
   * Initiates the closing of a cash journal. This does not yet mutate anything, but returns all the details you need about a cash journal to be able to close it.
   * 
   * This consists of:
   * 
   * - The information about the device and station
   * - Which expenses and deposits were made from this device.
   * - What payments were made.
   * - What the `ExpectedClosingAmount` is, which is a summary of the previous journal's closing amount plus all transactions.
   * - Possible pending cash deposits on this device
   */
  export interface StartCloseCashJournal {
    /**
     * Entity type: Device
     */
    DeviceID: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID: number;
  }

  export interface StartCloseCashJournalResponse {
    CashJournalDetails: CashJournalDetailsModel;
    PendingCashDeposits: StartCloseCashJournalResponse.PendingCashDeposit[];
    ExpectedClosingAmount: number;
    MinimalAllowedDeviation: number;
    MaximalAllowedDeviation: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace StartCloseCashJournalResponse {
    export interface PendingCashDeposit {
      /**
       * Entity type: CashDeposit
       */
      ID: number;
      Number: string;
      Amount: number;
    }

  }

  export interface CashJournalDetailsModel {
    ID: number;
    OpeningAmount: number;
    ExpectedClosingAmount: number;
    OpeningDeviation?: number;
    OpeningTime: string;
    ClosingTime?: string;
    ClosingAmount?: number;
    Device: CashJournalDetailsModel.CashDevice;
    Type: CashJournalTypes;
    PaymentType: CashJournalDetailsModel.PaymentTypeDto;
    CurrencyID: string;
    CashTransactions: CashJournalDetailsModel.CashTransactionLedger[];
    Expenses: CashJournalDetailsModel.CashExpense[];
    Deposits: CashJournalDetailsModel.CashDeposit[];
    Corrections: CashJournalDetailsModel.CashCorrection[];
    OpeningDenominations: CashJournalDetailsModel.CashDenominations;
    ClosingDenominations: CashJournalDetailsModel.CashDenominations;
    OpenCashJournalsCount: number;
  }

  export namespace CashJournalDetailsModel {
    export interface CashDevice {
      /**
       * Entity type: Device
       */
      ID: number;
      Name: string;
      Type: FlagsEnumDto;
      Station: CashJournalDetailsModel.Station;
    }

    export interface PaymentTypeDto {
      /**
       * Entity type: PaymentType
       */
      ID: number;
      Name: string;
      Code: string;
      CashJournalMethod: PaymentCashJournalMethod;
    }

    export interface Station {
      /**
       * Entity type: Station
       */
      ID: number;
      Name: string;
    }

    export interface CashDeposit {
      ID: number;
      Amount: number;
      Number: string;
      CashTransactionLedger: CashJournalDetailsModel.CashTransactionLedger;
    }

    export interface CashCorrection {
      ID: number;
      Type: CashCorrectionTypes;
      Amount: number;
      Remark: string;
      CashTransactionLedger: CashJournalDetailsModel.CashTransactionLedger;
    }

    export interface CashExpense {
      ID: number;
      Amount: number;
      TaxCode: EnumDto;
      Description: string;
      CreationTime: string;
      BlobID?: string;
    }

    export interface CashTransactionLedger {
      ID: number;
      Description: string;
      Amount: number;
      CreationTime: string;
      Type: CashTransactionLedgerTypes;
      Denominations: CashJournalDetailsModel.CashDenominations;
    }

    export interface CashDenominations {
      Coins: { [key: number]: number };
      BankNotes: { [key: number]: number };
    }

  }

  export const enum CashTransactionLedgerTypes {
    MoveFrom = 0,
    MoveTo = 1,
    Deposit = 2,
    Correction = 3,
    Expense = 4,
    AmountGiven = 5,
    Change = 6,
    DepositPending = 7,
    DepositDeleted = 8,
    DepositCounted = 9
  }

  /**
   * Completes the closing of a cash journal, making the device once again unavailable for cash transactions until a new journal is opened.
   * 
   * This service expects a list of coins and notes, which summed up must equal the given `TotalAmount`.
   * 
   * If the `TotalAmount` is different from what was expected (returned as `ExpectedClosingAmount` in `StartCloseCashJournal` ) then this deviation
   * must be corrected and provided through a list of corrections in the `Corrections` field.
   * 
   * For cash journals that either do not use or ignore cash journals, most properties will automatically be set to the expected amounts. Should you
   * want to enforce validation, regardless, specify the `ForceValidation` as `true`.
   * 
   * Pending cash deposits need to be accounted for as well - supply their `ID`s as `PendingCashDeposits`. Do not add the `Amount` of cash deposits
   * to the `TotalAmount`, as the user cannot usually verify the cash deposit content.
   */
  export interface CompleteCloseCashJournal {
    /**
     * Entity type: Device
     */
    DeviceID: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID: number;
    Coins?: { [key: number]: number };
    BankNotes?: { [key: number]: number };
    /**
     * Min: 0
     */
    TotalAmount: number;
    Corrections?: CompleteCloseCashJournal.CashCorrection[];
    Data?: { [key: string]: any };
    /**
     * Entity type: CashDeposit
     */
    PendingCashDeposits?: number[];
    ForceValidation?: boolean;
  }

  export namespace CompleteCloseCashJournal {
    export interface CashCorrection {
      Amount: number;
      Description?: string;
      /**
       * Entity type: CashCorrectionReason
       */
      ReasonID?: number;
    }

  }

  /**
   * Gets the currency and a list of available coins and notes for the provided `DeviceID`.
   */
  export interface GetCashJournalDenominations {
    /**
     * Entity type: Device
     */
    DeviceID: number;
  }

  export interface GetCashJournalDenominationsResponse {
    CashJournalDenominations: GetCashJournalDenominationsResponse.CashJournalDenomination[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetCashJournalDenominationsResponse {
    export interface CashJournalDenomination {
      CurrencyID: string;
      AvailableCoins: number[];
      AvailableBankNotes: number[];
    }

  }

  /**
   * Returns information about the current cash journals for the given DeviceID.
   */
  export interface GetCurrentCashJournals {
    /**
     * Entity type: Device
     */
    DeviceID: number;
  }

  export interface GetCurrentCashJournalsResponse {
    CashJournals: GetCurrentCashJournalsResponse.CashJournal[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetCurrentCashJournalsResponse {
    export interface CashJournal {
      /**
       * Entity type: CashJournal
       */
      ID?: number;
      OpeningTime?: string;
      OpeningAmount?: number;
      Type: CashJournalTypes;
      CurrencyID: string;
      PaymentType: GetCurrentCashJournalsResponse.PaymentTypeDto;
      PreviousCashJournal?: GetCurrentCashJournalsResponse.PreviousCashJournal;
      /**
       * Entity type: Device
       */
      DeviceID: number;
      ExpectedClosingAmount?: number;
      PendingCashDeposits: GetCurrentCashJournalsResponse.PendingCashDeposit[];
    }

    export interface PreviousCashJournal {
      /**
       * Entity type: CashJournal
       */
      ID: number;
      OpeningTime: string;
      ClosingTime?: string;
      OpeningAmount: number;
      ClosingAmount?: number;
    }

    export interface PaymentTypeDto {
      /**
       * Entity type: PaymentType
       */
      ID: number;
      Name: string;
      Code: string;
      CashJournalMethod: PaymentCashJournalMethod;
    }

    export interface PendingCashDeposit {
      /**
       * Entity type: CashDeposit
       */
      ID: number;
      Number: string;
      Amount: number;
    }

  }

  /**
   * Retrieves details of a cash movement
   */
  export interface GetCashMovement {
    /**
     * Entity type: CashMovement
     */
    ID: number;
  }

  export interface GetCashMovementResponse {
    /**
     * Entity type: CashMovement
     */
    ID: number;
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID?: number;
    /**
     * Entity type: Device
     */
    SourceDeviceID: number;
    /**
     * Entity type: Device
     */
    DestinationDeviceID: number;
    CurrencyID?: string;
    Amount: number;
    SourceDevice: GetCashMovementResponse.MovementDevice;
    DestinationDevice: GetCashMovementResponse.MovementDevice;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetCashMovementResponse {
    export interface MovementDevice {
      /**
       * Entity type: Device
       */
      ID: number;
      Name: string;
      Type: FlagsEnumDto;
      Station?: GetCashMovementResponse.MovementStation;
    }

    export interface MovementStation {
      /**
       * Entity type: Station
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Moves cash!
   */
  export interface MoveCash {
    /**
     * Entity type: Device
     */
    SourceDeviceID?: number;
    /**
     * Entity type: Device
     */
    DestinationDeviceID?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID?: number;
    Coins?: { [key: number]: number };
    BankNotes?: { [key: number]: number };
    /**
     * Instead of supplying Coins or BankNotes, supply directly the total.
     */
    Total?: number;
  }

  /**
   * Download Financial Period Deposit
   */
  export interface DownloadFinancialPeriodDeposit {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
  }

  /**
   * Returns all cash expenses that are available for your current OrganizationUnit, or available to the provided OrganizationUnitID (optional).
   */
  export interface GetCashExpenseTypes {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export interface GetCashExpenseTypesResponse {
    CashExpenseTypes: GetCashExpenseTypesResponse.CashExpenseTypeDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetCashExpenseTypesResponse {
    export interface CashExpenseTypeDto {
      /**
       * Entity type: CashExpenseType
       */
      ID: number;
      BackendID?: string;
      Name: string;
      Description?: string;
      LedgerClassID?: string;
      /**
       * Entity type: DeviceType
       */
      DeviceTypeID?: number;
      DeviceType?: FlagsEnumDto;
      AmountType: CashExpenseAmountTypes;
      /**
       * Entity type: TaxCode
       */
      TaxCodeID?: number;
      TaxCodeName?: string;
      OrganizationUnitSet?: CashExpenseTypeDto.CashExpenseTypeOrganizationUnitSet;
    }

    export namespace CashExpenseTypeDto {
      export interface CashExpenseTypeOrganizationUnitSet {
        /**
         * Entity type: OrganizationUnitSet
         */
        ID: number;
        Name: string;
      }

    }

  }

  /**
   * Get financial period export documents
   */
  export interface GetFinancialPeriodExportDocuments {
    /**
     * Entity type: FinancialPeriodExport
     */
    ID: number;
  }

  export interface GetFinancialPeriodExportDocumentsResponse {
    RequestDocuments: TransputJobDocument[];
    ResponseDocuments: TransputJobDocument[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Retry financial period export. Use `Force` to retry eventhough the status is `Finished`
   */
  export interface RetryFinancialPeriodExport {
    /**
     * Entity type: FinancialPeriodExport
     */
    ID: number;
    Force?: boolean;
  }

  /**
   * Opens a financial period for your current OrganizationUnit.
   */
  export interface OpenFinancialPeriod {
    /**
     * If there is an impediment to opening the period and it allows being ignored then passing the name of the impediment type in this collection will not block opening the period on that impediment. Also see `GetFinancialPeriodOpeningImpediments`.
     */
    OpeningImpedimentTypesToIgnore?: string[];
  }

  /**
   * Closes the financial period for your current OrganizationUnit.
   */
  export interface CloseFinancialPeriod {
    /**
     * If there is an impediment to closing the period and it allows being ignored then passing the name of the impediment type in this collection will not block closing the period on that impediment. Also see `GetFinancialPeriodClosingImpediments`.
     */
    ClosingImpedimentTypesToIgnore?: string[];
  }

  /**
   * Set the answer to the PCI question for the provided `FinancialPeriodID`.
   */
  export interface SetPCIQuestionAnswerForFinancialPeriod {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
    Answer: boolean;
  }

  /**
   * Set the employees for the financial period. This only works for pending financial periods.
   */
  export interface SetEmployeesForFinancialPeriod {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
    /**
     * The employees to set for the financial period. Can be left empty to remove all employees.
     */
    Employees?: SetEmployeesForFinancialPeriod.FinancialPeriodEmployee[];
  }

  export namespace SetEmployeesForFinancialPeriod {
    export interface FinancialPeriodEmployee {
      /**
       * Entity type: User
       */
      UserID: number;
      /**
       * Share of the commission fo this financial period. Either provide this for all employees or for none. It must of course add up to 1
       * Range: 0-1
       */
      CommissionShare?: number;
    }

  }

  /**
   * Set the loyalty program for the financial period. This only works for pending financial periods.
   */
  export interface SetLoyaltyProgramForFinancialPeriod {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
    /**
     * The loyalty program to set for the financial period. Can be left empty to remove the loyalty program.
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
  }

  /**
   * Gets a detailed overview of the provided `FinancialPeriodID`. If no `FinancialPeriodID` is provided, the current period for your user is used.
   */
  export interface GetFinancialPeriodInformation {
    /**
     * If left null, defaults to the current period of the logged in user.
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
  }

  export interface GetFinancialPeriodInformationResponse {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
    Status: FinancialPeriodStatus;
    OrganizationUnit: GetFinancialPeriodInformationResponse.FinancialPeriodOrganizationUnit;
    TotalRevenue: number;
    CreationTime: string;
    ExpectedClosingTime?: string;
    ShouldHaveBeenClosed: boolean;
    PCIQuestionAnswer?: boolean;
    CashJournals: CashJournalDetailsModel[];
    PaymentTypeSummaries: GetFinancialPeriodInformationResponse.PaymentTypeSummary[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetFinancialPeriodInformationResponse {
    export interface FinancialPeriodOrganizationUnit {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
    }

    export interface PaymentTypeSummary {
      Type: GetFinancialPeriodInformationResponse.PaymentType;
      TotalPaidAmount: number;
    }

    export interface PaymentType {
      /**
       * Entity type: PaymentType
       */
      ID: number;
      Name: string;
    }

  }

  export const enum FinancialPeriodStatus {
    Open = 0,
    Closing = 1,
    Closed = 2,
    Processed = 3,
    Pending = -1
  }

  /**
   * Gets a list of reasons (if any) why this period cannot be opened yet.
   * 
   * The current possible reasons are (which is available in the `Type` property of each item):
   * 
   * ## LINKED_EMPLOYEES
   * 
   * Employees should be linked to this financial periods (with an optional commission share).
   * 
   * ### Data
   * 
   * No Data.
   * 
   * ## LOYALTY_PROGRAM
   * 
   * A loyalty program should be linked to this financial period.
   * 
   * ### Data
   * 
   * No Data.
   * 
   * ## MOBILE_ORGANIZATION_UNIT_LOCATION
   * 
   * This organization unit should get an updated location before starting this financial period.
   * 
   * ### Data
   * 
   * No Data.
   */
  export interface GetFinancialPeriodOpeningImpediments {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
  }

  export interface GetFinancialPeriodOpeningImpedimentsResponse {
    Impediments: FinancialPeriodImpediment[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface FinancialPeriodImpediment {
    Type: string;
    Description: string;
    AllowIgnore: boolean;
    Data: { [key: string]: any };
  }

  /**
   * Gets a list of reasons (if any) why this period cannot be closed yet.
   * 
   * The current possible reasons are (which is available in the `Type` property of each item):
   * 
   * ## CLOCKED_IN_USER
   * 
   * The user is still clocked in and must be clocked out.
   * 
   * ### Data
   * 
   * The `Data` property will contain:
   * 
   * ```json
   * {
   *   "UserID" : 1,
   *   "ClockedIn" : "2018-08-01 12:00",
   *   "FirstName" : "John",
   *   "LastName"  : "Doe"
   * }
   * ```
   * 
   * ## ACTIVE_USER_TASK
   * 
   * The user task hasn't been completed yet and it's either attached to this financial period, or its past its deadline.
   * 
   * ### Data
   * 
   * The `Data` property will contain:
   * 
   * ```json
   * {
   * 	"UserTaskID" : 5546,
   * 	"UserTaskTypeID" : 9,
   * 	"UserID" : null,
   * 	"UserFullName" : null,
   * 	"IsActive" : true,
   * 	"IsCompleted" : false,
   * 	"Deadline" : null,
   * 	"CreationTime" : "2018-08-01"
   * }
   * ```
   * 
   * ## OPEN_CASH_JOURNAL
   * 
   * There is still an open cash journal that needs to be closed before the period can be closed.
   * 
   * ### Data
   * 
   * The `Data` property will contain:
   * 
   * ```json
   * {
   * "CashJournalID" : 3,
   * "DeviceID" : 1,
   * "OpeningAmount" : 150.15
   * }
   * ```
   * 
   * ## PCI_QUESTION
   * 
   * The PCI compliancy question has not been answered yet, this is required to close the period if the OrganizationUnit has been configured to require it.
   * 
   * ### Data
   * 
   * No Data.
   * 
   * ## NEGATIVE_STOCK
   * 
   * There is negative stock that must be corrected (to at least zero) before the period can be closed.
   * 
   * ### Data
   * 
   * The `Data` property will contain:
   * 
   * ```json
   * {
   *   "ProductID" : 7684,
   *   "ProductBackendID" : "ABC123",
   *   "QuantityOnHand" : -10,
   *   "StockLabelID" : 1,
   *   "StockLabelName" : "Sellable",
   *   "OrganizationUnitID" : 182
   * }
   * ```
   * 
   * This data can then be used to correct the stock through AdjustStock/MoveStock.
   */
  export interface GetFinancialPeriodClosingImpediments {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
  }

  export interface GetFinancialPeriodClosingImpedimentsResponse {
    Impediments: FinancialPeriodImpediment[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Gets information regarding financial period stock
   */
  export interface GetFinancialPeriodClosingStockInformation {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
  }

  export interface GetFinancialPeriodClosingStockInformationResponse {
    PendingShipmentLines: GetFinancialPeriodClosingStockInformationResponse.PendingShipmentLine[];
    CurrentStock: GetFinancialPeriodClosingStockInformationResponse.CurrentStockForLabel[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetFinancialPeriodClosingStockInformationResponse {
    export interface CurrentStockForLabel {
      /**
       * Entity type: StockLabel
       */
      StockLabelID: number;
      StockLabelName: string;
      QuantityOnHand: number;
    }

    export interface PendingShipmentLine {
      /**
       * Entity type: Shipment
       */
      ShipmentID: number;
      ShipmentBackendID: string;
      TrackingCode: string;
      TrackingLink: string;
      /**
       * Entity type: ShipmentLine
       */
      ShipmentLineID: number;
      QuantityShipped: number;
      QuantityDelivered: number;
      /**
       * Entity type: Product
       */
      ProductID: number;
      ReceiveShipmentUserTaskID?: number;
    }

  }

  /**
   * Get status summary for the devices of a FinancialPeriod
   */
  export interface GetFinancialPeriodCashJournalDeviceSummary {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
  }

  export interface GetFinancialPeriodCashJournalDeviceSummaryResponse {
    Devices: GetFinancialPeriodCashJournalDeviceSummaryResponse.DeviceSummary[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetFinancialPeriodCashJournalDeviceSummaryResponse {
    export interface DeviceSummary {
      /**
       * Entity type: Device
       */
      ID: number;
      DeviceName: string;
      StationName?: string;
      DeviceType: FlagsEnumDto;
      Status: DeviceStatus;
    }

  }

  export const enum DeviceStatus {
    Unknown = 0,
    Open = 1,
    Opening = 2,
    Closed = 3,
    Missing = 4
  }

  /**
   * Retrieves the current available cash amount of given device, to be able to e.g. validate user given amounts in `CreateCashDeposit` or `CreateCashExpense` services.
   * 
   * Supply a `CurrencyID` and `PaymentTypeID` to indicate the Cash Journal to be used.
   */
  export interface GetAvailableCashAmountForDevice {
    /**
     * Entity type: Device
     */
    DeviceID: number;
    /**
     * The currency to get the available cash amount for.
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * The payment type to get the available cash amount for.
     * Entity type: PaymentType
     */
    PaymentTypeID: number;
  }

  export interface GetAvailableCashAmountForDeviceResponse {
    Amount: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    ValidateSafeBalance: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Returns a summary of the current financial period of the organization unit that the user is currently logged on to. The
   * result of this service can be used to retrieve more details of the financial period via the
   * `GetFinancialPeriodDetails` service.
   */
  export interface GetCurrentFinancialPeriodSummary {
  }

  export interface GetCurrentFinancialPeriodSummaryResponse {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
    FinancialPeriodStatus: FinancialPeriodStatus;
    ShouldHaveBeenClosed: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get Financial Period Accounts Summary
   */
  export interface GetFinancialPeriodAccountsSummary {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
  }

  export interface GetFinancialPeriodAccountsSummaryResponse {
    Accounts: AccountSummary[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface AccountSummary {
    /**
     * Entity type: Account
     */
    AccountID: number;
    Name: string;
    Amount: number;
    ObjectAccount: string;
    Subsidiary: string;
  }

  /**
   * Returns a `FinancialPeriodDetailsDto` that contains details about the given financial period (`FinancialPeriodID`).
   */
  export interface GetFinancialPeriodDetails {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
  }

  export interface GetFinancialPeriodDetailsResponse {
    Details: FinancialPeriodDetailsDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface FinancialPeriodDetailsDto {
    /**
     * Entity type: FinancialPeriod
     */
    PreviousPeriodID?: number;
    OpeningTime?: string;
    ClosingTime?: string;
    Status: FinancialPeriodStatus;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    CashDeposits: CashDepositDto[];
    CashJournals: CashJournalDto[];
    PreviousCashJournal: CashJournalDto;
    Expenses: ExpenseDto[];
    CashCorrections: CashCorrectionDto[];
    PaymentTotalPerTypes: PaymentTotalPerPaymentTypeDto[];
    ExtendedStations: ExtendedStation[];
    Devices: DeviceWithCashJournals[];
    LoyaltyProgram?: LoyaltyProgramDetails;
    Employees: LinkedEmployee[];
    AmountOfRoundingDifference: number;
    AmountOfOpeningDifference: number;
    AmountOfCashDifference: number;
    TotalDepositedAmounts: CurrencyTotalAmount[];
    TotalAmountOfExpenses: number;
    TotalAmountOfCorrections: number;
    TotalRevenue: number;
    TotalOrderAmountInTax: number;
    TotalOrderAmount: number;
    TotalReturnAmountInTax: number;
    TotalReturnAmount: number;
    TotalPaidOrders: number;
    TotalReturnedOrders: number;
    TotalSoldProducts: number;
    TotalReturnedProducts: number;
    TotalNonSystemPayments: number;
    TotalSystemPayments: number;
    PCIQuestionAnswer?: boolean;
    /**
     * ID of the user who closed the period
     */
    UserID?: number;
    /**
     * Full name of the user who closed the period
     */
    UserFullName?: string;
    /**
     * ID of the user who opened the period
     */
    OpenedByUserID?: number;
    /**
     * Full name of the user who opened the period
     */
    OpenedByUserFullName?: string;
  }

  export interface CashDepositDto {
    Number: string;
    Description: string;
    Total: number;
    Lines: CashDepositLineDto[];
    ID: number;
    CashJournalID: number;
  }

  export interface CashDepositLineDto {
    Currency: number;
    Quantity: number;
  }

  export interface CashJournalDto {
    OpeningAmount: number;
    ClosingAmount?: number;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    CreatedByFullName: string;
    Type: CashJournalTypes;
    /**
     * Entity type: CashJournal
     */
    ID: number;
    /**
     * Entity type: Station
     */
    StationID?: number;
    /**
     * Entity type: Device
     */
    DeviceID: number;
    DeviceName: string;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID: number;
    OpeningTime: string;
    ClosingTime?: string;
    OpeningDeviation?: number;
    ClosingDeviation?: number;
    PaymentType: CashJournalPaymentType;
    PreviousCashJournal?: PreviousCashJournal;
    OpeningCashDeposits: PendingCashDeposit[];
    ClosingCashDeposits: PendingCashDeposit[];
  }

  export interface CashJournalPaymentType {
    ID: number;
    Name: string;
    Code: string;
    CashJournalMethod: PaymentCashJournalMethod;
  }

  export interface PreviousCashJournal {
    ID: number;
    OpeningTime: string;
    ClosingTime?: string;
    OpeningAmount: number;
    ClosingAmount?: number;
  }

  export interface PendingCashDeposit {
    /**
     * Entity type: CashDeposit
     */
    ID?: number;
    Number?: string;
    Amount?: number;
  }

  export interface ExpenseDto {
    /**
     * Entity type: CashExpense
     */
    ID: number;
    /**
     * Entity type: CashExpenseType
     */
    TypeID: number;
    TypeDescription: string;
    TaxRate: number;
    Amount: number;
    Description: string;
    CreationTime: string;
    BlobID?: string;
    AmountType: CashExpenseAmountTypes;
    /**
     * Entity type: CashJournal
     */
    CashJournalID: number;
  }

  export interface CashCorrectionDto {
    /**
     * Entity type: CashCorrection
     */
    ID: number;
    Type: CashCorrectionTypes;
    Amount: number;
    Remark: string;
    CreationTime: string;
    /**
     * Entity type: CashJournal
     */
    CashJournalID: number;
    /**
     * Entity type: Station
     */
    StationID?: number;
    StationName?: string;
    /**
     * Entity type: Device
     */
    DeviceID: number;
    DeviceName: string;
    /**
     * Entity type: DeviceType
     */
    DeviceTypeID: number;
    DeviceTypeName: string;
  }

  export interface PaymentTotalPerPaymentTypeDto {
    Total: number;
    IsSystem: boolean;
    TypeName: string;
  }

  export interface StationClosing {
    /**
     * Entity type: Station
     */
    StationID?: number;
    InitialAmount: number;
    Name: string;
    Type: LegacyCashJournalTypes;
    TypeName: string;
    ClosingAmount: number;
  }

  export const enum LegacyCashJournalTypes {
    Register = 0,
    Safe = 1
  }

  export interface ExtendedStation {
    /**
     * Entity type: Station
     */
    ID: number;
    Name: string;
    BackendID: string;
    CashJournals: CashJournalDto[];
    FirstOpeningAmount?: number;
    LastClosingAmount?: number;
  }

  export interface DeviceWithCashJournals {
    /**
     * Entity type: Device
     */
    ID: number;
    DeviceName: string;
    DeviceTypeID: number;
    DeviceTypeName: string;
    /**
     * Entity type: Station
     */
    StationID?: number;
    StationName?: string;
    CashJournals: CashJournalDto[];
    Status: DeviceStatus;
  }

  export interface LoyaltyProgramDetails {
    /**
     * Entity type: LoyaltyProgram
     */
    ID: number;
    Name: string;
  }

  export interface LinkedEmployee {
    /**
     * Entity type: User
     */
    ID: number;
    CommissionShare?: number;
  }

  export interface CurrencyTotalAmount {
    Currency: string;
    TotalAmount: number;
  }

  export interface GeneralLedgerDto {
    ID: number;
    OrganizationUnitID: number;
    OrganizationUnit: OrganizationUnitDto;
    Amount: number;
    Remark: string;
    PaymentTransactionID?: number;
    PaymentTransaction: PaymentTransactionDto;
    CreationTime: string;
    OrderID?: number;
    AccountName: string;
    AccountObjectAccount: string;
    AccountingID: number;
    StockMutationID?: number;
    StockMutation: StockMutationDto;
    CurrencyID: string;
  }

  /**
   * Lists all of the bookings that've been made for the given financial period. Which you can retrieve
   * by setting the filter `FinancialPeriodID` on the `PageConfig`.
   */
  export interface ListBookings {
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListBookingsResponse {
    Result?: PagedResult<GeneralLedgerDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * This service allows you to view the cash transaction ledger, which underlies all cash transactions,
   * such as received payments, moves between devices, deposits and expenses.
   * 
   * By default this service will filter on your current organization unit's active financial period, unless `Security:UseContextIndependentFunctionalityChecksAndFiltering` is enabled.
   */
  export interface ListCashTransactionLedger {
    PageConfig?: PageConfig<ListCashTransactionLedgerFilter>;
  }

  export interface ListCashTransactionLedgerFilter {
    /**
     * Entity type: CashJournal
     */
    CashJournalID?: number;
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodIDs?: number[];
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    /**
     * Entity type: Device
     */
    DeviceID?: number;
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID?: number;
    /**
     * Entity type: CashDeposit
     */
    CashDepositID?: number;
    Types?: CashTransactionLedgerTypes[];
    CashDepositNumber?: string;
    FromDate?: string;
    ToDate?: string;
  }

  export interface ListCashTransactionLedgerResponse {
    Result?: PagedResult<ListCashTransactionLedgerItem>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListCashTransactionLedgerItem {
    ID: number;
    Amount: number;
    DeviceName: string;
    DeviceTypeID: number;
    StationName: string;
    Description: string;
    Type: CashTransactionLedgerTypes;
    CreationTime: string;
    GroupID?: string;
    CurrencyID: string;
    PaymentTypeID: number;
    PaymentTypeName: string;
    CreatedByID: number;
    CreatedByFullName: string;
    CashDepositID?: number;
    CashDepositNumber?: string;
    Details: string;
    Coins: { [key: number]: number };
    BankNotes: { [key: number]: number };
  }

  /**
   * This service allows you to get a grouped view of the cash transaction ledger, which underlies all cash
   * transactions, such as received payments, moves between devices, deposits and expenses.
   * 
   * By default this service will filter on your current organization unit's active financial period, unless `Security:UseContextIndependentFunctionalityChecksAndFiltering` is enabled.
   */
  export interface ListCashTransactionLedgerGroups {
    PageConfig?: PageConfig<ListCashTransactionLedgerFilter>;
  }

  export interface ListCashTransactionLedgerGroupsResponse {
    Result?: PagedResult<ListCashTransactionLedgerGroup>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListCashTransactionLedgerGroup {
    ID: string;
    Items: ListCashTransactionLedgerItem[];
  }

  /**
   * List financial events.
   */
  export interface ListFinancialEvents {
    InitialPageConfig?: PageTokenConfig<ListFinancialEventsFilter>;
    PageToken?: string;
  }

  export interface ListFinancialEventsFilter {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: Order
     */
    OrderIDs?: number[];
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    FromDate?: string;
    ToDate?: string;
    Type?: FinancialEventTypes;
    StatusID?: number;
  }

  export interface ListFinancialEventsResponse {
    Results?: ListFinancialEventRow[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListFinancialEventRow {
    /**
     * Entity type: FinancialEvent
     */
    ID: number;
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: StockMutation
     */
    StockMutationID?: number;
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID?: number;
    OrganizationUnitName: string;
    TypeID: number;
    CurrencyID: string;
    Amount: number;
    Remark: string;
    StatusID: number;
    OrderDisplayID?: string;
    ProcessingError: string;
    TaxRate?: number;
    TaxAmount?: number;
    ExchangeRate?: number;
    TaxRateCategory?: TaxRateCategory;
    Type: FinancialEventTypes;
    Status: FinancialEventStatuses;
  }

  export const enum FinancialEventStatuses {
    Unprocessed = 0,
    Processed = 1,
    Ignored = 2,
    NoProcessingRequired = 3,
    NoMatchingRecipe = 4
  }

  /**
   * List financial period exports
   */
  export interface ListFinancialPeriodExports2 {
    PageConfig?: PageConfig<ListFinancialPeriodExports2Filter>;
  }

  export interface ListFinancialPeriodExports2Filter {
    /**
     * Entity type: FinancialPeriodExport
     */
    ID?: number;
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    Status?: TransputJobStatuses;
    Name?: string;
    From?: string;
    To?: string;
  }

  export interface ListFinancialPeriodExports2Response {
    Result?: PagedResult<ListFinancialPeriodExports2Response.FinancialPeriodExport>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListFinancialPeriodExports2Response {
    export interface FinancialPeriodExport {
      /**
       * Entity type: FinancialPeriodExport
       */
      ID: number;
      Name: string;
      Trigger: FinancialPeriodExportTrigger;
      Status: TransputJobStatuses;
      CreationTime: string;
      LastModificationTime?: string;
      /**
       * Entity type: FinancialPeriod
       */
      FinancialPeriodID: number;
    }

  }

  export const enum FinancialPeriodExportTrigger {
    PeriodOpened = 0,
    PeriodClosed = 1,
    CashJournalOpened = 2,
    CashJournalClosed = 3,
    CashDeposit = 4,
    CashExpense = 5,
    CashMovement = 6,
    Difference = 7
  }

  /**
   * List financialperiods for an OrganizationUnit
   */
  export interface ListFinancialPeriods {
    PageConfig?: PageConfig<ListFinancialPeriodsFilter>;
  }

  export interface ListFinancialPeriodsFilter {
    IDs?: number[];
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    OpeningTimeFrom?: string;
    OpeningTimeTo?: string;
    ClosingTimeFrom?: string;
    ClosingTimeTo?: string;
    /**
     * Filter on the FinancialPeriodStatuses
     */
    Status?: FinancialPeriodStatus[];
  }

  export interface ListFinancialPeriodsResponse {
    Result?: PagedResult<FinancialPeriodDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface FinancialPeriodDto {
    /**
     * Entity type: FinancialPeriod
     */
    ID: number;
    OpeningTime?: string;
    ClosingTime?: string;
    Status: FinancialPeriodStatus;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    UserFullName?: string;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * Entity type: Currency
     */
    CostPriceCurrencyID: string;
    /**
     * Entity type: User
     */
    OpenedByUserID?: number;
    OpenedByUserFullName?: string;
  }

  /**
   * Returns a paged view of all the general ledgers.
   * 
   * The page size `Limit` has a maximum value of `1.000` for this service.
   */
  export interface ListGeneralLedgers {
    InitialPageConfig?: PageTokenConfig<ListGeneralLedgersFilter>;
    PageToken?: string;
  }

  export interface ListGeneralLedgersFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * The organization units to list the invoices for, will be ignored if `OrganizationUnitSetID` is specified
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: Account
     */
    AccountID?: number;
    IsProcessed?: boolean;
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
    CreationTime?: string;
    FromDate?: string;
    ToDate?: string;
    ObjectAccount?: string;
    Amount?: number;
  }

  export interface ListGeneralLedgersResponse {
    Result: PagedResult<ListGeneralLedgersResponse.GeneralLedger>;
    Results?: ListGeneralLedgersResponse.GeneralLedger[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListGeneralLedgersResponse {
    export interface GeneralLedger {
      AccountName: string;
      AccountObjectAccount: string;
      Amount: number;
      CreationTime: string;
      CurrencyID: string;
      /**
       * Entity type: FinancialEvent
       */
      FinancialEventID?: number;
      /**
       * Entity type: FinancialPeriod
       */
      FinancialPeriodID: number;
      /**
       * Entity type: GeneralLedger
       */
      ID: number;
      Offset1: string;
      Offset2: string;
      Offset3: string;
      Offset4: string;
      Offset5: string;
      Offset6: string;
      Offset7: string;
      Offset8: string;
      Offset9: string;
      /**
       * Entity type: Order
       */
      OrderID?: number;
      OrderDisplayID?: string;
      OrganizationUnit: ListGeneralLedgersResponse.OrganizationUnit;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      /**
       * Entity type: PaymentTransaction
       */
      PaymentTransactionID?: number;
      Remark: string;
      /**
       * Entity type: StockMutation
       */
      StockMutationID?: number;
    }

    export interface OrganizationUnit {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Get the estimated amount of unprocessed financial events.
   */
  export interface GetUnprocessedFinancialEventsCount {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    Filter?: ListFinancialEventsFilter;
  }

  export interface GetUnprocessedFinancialEventsCountResponse {
    Count: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Process unprocessed financial events.
   */
  export interface ProcessUnprocessedFinancialEvents {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    Filter?: ListFinancialEventsFilter;
  }

  /**
   * Repost Financial Period
   */
  export interface RepostFinancialPeriod {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
  }

  /**
   * This service resets processed financial events back to unprocessed,
   * which means all associated financial ledgers are deleted.
   * 
   * Only financial events of periods that have not been fully processed (for example exported to an external ERP system)
   * can be reset.
   * 
   * As this can be a time consuming service, the request is handled in the background and upon completion a mail
   * is sent to the caller of this service with the results.
   * 
   * The scope of which events to reset can be limited by specifying a `Filter` in the request. Only the events
   * that match the filter will be reset.
   */
  export interface ResetFinancialEvents {
    Filter?: ListFinancialEventsFilter;
  }

  /**
   * Retry export of financial period general ledgers.
   */
  export interface RetryExportFinancialPeriodGeneralLedgers {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
  }

  /**
   * Retry financial period exports.
   */
  export interface RetryFinancialPeriodExports {
    ToRetry?: RetryFinancialPeriodExports.FinancialPeriodExportToRetry[];
  }

  export namespace RetryFinancialPeriodExports {
    export interface FinancialPeriodExportToRetry {
      /**
       * Entity type: FinancialPeriodExport
       */
      ID: number;
      Force?: boolean;
    }

  }

  /**
   * Create a cash correction reason
   */
  export interface CreateCashCorrectionReason {
    Name: string;
    BackendID?: string;
    Sequence: number;
  }

  export interface CreateCashCorrectionReasonResponse {
    /**
     * Entity type: CashCorrectionReason
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Delete a cash correction reason
   */
  export interface DeleteCashCorrectionReason {
    /**
     * Entity type: CashCorrectionReason
     */
    ID: number;
  }

  /**
   * Get cash correction reason by it's ID
   */
  export interface GetCashCorrectionReason {
    /**
     * Entity type: CashCorrectionReason
     */
    ID: number;
  }

  export interface GetCashCorrectionReasonResponse {
    /**
     * Entity type: CashCorrectionReason
     */
    ID: number;
    Name: string;
    TranslatedName: string;
    BackendID?: string;
    Sequence: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get all cash correction reasons
   */
  export interface GetCashCorrectionReasons {
  }

  export interface GetCashCorrectionReasonsResponse {
    Reasons: GetCashCorrectionReasonsResponse.CashCorrectionReasonData[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetCashCorrectionReasonsResponse {
    export interface CashCorrectionReasonData {
      /**
       * Entity type: CashCorrectionReason
       */
      ID: number;
      Name: string;
      BackendID?: string;
    }

  }

  /**
   * Update a cash correction reason
   */
  export interface UpdateCashCorrectionReason {
    /**
     * Entity type: CashCorrectionReason
     */
    ID: number;
    Name?: string;
    BackendID?: string;
    Sequence?: number;
  }

  /**
   * List the active feed subscriptions for the current user's `ApplicationID`.
   */
  export interface ListFeedSubscriptions {
  }

  export interface ListFeedSubscriptionsResponse {
    Result: FeedSubscriptionDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface FeedSubscriptionDto {
    ID: number;
    Name: string;
    WebhookUrl: string;
  }

  /**
   * Subscribe to the specified feed for the current User's `ApplicationID`.
   * 
   * `Name` is the name of the file you wish to watch. The `WebhookUrl` is called with a JSON POST request, in which the Feed's `name` and `applicationID` are specified. This request does not contain the data
   * itself, your application will have to fetch the data using your current approaches to download this feed. This may seem verbose, but we have no guarantee the endpoint is secure, and we can't just send
   * possibly sensitive information there!
   * 
   * To unsubscribe, call the `UnsubscribeFromFeed` service with the returned `ID` value.
   */
  export interface SubscribeToFeed {
    Name?: string;
    WebhookUrl?: string;
  }

  export interface SubscribeToFeedResponse {
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Unsubscribe from the specified feed.
   */
  export interface UnsubscribeFromFeed {
    /**
     * Entity type: FeedSubscription
     */
    ID: number;
  }

  /**
   * Create event export configurations (HTTPS only).
   * 
   * Event Export Configurations allow you to configure specific endpoints (webhooks) for EventTargets and EventTypes.
   * 
   * - Not setting EventTarget & EventType will configure the endpoint for all targets and types
   * - Set AuthenticationHeaderType and AuthenticationHeaderValue if you want to configure some sort of authentication
   * - Make sure to catch & store the `SecretKey1` and `SecretKey2`, as there will be no other way of retrieving them after this service call!
   */
  export interface CreateEventExportConfiguration {
    /**
     * A name to identify the configuration.
     */
    Name: string;
    /**
     * The configuration of the endpoint attached to this EventExport.
     * Entity type: EndpointConfiguration
     */
    EndpointConfigurationID: number;
    /**
     * The status of the configuration.
     */
    Status: EventExportConfigurationStatus;
    /**
     * Additional configuration for the endpoint.
     */
    Config?: EventExportConfigurationConfigModel;
  }

  export const enum EventExportConfigurationStatus {
    Enabled = 1,
    Disabled = 2,
    Error = 3,
    Done = 4
  }

  export interface EventExportConfigurationConfigModel {
    /**
     * Authorization configuration used when calling this endpoint.
     */
    Authorization?: EventExportConfigurationConfigAuthorizationModel;
    /**
     * Defines what kind of response EVA requires from this endpoint.
     */
    ResponseMode?: EventExportConfigurationResponseMode;
    /**
     * Filter for certain message types. If not set, all message types will be sent.
     */
    MessageTypes?: EventExportConfigurationTarget[];
    /**
     * Exclude certain message types. If not set, no message types will be excluded.
     */
    ExcludedMessageTypes?: EventExportConfigurationTarget[];
    /**
     * Filter for certain organization units. If not set, all organization units will be sent.
     * Entity type: OrganizationUnit
     */
    IncludeOrganizationUnits?: number[];
    /**
     * Exclude certain organization units. If not set, no organization units will be excluded.
     * Entity type: OrganizationUnit
     */
    ExcludeOrganizationUnits?: number[];
    /**
     * Filter for certain organization unit sets. If not set, all organization units will be sent.
     * Entity type: OrganizationUnitSet
     */
    IncludeOrganizationUnitSets?: number[];
    /**
     * Exclude certain organization unit sets. If not set, no organization units will be excluded.
     * Entity type: OrganizationUnitSet
     */
    ExcludeOrganizationUnitSets?: number[];
    /**
     * Optional script to run before sending the data. This can be used to filter out the event export.
     * Entity type: Script
     */
    ScriptID?: number;
    /**
     * Name of the script that ScriptID refers to.
     */
    ScriptName?: string;
    /**
     * Timeout after which event exports are cancelled. Defaults to 5 seconds. Not recommended to change.
     * Min: 1
     */
    TimeoutSeconds?: number;
    /**
     * The protocol to use when sending the data. If not set, the best available version of HTTP will be used.
     */
    Protocol?: ProtocolTypes;
  }

  export interface EventExportConfigurationConfigAuthorizationModel {
    /**
     * This will result in an authorization header that looks like: `Authorization: Bearer TOKEN`
     */
    StaticBearerToken?: string;
    /**
     * This will result in an authorization header that looks like: `Authorization: TOKEN`. Use this only when the other options are not sufficient.
     */
    StaticUnschemedToken?: string;
    /**
     * Configuration for Mutual TLS (mTLS)
     */
    ClientCertificate?: EventExportConfigurationCertificateModel;
  }

  export interface EventExportConfigurationCertificateModel {
    /**
     * A client certificate that can be used for mTLS. Must be X509 in PKCS12 format. Also, it must not be expired, have a private key and have clientAuth in it's extended key usage.
     */
    Certificate: string;
    /**
     * The password that is used to encrypt the certificate.
     */
    Password?: string;
  }

  export const enum EventExportConfigurationResponseMode {
    /**
     * Expects a 200 OK response with a body of exactly: '[ACK]' (without the singular quotes)
     */
    Normal = 0,
    /**
     * We don't care what you send back as long as it is a 2XX statuscode
     */
    Loose = 1
  }

  export interface EventExportConfigurationTarget {
    TargetID: EventExportTarget;
    EventType?: string;
  }

  export const enum EventExportTarget {
    Order = 1,
    Shipment = 2,
    PaymentTransaction = 3,
    Customer = 4,
    Invoice = 5,
    StockMutation = 6,
    OrganizationUnit = 7,
    FinancialPeriod = 8,
    FinancialPeriodAudit = 9,
    OrderFulfillmentLine = 10,
    System = 11,
    UserTasks = 12,
    CashCorrection = 13,
    CashDeposit = 14,
    CashExpense = 15,
    CashMovement = 16,
    RecurringTask = 17,
    OrderFulfillment = 18,
    Coupon = 19,
    ProductAvailability = 20,
    Repairs = 21,
    StockNotification = 22,
    SerialNumber = 23,
    LoyaltyProgram = 24,
    Cases = 25,
    Wishlist = 26,
    Assortment = 27,
    Survey = 28,
    SurveyResponse = 29,
    Company = 30
  }

  export const enum ProtocolTypes {
    /**
     * Use the best available HTTP version (default)
     */
    HTTP_ANY = 0,
    /**
     * Explicitly instruct EVA to use HTTP/1.1
     */
    HTTP_1_1 = 1
  }

  export interface CreateEventExportConfigurationResponse {
    /**
     * Entity type: EventExportConfiguration
     */
    ID?: number;
    /**
     * Make sure to store this information, this is the only time EVA will expose it for you!
     */
    SecretKey1?: string;
    /**
     * Make sure to store this information, this is the only time EVA will expose it for you!
     */
    SecretKey2?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for deleting a existing `EventExportConfiguration`
   */
  export interface DeleteEventExportConfiguration {
    /**
     * Entity type: EventExportConfiguration
     */
    ID: number;
  }

  /**
   * Service for retrieving an existing `EventExportConfiguration`.
   */
  export interface GetEventExportConfiguration {
    /**
     * Entity type: EventExportConfiguration
     */
    ID: number;
  }

  export interface GetEventExportConfigurationResponse {
    Result: EventExportConfigurationModel;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface EventExportConfigurationModel {
    /**
     * Entity type: EventExportConfiguration
     */
    ID: number;
    /**
     * Entity type: EndpointConfiguration
     */
    EndpointConfigurationID?: number;
    Name: string;
    Status: EventExportConfigurationStatus;
    IsReplay: boolean;
    Endpoint: string;
    SecretKey1: string;
    SecretKey2: string;
    Config: EventExportConfigurationConfigModel;
    ErrorReason?: string;
  }

  export interface EventExportConfigurationConfig {
    Authorization?: EventExportConfigurationConfigAuthorization;
    ResponseMode?: EventExportConfigurationResponseMode;
    MessageTypes?: EventExportConfigurationTarget[];
    ExcludedMessageTypes?: EventExportConfigurationTarget[];
    IncludeOrganizationUnits?: number[];
    ExcludeOrganizationUnits?: number[];
    IncludeOrganizationUnitSets?: number[];
    ExcludeOrganizationUnitSets?: number[];
    ScriptID?: number;
    TimeoutSeconds?: number;
    Protocol?: ProtocolTypes;
  }

  export interface EventExportConfigurationConfigAuthorization {
    StaticBearerToken: string;
    StaticUnschemedToken: string;
    ClientCertificate?: EventExportConfigurationCertificate;
  }

  export interface EventExportConfigurationCertificate {
    Certificate?: string;
    Password?: string;
  }

  /**
   * Service for retrieving a list of existing `EventExportConfiguration`'s
   */
  export interface GetEventExportConfigurations {
  }

  export interface GetEventExportConfigurationsResponse {
    Items: EventExportConfigurationModel[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for retrieving a list of possible event types by `EventExportTarget`. If no target is provided, all targets and their types are returned.
   */
  export interface GetEventExportTargetTypes {
    EventTarget?: EventExportTarget;
  }

  export interface GetEventExportTargetTypesResponse {
    EventTypes?: string[];
    EventTargets?: EventTargetTypes[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface EventTargetTypes {
    Target: EventExportTarget;
    Types: string[];
  }

  /**
   * Replay events for a configuration ID between optional From and To dates.
   */
  export interface ReplayEvents {
    /**
     * Entity type: EventExportConfiguration
     */
    ID: number;
    From?: string;
    To?: string;
  }

  export interface ReplayEventsResponse {
    /**
     * Entity type: EventExportConfiguration
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for updating a existing `EventExportConfiguration`.
   * 
   * - Make sure to catch & store the `SecretKey1` or `SecretKey2`, as there will be no other way of retrieving them after this service call!
   */
  export interface RotateEventExportConfigurationKey {
    /**
     * Entity type: EventExportConfiguration
     */
    ID: number;
    KeyID: number;
  }

  export interface RotateEventExportConfigurationKeyResponse {
    SecretKey1?: string;
    SecretKey2?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for updating a existing `EventExportConfiguration`
   */
  export interface UpdateEventExportConfiguration {
    /**
     * Entity type: EventExportConfiguration
     */
    ID: number;
    Name?: string;
    /**
     * The configuration of the endpoint attached to this EventExport.
     * Entity type: EndpointConfiguration
     */
    EndpointConfigurationID?: number;
    Status?: EventExportConfigurationStatus;
    Endpoint?: string;
    Config?: EventExportConfigurationConfigModel;
  }

  /**
   * A generic service to return all possible values in specified list, e.g. `Currency`, `TaxCode` or `StockLabel`.
   * 
   * The `Name` of the enumeration is unique within EVA, and all of the `Values` returned are also unique and identifiable
   * by their respective `Name`. Services that consume a value of an enumeration will expect the numeric `Value` returned.
   * 
   * Some of these enumerations are static and are defined by code, meaning the `Values`' combination of `Name` and `Value`
   * is contant and will never change. It is important to know, though, that other enumerations may be dynamic and can be
   * altered per environment by their own respective services. When using these, keep in mind they can vary between
   * environments and new values could be added. It is guaranteed, however, that once a certain `Name`-`Value` pair is set,
   * it will never change in that particular environment and you are safe treat it as a constant.
   * 
   * :point_right: It is important to realize these dynamics, because at first sight, all of these values may seem contant between
   * environments - but that is the mere result of an initialization sequence that is usually identical, but definitely
   * not guaranteed!
   * 
   * :point_right: `IsFlags` will indicate if the values should be treated as bit fields (or, a set of flags). For example,
   * the enumeration `OrganizationUnitTypes` demonstrates that an organization unit can both be a Shop (`1`) and a Warehouse (`16`)
   * at the same time, indicated by value `17`. Always use bitwise operands on these fields!
   */
  export interface GetEnumValues {
    Name: string;
  }

  export interface GetEnumValuesResponse {
    Values: GetEnumValuesResponse.EnumValue[];
    IsFlags: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetEnumValuesResponse {
    export interface EnumValue {
      Name: string;
      Value: number;
      Description: string;
    }

  }

  /**
   * Get Transput Job Types
   */
  export interface GetTransputJobTypes {
  }

  export interface GetTransputJobTypesResponse {
    Values: TransputJobTypeInfo[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface TransputJobTypeInfo {
    /**
     * Entity type: TransputJobType
     */
    ID: number;
    Name: string;
  }

  /**
   * Get a list of all document store categories.
   * 
   * :warning: For debugging and support purposes only.
   */
  export interface GetDocumentStoreCategories {
  }

  export interface GetDocumentStoreCategoriesResponse {
    Categories: string[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get a specific document from the document store.
   * 
   * :warning: For debugging and support purposes only.
   */
  export interface GetDocumentStoreDocument {
    /**
     * @The category of the document, see `GetDocumentStoreCategories`
     */
    CategoryID?: string;
    /**
     * @The partition key of the document
     */
    PartitionKey?: string;
  }

  export interface GetDocumentStoreDocumentResponse {
    Documents: Document[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface Document {
    ID: string;
    CreationTime: string;
    Data: any;
  }

  /**
   * Search for documents in a specified category. This will return a maximum of 100 records.
   * 
   * :warning: For debugging and support purposes only.
   */
  export interface SearchDocumentStore {
    /**
     * @The category of the document, see `GetDocumentStoreCategories`
     */
    CategoryID?: string;
    From?: string;
    To?: string;
  }

  export interface SearchDocumentStoreResponse {
    Documents: SearchDocumentStoreResponse.SearchDocumentStoreResponseResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace SearchDocumentStoreResponse {
    export interface SearchDocumentStoreResponseResult {
      PartitionKey: string;
      Id: string;
      CreationTime: string;
      /**
       * Entity type: User
       */
      CreatedByID: number;
      MimeType: string;
    }

  }

  /**
   * Disable a specific Discount for an Order, if the discount is active it will be removed from the Order, if it not active, it will not be applied anymore.
   */
  export interface DisableDiscountOnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Discount
     */
    DiscountID: number;
  }

  /**
   * List disabled discounts on order
   */
  export interface ListDisabledDiscountsOnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface ListDisabledDiscountsOnOrderResponse {
    DisabledDiscounts: ListDisabledDiscountsOnOrderResponse.Item[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListDisabledDiscountsOnOrderResponse {
    export interface Item {
      /**
       * Entity type: Discount
       */
      ID: number;
      Description: string;
      MarketingDescription: string;
      CampaignName: string;
    }

  }

  /**
   * Enable a previous disabled Discount for an Order. If the Discount wasn't disabled, no error will be given.
   */
  export interface EnableDisabledDiscountOnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Discount
     */
    DiscountID: number;
  }

  /**
   * Disable all discounts of the given trigger(s) on the order.
   */
  export interface DisableDiscountTriggersOnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    DiscountTrigger?: DiscountTriggers[];
  }

  /**
   * Enable previously disabled discounts of the given trigger(s) on the order
   */
  export interface EnableDiscountTriggersOnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    DiscountTrigger?: DiscountTriggers[];
  }

  /**
   * List disabled discounts triggers on order
   */
  export interface ListDisabledDiscountTriggersOnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface ListDisabledDiscountTriggersOnOrderResponse {
    DisabledDiscountTriggers: DiscountTriggers[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * This services returns info about the discounts on the given order
   */
  export interface GetOrderDiscountInfo {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetOrderDiscountInfoResponse {
    Discounts: GetOrderDiscountInfoResponse.DiscountInfo[];
    OrderLineDiscounts: GetOrderDiscountInfoResponse.OrderLineDiscount[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetOrderDiscountInfoResponse {
    export interface DiscountInfo {
      /**
       * Entity type: Discount
       */
      ID: number;
      Description: string;
      MarketingDescription: string;
      /**
       * Discount type: Default/System/Coupon/Bundle/Manual
       */
      Type: string;
      /**
       * If the manual discount needs a reason to apply it.
       */
      NeedsReason: boolean;
      BackendID: string;
      /**
       * If the discount is disabled with the DisableDiscountOnOrder service
       */
      IsDisabled: boolean;
      Coupons: GetOrderDiscountInfoResponse.CouponInfo[];
      Manuals: GetOrderDiscountInfoResponse.ManualInfo[];
      /**
       * The OrderLineID's of the discount lines.
       * Entity type: OrderLine
       */
      DiscountOrderLineIDs: number[];
      /**
       * The OrderLineID's on which the discount is applied.
       * Entity type: OrderLine
       */
      AppliedToOrderLines: number[];
      TotalDiscountAmount: number;
    }

    export interface CouponInfo {
      /**
       * Entity type: DiscountCoupon
       */
      ID: number;
      Code: string;
      /**
       * Entity type: OrderLine
       */
      DiscountOrderLineID: number;
    }

    export interface ManualInfo {
      /**
       * Entity type: OrderLine
       */
      DiscountOrderLineID: number;
      /**
       * If the manual discount is applied to a subset of lines, this will contain those lines. If empty, the discount is applied to the order.
       */
      Lines: OrderLineWithQuantity[];
      Amount: number;
      /**
       * Reason for the manual discount
       */
      Reason: string;
    }

    export interface OrderLineDiscount {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      Details: GetOrderDiscountInfoResponse.OrderLineDiscountDetail[];
    }

    export interface OrderLineDiscountDetail {
      /**
       * Entity type: Discount
       */
      DiscountID: number;
      DiscountAmount: number;
    }

  }

  /**
   * List the discounts that potentially could be activated.
   * 
   * A order or user can be given to look at the context of the order or user. When order is given the user will be ignored and the customer of the order will be used (if present)
   * 
   * If a `ProductIDs`, `ProductSearchID` or `ProductSearch` is set, the service will check if the resulting products are a eligible to one or more discounts. If an `OrderID` is provided, the context of the given order is taken into account, that can include user specific discounts, order OU specific discount, etc.
   * 
   * Be aware that:
   * - If `ProductIDs` is given, `ProductSearchID` and `ProductSearch` are ignored
   * - If `ProductSearchID` is given, `ProductIDs` and `ProductSearch` are ignored
   * - If `ProductSearch` is given, `ProductIDs` and `ProductSearchID` are ignored
   */
  export interface PrefigureDiscounts {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchID?: number;
    ProductSearch?: SearchProducts;
  }

  export interface PrefigureDiscountsResponse {
    Results: PrefigureDiscountResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Returns all active discounts within an organization unit
   */
  export interface GetActiveDiscounts {
    /**
     * Defaults to current organization unit.
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Include discounts based on trigger type. Defaults to automatic.
     */
    DiscountTriggers?: DiscountTriggers[];
  }

  export interface GetActiveDiscountsResponse {
    Layers: GetActiveDiscountsResponse.ActiveDiscountLayer[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetActiveDiscountsResponse {
    export interface ActiveDiscountLayer {
      /**
       * Entity type: DiscountLayer
       */
      LayerID: number;
      Discounts: GetActiveDiscountsResponse.ActiveDiscount[];
    }

    export interface ActiveDiscount {
      /**
       * Entity type: Discount
       */
      DiscountID: number;
      Description: string;
      DisplayDescription: string;
      MarketingDescription: string;
      DisplayMarketingDescription: string;
      DisplayPromotionLabel: string;
      PromotionLabel: string;
      ActionType: string;
      ActionData: any;
      Conditions: GetActiveDiscountsResponse.ActiveDiscountCondition[];
      ImageBlobID?: string;
    }

    export interface ActiveDiscountCondition {
      /**
       * Entity type: DiscountCondition
       */
      ID: number;
      Type: string;
      Data: any;
      UseAsActionCondition: boolean;
    }

  }

  /**
   * This services returns a list of discount coupon handlers
   */
  export interface ListDiscountCouponHandlers {
  }

  export interface ListDiscountCouponHandlersResponse {
    Handlers: string[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * List the available manual discounts. Optionally, the OrderType or DiscountAppliesTo filter can be given.
   */
  export interface ListManualDiscounts {
    /**
     * Defaults to Sales
     */
    OrderType?: OrderTypes;
    /**
     * Defaults to Both
     */
    DiscountAppliesTo?: DiscountAppliesTo;
    /**
     * When OrderID is given, the manual discount conditions will be checked against the order.
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * When OrderLineID is given, the manual discount conditions will be checked against the order and orderline. When OrderLineID is given, OrderID will be ignored.
     * Entity type: OrderLine
     */
    OrderLineID?: number;
  }

  export interface ListManualDiscountsResponse {
    Result: ListManualDiscountsResponse.ManualDiscountDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListManualDiscountsResponse {
    export interface ManualDiscountDto {
      /**
       * Entity type: Discount
       */
      ID: number;
      BackendID?: string;
      Description?: string;
      MarketingDescription?: string;
      AppliesTo: DiscountAppliesTo;
      DiscountValueType: DiscountValueType;
      NeedsReason: boolean;
      /**
       * Entity type: CustomField
       */
      RequiredCustomFields: number[];
      FixedAmount?: number;
      MaxAmount?: number;
      /**
       * Entity type: Currency
       */
      CurrencyID: string;
      CurrencyConstraint: CurrencyConstraint;
    }

  }

  export const enum DiscountValueType {
    Percentage = 0,
    Amount = 1
  }

  export const enum CurrencyConstraint {
    CurrencyDependent = 0,
    CurrencyIndependent = 1
  }

  /**
   * Get the PickProductDiscountOptions for an OrderLine
   * 
   * See: `GetPickProductDiscountOptionsForOrder`
   */
  export interface GetPickProductDiscountOptionsForOrderLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
  }

  export interface GetPickProductDiscountOptionsForOrderLineResponse {
    BaseAmount: number;
    /**
     * Entity type: Product
     */
    Options: number[];
    Tiers: PickProductTierOptions[];
    /**
     * Entity type: Product
     */
    CurrentSelection?: number;
    CurrentTier?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface PickProductTierOptions {
    ID: string;
    From: number;
    Difference: number;
    /**
     * Entity type: Product
     */
    DefaultProductID?: number;
    Prompt: boolean;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    Description: string;
    IsCurrentTier: boolean;
  }

  /**
   * Get the PickProductDiscountOptions for an Order
   * 
   * For each line there is an object with the options:
   * - Options: the available products to choose from
   * - CurrentSelection: the currently selected product
   * - CurrentTier: the current tier of the discount
   * - BaseAmount: the amount used to determine the tiers
   * - Tiers:
   *  - ID
   *  - Description
   *  - From: The amount at which this tier is available
   *  - Difference: The amount that should be added to be eligable for this tier
   *  - DefaultProductID: The product that should be selected by default when hitting this tier
   *  - Prompt: Should the frontend show a prompt to pick a product?
   *  - ProductIDs: The avaialble products in this tier
   *  - IsCurrentTier: Is this tier the current one?
   */
  export interface GetPickProductDiscountOptionsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetPickProductDiscountOptionsForOrderResponse {
    /**
     * Entity type: OrderLine
     */
    OptionsPerLine: { [key: number]: GetPickProductDiscountOptionsForOrderResponse.PickProductDiscountOptions };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetPickProductDiscountOptionsForOrderResponse {
    export interface PickProductDiscountOptions {
      BaseAmount: number;
      /**
       * Entity type: Product
       */
      Options: number[];
      Tiers: PickProductTierOptions[];
      /**
       * Entity type: Product
       */
      CurrentSelection?: number;
      CurrentTier?: string;
    }

  }

  /**
   * Pick a product for a PickProductAction for an OrderLine
   */
  export interface SetPickProductDiscountOptionsForOrderLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Entity type: Product
     */
    Selection?: number;
    /**
     * When set to 'true' selection must be within the given product options
     */
    DisallowSelectionOutsideProductOptions?: boolean;
  }

  /**
   * Retrieve currency information using its ID, returning name and precision.
   */
  export interface GetCurrency {
    /**
     * Entity type: Currency
     */
    ID: string;
  }

  export interface GetCurrencyResponse {
    ID: string;
    Name: string;
    Precision: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListCurrencies {
    PageConfig?: PageConfig<ListCurrenciesFilter>;
  }

  export interface ListCurrenciesFilter {
    /**
     * Entity type: Currency
     */
    ID: string;
    Name: string;
  }

  export interface ListCurrenciesResponse {
    Result?: PagedResult<CurrencyDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface CurrencyDto {
    ID: string;
    Name: string;
    Precision: number;
  }

  /**
   * Services for retrieving a list of `Currency`
   */
  export interface GetAvailableCurrencies {
  }

  export interface GetAvailableCurrenciesResponse {
    Currencies: CurrencyDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Creates a new company associated with the consumer type
   */
  export interface CreateConsumerCompany {
    BackendID?: string;
    Name?: string;
    RegistrationNumber?: string;
    RegistrationCountryID?: string;
    RegistrationCountrySubdivisionID?: string;
    TaxRegistrationNumber?: string;
    FiscalID?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    TaxOfficeNumber?: string;
    BillingAddress?: AddressDataDto;
    ShippingAddress?: AddressDataDto;
    TaxRecipientCode?: string;
    TaxRecipientEmail?: string;
    SingleUse?: boolean;
    IsInvoicing?: boolean;
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: User
     */
    UserID?: number;
  }

  export interface CreateConsumerCompanyResponse {
    /**
     * Entity type: Company
     */
    ID: number;
    VatNumberValidationResult: AuditingVatNumberValidationResult;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Retrieves the details of the consumer company corresponding to the specified ID.
   */
  export interface GetConsumerCompany {
    /**
     * Entity type: Company
     */
    ID: number;
  }

  export interface GetConsumerCompanyResponse {
    /**
     * Entity type: Company
     */
    ID?: number;
    BackendID?: string;
    Name?: string;
    RegistrationNumber?: string;
    RegistrationCountryID?: string;
    RegistrationCountrySubdivisionID?: string;
    TaxRegistrationNumber?: string;
    FiscalID?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    BillingAddress?: AddressDto;
    ShippingAddress?: AddressDto;
    TaxRecipientCode?: string;
    TaxRecipientEmail?: string;
    SingleUse?: boolean;
    IsInvoicing?: boolean;
    HasUsers?: boolean;
    TaxOfficeNumber?: string;
    VatNumberValidationResult?: AuditingVatNumberValidationResult;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Searches for consumer companies based on the provided query and filter criteria.
   */
  export interface SearchConsumerCompany {
    Query?: string;
    PageConfig?: ScrollablePageConfig<SearchCompanyFilter>;
  }

  export interface ScrollablePageConfig<T> {
    Filter: T;
    NextResultToken: string;
    Limit?: number;
  }

  export interface SearchCompanyFilter {
    /**
     * Entity type: Company
     */
    CompanyIDs?: number[];
    /**
     * Entity type: User
     */
    UserIDs?: number[];
    Name?: string;
    RegistrationNumber?: string;
    TaxRegistrationNumber?: string;
    FiscalID?: string;
    BillingAddressAddress1?: string;
    BillingAddressAddress2?: string;
    BillingAddressHouseNumber?: string;
    BillingAddressZipCode?: string;
    BillingAddressDistrict?: string;
    BillingAddressSubDistrict?: string;
    BillingAddressCity?: string;
    BillingAddressState?: string;
    BillingAddressCountryID?: string;
    BillingAddressCountrySubdivisionID?: string;
    IsInvoicing?: boolean;
  }

  export interface SearchConsumerCompanyResponse {
    Result: ScrollablePagedResult<SearchCompanyResult>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ScrollablePagedResult<T> {
    Page: T[];
    PreviousResultToken: string;
    NextResultToken: string;
  }

  export interface SearchCompanyResult {
    /**
     * Entity type: Company
     */
    ID?: number;
    BackendID?: string;
    Name?: string;
    RegistrationNumber?: string;
    TaxRegistrationNumber?: string;
    FiscalID?: string;
    HasUsers?: boolean;
  }

  /**
   * Updates the details of companies associated with the consumer type.
   */
  export interface UpdateConsumerCompany {
    /**
     * Entity type: Company
     */
    ID: number;
    Name?: string;
    RegistrationNumber?: string;
    RegistrationCountryID?: string;
    RegistrationCountrySubdivisionID?: string;
    TaxRegistrationNumber?: string;
    FiscalID?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    BillingAddress?: AddressDataDto;
    ShippingAddress?: AddressDataDto;
    TaxRecipientCode?: string;
    TaxRecipientEmail?: string;
    TaxOfficeNumber?: string;
    IsInvoicing?: boolean;
    /**
     * Optional additional custom fields
     */
    CustomFields?: CustomFieldKeyValue[];
    /**
     * Entity type: Order
     */
    OrderID?: number;
  }

  export interface UpdateConsumerCompanyResponse {
    /**
     * Entity type: Company
     */
    ID: number;
    VatNumberValidationResult: AuditingVatNumberValidationResult;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for customers to list case interactions
   */
  export interface CustomerListCaseInteractions {
    /**
     * Entity type: Case
     */
    CaseID: number;
    InitialPageConfig?: PageTokenConfig<CustomerListCaseInteractionsFilter>;
    PageToken?: string;
  }

  export interface CustomerListCaseInteractionsFilter {
    /**
     * Entity type: Interaction
     */
    ID?: number;
    Text?: string;
  }

  export interface CustomerListCaseInteractionsResponse {
    Results?: CustomerListCaseInteractionsResponse.CaseInteraction[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace CustomerListCaseInteractionsResponse {
    export interface CaseInteraction {
      /**
       * Entity type: Interaction
       */
      ID: number;
      /**
       * Entity type: Case
       */
      CaseID: number;
      Type: InteractionType;
      CanBeModified: boolean;
      Text: string;
      CreationTime: string;
      LastModificationTime?: string;
      /**
       * Entity type: User
       */
      CreatedByID?: number;
      CreatedBy?: CustomerListCaseInteractionsResponse.User;
    }

    export interface User {
      FirstName: string;
      LastName: string;
      FullName: string;
    }

  }

  /**
   * Service for customers to get a case interaction by id
   */
  export interface CustomerGetCaseInteraction {
    /**
     * Entity type: Interaction
     */
    ID: number;
  }

  export interface CustomerGetCaseInteractionResponse {
    /**
     * Entity type: Interaction
     */
    ID: number;
    /**
     * Entity type: Case
     */
    CaseID: number;
    Type: InteractionType;
    CanBeModified: boolean;
    Text: string;
    CreationTime: string;
    LastModificationTime?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for customers to create a case
   */
  export interface CustomerCreateCaseInteraction {
    /**
     * Entity type: Case
     */
    CaseID: number;
    Text?: string;
  }

  export interface CustomerCreateCaseInteractionResponse {
    /**
     * Entity type: Interaction
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for customers to update a case interaction
   */
  export interface CustomerUpdateCaseInteraction {
    /**
     * Entity type: Interaction
     */
    ID: number;
    Text?: string;
  }

  /**
   * Service for customers to delete a case interaction
   */
  export interface CustomerDeleteCaseInteraction {
    /**
     * Entity type: Interaction
     */
    ID: number;
  }

  /**
   * Service for customers to add a blob to a case interacion.
   */
  export interface CustomerAddBlobToCaseInteraction {
    /**
     * Entity type: Interaction
     */
    InteractionID?: number;
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     * @deprecated Use `BlobUrls` instead.
     */
    BlobUrl?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrls?: string[];
  }

  /**
   * Service for customers to remove a blob from a case interaction.
   */
  export interface CustomerRemoveCaseInteractionBlob {
    /**
     * Entity type: Interaction
     */
    InteractionID?: number;
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrl?: string;
  }

  /**
   * Service for customers to list cases. Returns a paged response.
   */
  export interface CustomerListCases {
    InitialPageConfig?: PageTokenConfig<CustomerListCasesFilter>;
    PageToken?: string;
  }

  export interface CustomerListCasesFilter {
    Title?: string;
  }

  export interface CustomerListCasesResponse {
    Results?: CustomerListCasesResponse.Case[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace CustomerListCasesResponse {
    export interface Case {
      /**
       * Entity type: Case
       */
      ID?: number;
      /**
       * Entity type: CaseTopic
       */
      TopicID?: number;
      TopicName?: string;
      /**
       * Entity type: CaseStatus
       */
      StatusID?: number;
      StatusName?: string;
      Priority?: CasePriority;
      Title?: string;
      /**
       * Entity type: Order
       */
      OrderID?: number;
      ReportingTime?: string;
    }

  }

  export const enum CasePriority {
    Low = 0,
    Medium = 1,
    High = 2,
    Critical = 9
  }

  /**
   * Service for customers to get a case by its ID.
   */
  export interface CustomerGetCaseByID {
    /**
     * Entity type: Case
     */
    ID: number;
  }

  export interface CustomerGetCaseByIDResponse {
    /**
     * Entity type: Case
     */
    ID: number;
    /**
     * Entity type: CaseTopic
     */
    TopicID?: number;
    TopicName?: string;
    /**
     * Entity type: CaseStatus
     */
    StatusID: number;
    StatusName?: string;
    Priority: CasePriority;
    Title: string;
    IsTitleEditable: boolean;
    Description: string;
    IsDescriptionEditable: boolean;
    Solution: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    ReportingTime: string;
    ClosingTime?: string;
    DescriptionCanBeModified: boolean;
    BlobIDs: string[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for customers to create a new case.
   */
  export interface CustomerCreateCase {
    /**
     * Entity type: CaseTopic
     */
    TopicID: number;
    Title: string;
    Description: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
  }

  export interface CustomerCreateCaseResponse {
    /**
     * Entity type: Case
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for customers to update an existing case.
   */
  export interface CustomerUpdateCase {
    /**
     * Entity type: Case
     */
    ID: number;
    /**
     * Entity type: CaseTopic
     */
    TopicID?: number;
    Title?: string;
    Description?: string;
  }

  /**
   * Service for customers to add a blob to a case.
   */
  export interface CustomerAddBlobToCase {
    /**
     * Entity type: Case
     */
    CaseID?: number;
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     * @deprecated Use `BlobUrls` instead.
     */
    BlobUrl?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrls?: string[];
  }

  /**
   * Service for customers to remove a blob from a case.
   */
  export interface CustomerRemoveCaseBlob {
    /**
     * Entity type: Case
     */
    CaseID?: number;
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrl?: string;
  }

  /**
   * Returns the active shopping cart for the current user.
   * Works only for webshop OUs.
   * If there is no active shopping cart, no orderID will be returned.
   */
  export interface GetActiveShoppingCart {
  }

  export interface GetActiveShoppingCartResponse {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Fetch the summary of an Order. This summary contains:
   * - QuantityOrdered: the total count of products in the Order
   * - TotalAmount: the total amount of the Order
   * - ForeignTotalAmount: the total amount of the Order in the foreign currency
   * - CurrencyID: the currency of the Order
   * 
   * It is required to supply an OrderID
   */
  export interface GetShoppingCartInfo {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetShoppingCartInfoResponse {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * This returns the requested order. The order is retreived based on the OrderID.
   * 
   * The order will be recalculated:
   * - Discounts
   * - ShippingCosts
   * - GiftWrappingCosts
   * - OrderLine prices
   * 
   * If no recalculation is needed, use the GetOrder service instead. In general the approach would be: use GetShoppingCart while building the order, after PrepareOrderForCheckout has been called, switch to GetOrder.
   * 
   * To include the result of `GetRequiredDataForOrder`, the property `AdditionalOrderDataOptions.RequiredFor` can be set to the desired level of requirements.
   * To include the result of `GetProductRequirementValuesForOrder`, the property `AdditionalOrderDataOptions.IncludeProductRequirements` can be set to `true`.
   * To include the result of `GetGiftWrappingOptionsForOrder` and `GetAvailableGiftWrappingLinesForOrder`, the property `AdditionalOrderDataOptions.IncludeGiftWrapping` can be set to `true`.
   * To include the result of `PrefigureDiscounts` and `GetPotentialDiscountsForOrder`, the property `AdditionalOrderDataOptions.IncludePrefigureDiscounts` can be set to `true`.
   * To include the result of `GetPickProductDiscountOptionsForOrder`, the property `AdditionalOrderDataOptions.IncludePickProductOptions` can be set to `true`.
   * To include the result of `ListAvailableShippingMethods`, the property `AdditionalOrderDataOptions.IncludeAvailableShippingMethods` can be set to `true`.
   * To include the result of `GetAvailablePaymentMethods`, the property `AdditionalOrderDataOptions.IncludeAvailablePaymentMethods` can be set to `true`.
   * To include the result of `GetAvailableRefundPaymentMethodsForOrder`, the property `AdditionalOrderDataOptions.IncludeAvailableRefundPaymentMethods` can be set to `true`.
   * To include the result of `ValidateOrderShipment`, the property `AdditionalOrderDataOptions.IncludeValidateShipment` can be set to `true`.
   * To include the available actions for the PaymentTransactions, the property `AdditionalOrderDataOptions.IncludePaymentTransactionActions` can be set to `true`.
   */
  export interface GetShoppingCart {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * By default only confirmed payments are returned, enabling this flag will return all PaymentTransactions
     */
    IncludeAllPayments?: boolean;
    AdditionalOrderDataOptions?: AdditionalOrderDataOptions;
  }

  export interface ShoppingCartResponse {
    ShoppingCart: OrderDto;
    Amounts: OpenOrderAmounts;
    AdditionalOrderData?: AdditionalOrderData;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Clear cached entries matching the given Pattern string.
   */
  export interface FlushCache {
    Pattern: string;
  }

  /**
   * Gets info about EVA caches, only accessible by New Black.
   */
  export interface GetCacheInfo {
    /**
     * Include more detail for the caches where available.
     */
    IncludeDetails?: boolean;
  }

  export interface GetCacheInfoResponse {
    CacheInfo: any;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Attaches given blob to an order, either by `BlobID` or `BlobUrl`.
   */
  export interface AttachBlobToOrder {
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrl?: string;
    Name: string;
    /**
     * @default None
     */
    Type?: OrderBlobTypes;
    /**
     * Required when `OrderLineID` is omitted
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Required when `OrderID` is omitted
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Optional link the blob to an Invoice of the Order
     * Entity type: Invoice
     */
    InvoiceID?: number;
    /**
     * Optional link the blob to a Shipment of the Order
     * Entity type: Shipment
     */
    ShipmentID?: number;
  }

  /**
   * Creates a blob intended for app diagnostics - will log the user context to determine user, organization unit and user agent.
   */
  export interface CreateDiagnosticsBlob {
    LiveGuardCreationTime?: string;
  }

  export interface CreateDiagnosticsBlobResponse {
    /**
     * Entity type: Blob
     */
    Guid: string;
    Url: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * List blobs intended for app diagnostics.
   */
  export interface ListDiagnosticsBlobs {
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListDiagnosticsBlobsResponse {
    Result?: PagedResult<DiagnosticsBlob>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface DiagnosticsBlob {
    /**
     * Entity type: Blob
     */
    ID: string;
    Url: string;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    CreationTime: string;
    OriginatingFromWatchtower: boolean;
    /**
     * Entity type: Station
     */
    StationID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    UserAgent?: string;
  }

  /**
   * Return archive blobs belonging to the specified FinancialPeriodID.
   */
  export interface ListBlobsForFinancialPeriod {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
  }

  export interface ListBlobsForFinancialPeriodResponse {
    Result: FinancialPeriodBlobDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface FinancialPeriodBlobDto {
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID: number;
    Name: string;
    MimeType: string;
    /**
     * Entity type: Blob
     */
    BlobID: string;
    Url: string;
  }

  /**
   * Get the blobs that are attached to an Order
   * 
   * It's required to specify the order, optionally the blobs can also be filtered on `InvoiceID` of `ShipmentID`.
   */
  export interface ListBlobsForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
  }

  export interface ListBlobsForOrderResponse {
    Result: OrderBlobDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface OrderBlobDto {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Entity type: Invoice
     */
    InvoiceID?: number;
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    Type: OrderBlobTypes;
    Name: string;
    MimeType: string;
    BlobID: string;
    Url: string;
    CreationTime: string;
    /**
     * Optional OrganizationUnit based on Shipment.OrganizationUnit or Invoice.OrganizationUnit
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OrganizationUnitBackendID?: string;
    OrganizationUnitName?: string;
    InvoiceNumber?: string;
    /**
     * Entity type: MessageTemplate
     */
    MessageTemplateID?: number;
  }

  /**
   * Service combining StoreBlob and AttachBlobToOrder.
   */
  export interface StoreAndAttachBlobToOrder {
    Name: string;
    /**
     * @default None
     */
    Type?: OrderBlobTypes;
    Category?: string;
    OriginalName?: string;
    MimeType: string;
    Data: string;
    /**
     * Required when `OrderLineID` is omitted
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Required when `OrderID` is omitted
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Optional link the blob to an Invoice of the Order
     * Entity type: Invoice
     */
    InvoiceID?: number;
    /**
     * Optional link the blob to a Shipment of the Order
     * Entity type: Shipment
     */
    ShipmentID?: number;
  }

  export interface StoreAndAttachBlobToOrderResponse {
    Guid: string;
    Url: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for generating a new device hub barcode
   */
  export interface GenerateDeviceHubBarcode {
  }

  export interface GenerateDeviceHubBarcodeResponse {
    DeviceID: string;
    Barcode: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for generating a new scan mode barcode
   */
  export interface GenerateScanModeBarcode {
  }

  export interface GenerateScanModeBarcodeResponse {
    DeviceID: string;
    Barcode: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for generating a new session barcode
   */
  export interface GenerateSessionBarcode {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GenerateSessionBarcodeResponse {
    Barcode: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Parses the given barcode with an available handler that can process it.
   */
  export interface ParseBarcode {
    Barcode?: string;
  }

  export interface ParseBarcodeResponse {
    Type: string;
    Value: string;
    /**
     * This indicates the barcode was parsed succesfully, but the resulting data could not be found in the current instance.
     */
    ParsedButNotFound: boolean;
    /**
     * The handler that handled the barcode has ExecuteBarcode functionality.
     */
    IsExecutable: boolean;
    Data: { [key: string]: any };
    Actions: ParseBarcodeResponse.Action[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ParseBarcodeResponse {
    export interface Action {
      Sequence: number;
      Type: string;
      Parameters: { [key: string]: any };
    }

  }

  /**
   * Executes the given barcode with an available handler that can execute it. To know if a barcode is executable, run ParseBarcode and look for the IsExecutable in the response.
   */
  export interface ExecuteBarcode {
    /**
     * The handler that parsed the barcode in parsebarcode.
     */
    Type: string;
    Barcode: string;
    Data: { [key: string]: any };
  }

  export interface ExecuteBarcodeResponse {
    Data?: { [key: string]: any };
    Actions?: ExecuteBarcodeResponse.Action[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ExecuteBarcodeResponse {
    export interface Action {
      Sequence: number;
      Type: string;
      Parameters: { [key: string]: any };
    }

  }

  /**
   * Service for retrieving a device authentication token
   */
  export interface RequestDeviceAuthenticationToken {
  }

  export interface RequestDeviceAuthenticationTokenResponse {
    AuthenticationToken: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Generates a temporary 5-digit code that can be used for elevation.
   * 
   * A manager generates this code on their own device, and can then manually copy this code on the user's device when requested.
   * 
   * :shield: Requires `Security:ElevatedFunctionalityProvider` to contain "TemporaryElevationCode".
   * 
   * :point_right: Send this temporary code as elevation header with your original call.
   * 
   * :bulb: Note it's only valid for a limited period of time (as per `Security:TemporaryElevationCode:ExpireInMinutes`) and is a /separate/ code from your login PIN!
   */
  export interface GenerateTemporaryElevationCode {
  }

  export interface GenerateTemporaryElevationCodeResponse {
    Code: string;
    ValidBefore: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Generates an elevation barcode to elevate this user's rights, which can be scanned by a manager with sufficient rights to grant elevation.
   * 
   * Show the returned `Barcode` to a manager for scanning through the `ParseBarcode` service, preferably as QR code through our `/barcode` endpoint.
   * 
   * :shield: Requires `Security:ElevatedFunctionalityProvider` to contain "ElevationBarcode".
   * 
   * :point_right: Send the returned `RequestToken` as elevation header with your original call, but before you do, it needs to be confirmed first through a manager scan. You can use this
   * same token to subscribe to the `/elevationBarcode` SignalR hub to listen for this scan event.
   * 
   * :bulb: Supply the `OrganizationUnitID` of your current context, and the `Functionality`, `Scope` and `ElevationType` returned from your original request through response headers
   * `EVA-Elevation-Functionality`, `EVA-Elevation-Scope` and `EVA-Elevation-Type` respectively.
   */
  export interface GenerateElevationBarcode {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    Functionality?: string;
    Scope?: FunctionalityScope;
    ElevationType?: ElevationType;
  }

  export interface GenerateElevationBarcodeResponse {
    Barcode: string;
    RequestToken: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Generates an elevation skip token to elevate this user's rights.
   * 
   * :shield: Requires `Security:ElevatedFunctionalityProvider` to contain "Skip".
   * 
   * :point_right: Simply use this as elevation header with your original call, you don't need anyone else for this elevation.
   * 
   * :bulb: Supply the `OrganizationUnitID` of your current context, and the `Functionality`, `Scope` and `ElevationType` returned from your original request through response headers
   * `EVA-Elevation-Functionality`, `EVA-Elevation-Scope` and `EVA-Elevation-Type` respectively.
   */
  export interface GenerateElevationSkipToken {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    Functionality: string;
    Scope: FunctionalityScope;
    ElevationType: ElevationType;
  }

  export interface GenerateElevationSkipTokenResponse {
    Token: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Returns the full authorizationstructure of the current user.
   * 
   * It is a list of all the roles the user has, with their functionalities and the OrganizationUnits where these are active.
   */
  export interface GetAuthorizationStructure {
  }

  export interface GetAuthorizationStructureResponse {
    Roles: RoleWithFunctionalitiesAndOrganizationUnits[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface RoleWithFunctionalitiesAndOrganizationUnits {
    /**
     * Entity type: Role
     */
    RoleID: number;
    RoleName: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs: number[];
    Functionalities: Record<'None' | 'Elevation' | 'Verification', { [key: string]: FunctionalityScope }>;
  }

  /**
   * Create a temporary token, based off of your current authentication token, which can be passed in query parameters for redirect requests. On the
   * receiving side, post this token in the `Login` service request body as `AuthenticationToken` to retrieve a new token, similar to the original
   * token, preserving user and context.
   * 
   * Note this token lifetime is only 30 seconds, and has no rights to do anything else.
   */
  export interface GetTemporaryRedirectToken {
  }

  export interface GetTemporaryRedirectTokenResponse {
    Token: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Authenticates a user
   */
  export interface Login {
    /**
     * Primary identifier of the user, can be an `EmailAddress` or `Nickname`
     */
    Username?: string;
    /**
     * The password associated with the `Username`
     */
    Password?: string;
    /**
     * Used to login to a specific organization unit
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Used to login to a specific visibility group
     * Entity type: VisibilityGroup
     */
    VisibilityGroupID?: number;
    /**
     * The two-factor authenticator code that granted the confirmation token
     */
    TwoFactorAuthenticator?: string;
    /**
     * The two-factor authenticator confirmation token
     */
    TwoFactorAuthenticationToken?: string;
    /**
     * If a successful two-factor authentication should be remembered on this IP address
     */
    TwoFactorRememberMe?: boolean;
    /**
     * Your current authenticationtoken;
     * - Can be used to select the same OrganizationUnit when logging in onto a website with an anonymous token
     * - Can be used when switching to another organization unit (no other properties are required in that case)
     */
    AuthenticationToken?: string;
    /**
     * The employee code - used to login by QR or PIN
     */
    IdentificationCode?: string;
    /**
     * Login on the first OrganizationUnit in the tree where the user has the Login functionality
     */
    SelectFirstOrganizationUnit?: boolean;
    /**
     * The preferred Language for the session
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Type of the custom authenticator, if used
     */
    CustomAuthenticatorType?: string;
    /**
     * Data for the custom authenticator, if used
     */
    CustomAuthenticateData?: { [key: string]: any };
    /**
     * Filters the available roles/functionalities when those are explicitly attached to a user type (only single flag values are allowed)
     */
    UserType?: UserTypes;
    /**
     * When set, the non-employees will be explicity filtered - used primarily when Customers and Employees are split, but can also be used to make sure no Customers can login
     */
    AsEmployee?: boolean;
    /**
     * When enabled this service will return a JWT token and refresh token.
     */
    UseJwtTokens?: boolean;
  }

  export interface LoginResponse {
    Authentication?: AuthenticationResults;
    FailureReason?: AuthenticationFailureReasons;
    OrganizationUnits?: LoginResponse.OrganizationUnitModel[];
    VisibilityGroups?: LoginResponse.VisibilityGroupModel[];
    User?: LoggedInUserDto;
    IsCustomAuthenticateResult?: boolean;
    /**
     * The available two-factor authenticators, returned when the Authentication result is NeedsTwoFactorAuthentication, for use in a sequential Login call
     */
    TwoFactorAuthenticators?: TwoFactorAuthenticatorData[];
    /**
     * Response data for the custom authenticator, if used
     */
    CustomAuthenticateResponseData?: { [key: string]: any };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace LoginResponse {
    export interface OrganizationUnitModel {
      /**
       * Entity type: OrganizationUnit
       */
      ID?: number;
      /**
       * Entity type: OrganizationUnit
       */
      ParentID?: number;
      /**
       * Entity type: Country
       */
      CountryID?: string;
      Name?: string;
      BackendID?: string;
      Description?: string;
      Type?: OrganizationUnitTypes;
      Status?: OrganizationUnitStatus;
    }

    export interface VisibilityGroupModel {
      /**
       * Entity type: VisibilityGroup
       */
      ID?: number;
      Name?: string;
    }

  }

  export const enum AuthenticationResults {
    NotAuthenticated = 0,
    NotAuthorized = 1,
    Authenticated = 2,
    NeedsTwoFactorAuthentication = 3,
    NeedsOrganizationUnitID = 4,
    NeedsEmailVerification = 5,
    NeedsPasswordReset = 6,
    NeedsVisibilityGroupID = 7,
    NeedsChallenge = 8
  }

  export const enum AuthenticationFailureReasons {
    None = 0,
    InvalidRequest = 1,
    NeedsEmailVerification = 2,
    NotAuthorized = 3,
    InvalidCredentials = 4,
    ThirdPartyFailure = 5,
    InvalidUserType = 6,
    NeedsPasswordReset = 7,
    AuthenticationOnPrimaryRegionFailed = 8,
    SelectedOrganizationUnitNotAvailable = 9,
    UserDoesntExist = 10,
    UserDeactivated = 11,
    InvalidTwoFactorAuthentication = 12,
    CannotUseApiKeyForLogin = 13,
    InvalidChallenge = 14
  }

  export interface TwoFactorAuthenticatorData {
    Name: string;
    SecurityLevel: number;
    Status: TwoFactorAuthenticatorStatus;
    Type: TwoFactorAuthenticatorType;
  }

  export const enum TwoFactorAuthenticatorStatus {
    Disabled = 0,
    Pending = 1,
    Confirmed = 2,
    Failed = 3
  }

  export const enum TwoFactorAuthenticatorType {
    Passive = 0,
    Active = 1
  }

  /**
   * Ends the current session of the user and invalidates the used AuthenticationToken
   * 
   * Optionally the ExpireAllSessions property can be set to terminate all current sessions for the User.
   */
  export interface Logout {
    ExpireAllSessions?: boolean;
  }

  export interface LogoutResponse {
    LogoutSuccessful: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Retrieves some basic information about the current user's passkeys.
   */
  export interface GetPasskeyInfo {
  }

  export interface GetPasskeyInfoResponse {
    Passkeys?: GetPasskeyInfoResponse.GetPasskeyInfoItem[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetPasskeyInfoResponse {
    export interface GetPasskeyInfoItem {
      ID?: string;
    }

  }

  /**
   * As a logged in user, you can create a passkey as additional login method, which is a totally awesome, passwordless, usernameless method to log in!
   * 
   * Before you can create a new passkey, use this `GetPasskeyChallenge` service to obtain a challenge and some information from the server, push that through WebAuthn using
   * `navigator.credentials.create` to create the credential, which you use to call `CreatePasskey`.
   * 
   * :point_right: See `CreatePasskey` for more details!
   */
  export interface GetPasskeyChallenge {
  }

  export interface GetPasskeyChallengeResponse {
    Challenge?: string;
    RelyingParties?: GetPasskeyChallengeResponse.GetPasskeyChallengeResponseRelyingParty[];
    User?: GetPasskeyChallengeResponse.GetPasskeyChallengeResponseUser;
    Algorithms?: GetPasskeyChallengeResponse.GetPasskeyChallengeResponseAlgorithm[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetPasskeyChallengeResponse {
    export interface GetPasskeyChallengeResponseRelyingParty {
      ID?: string;
      Name?: string;
    }

    export interface GetPasskeyChallengeResponseUser {
      ID?: string;
      DisplayName?: string;
      Name?: string;
    }

    export interface GetPasskeyChallengeResponseAlgorithm {
      ID?: number;
      Type?: string;
    }

  }

  /**
   * After having called `GetPasskeyChallenge` to obtain a challenge and some information from the server, and after pushing that through WebAuthn using `navigator.credentials.create`,
   * you extract information from the generated credential and send it back to the server for storage.
   * 
   * 1. The `Challenge` matching the one originally provided through `GetPasskeyChallenge`
   * 2. The `PublicKey` generated (base64 encoded)
   * 3. The `AuthenticatorData` generated (base64 encoded)
   * 
   * The creation will succeed if the `Challenge` matches the one we created for you and all the data checks out, after which you can use your new key to log in!
   * 
   * When you want to log in, simply call `Login` using `CustomAuthenticatorType` set to "Passkey" and it will reply with a challenge and some information inside the
   * `CustomAuthenticateResponseData` property, which you can push through WebAuthn using `navigator.credentials.get` to sign that challenge with your private key. Exact the information
   * from the generated credential and call `Login` again with the same `CustomAuthenticatorType`, but this time include `CustomAuthenticateData` with an object of type
   * `PasskeyAuthenticateMessage` containing;
   * 
   * - The `ID` as the "rawId" of the used credential (base64 encoded)
   * - The `Signature` that was created to sign the challenge (base64 encoded)
   * - The `ClientData` to include some client information (base64 encoded json)
   * - The `AuthenticatorData` to include some authenticator data (base64 encoded)
   * 
   * If this all checks out, you're logged in! As with every `Login`, be sure to specify user types and organization units of your preference.
   */
  export interface CreatePasskey {
    Challenge?: string;
    PublicKey?: string;
    AuthenticatorData?: string;
  }

  /**
   * Remove a passkey configuration for the current user.
   */
  export interface DeletePasskey {
    ID?: string;
  }

  /**
   * Remove all passkey configurations for the specified user, as employee management feature.
   */
  export interface DeletePasskeyForUser {
    /**
     * Entity type: User
     */
    UserID: number;
  }

  /**
   * Stub service to validate the current token for employees
   */
  export interface Ping {
  }

  /**
   * Stub service to validate the current token
   */
  export interface ValidateToken {
  }

  /**
   * Refresh a JWT token
   */
  export interface RefreshToken {
    Token?: string;
  }

  export interface RefreshTokenResponse {
    Token?: string;
    RefreshToken?: string;
    RefreshTokenExpireDate?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Gets the available two-factor authenticators for the current user
   */
  export interface GetAvailableTwoFactorAuthenticators {
    Status?: TwoFactorAuthenticatorStatus;
  }

  export interface GetAvailableTwoFactorAuthenticatorsResponse {
    Result: TwoFactorAuthenticatorData[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Enable a given two-factor authenticator for the current user
   */
  export interface EnableTwoFactorAuthentication {
    TwoFactorAuthenticator: string;
    TwoFactorAuthenticationToken?: string;
  }

  export interface EnableTwoFactorAuthenticationResponse {
    Status: TwoFactorAuthenticatorStatus;
    Data: { [key: string]: any };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Disable a given two-factor authenticator for the current user
   */
  export interface DisableTwoFactorAuthentication {
    TwoFactorAuthenticator: string;
  }

  /**
   * Disables all two-factor authenticator for the given user
   */
  export interface DisableAllTwoFactorAuthentication {
    /**
     * Entity type: User
     */
    UserID: number;
  }

  /**
   * Validates if the given PIN is valid for the current user/ou.
   */
  export interface ValidateIdentificationPin {
    Pin: string;
  }

  export interface ValidateIdentificationPinResponse {
    IsValid: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Creates a new AuditChainConfiguration, which allows you to configure the starting number of a sequence and its prefix.
   * Creating a configuration for an audit chain that already exists does not apply this configuration. A new chain would need to be created by incrementing the Auditing:Version setting.
   */
  export interface CreateAuditChainConfiguration {
    AuditChainType?: AuditChainTypes;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Company
     */
    CompanyID?: number;
    DesiredStartSequenceNumber?: number;
    DesiredPrefix?: string;
    DesiredIdentifier?: string;
  }

  export interface CreateAuditChainConfigurationResponse {
    /**
     * Entity type: AuditChainConfiguration
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Gets all current audit chain configurations.
   */
  export interface GetAuditChainConfigurations {
  }

  export interface GetAuditChainConfigurationsResponse {
    Configurations: GetAuditChainConfigurationsResponse.AuditChainConfiguration[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetAuditChainConfigurationsResponse {
    export interface AuditChainConfiguration {
      /**
       * Entity type: AuditChainConfiguration
       */
      ID?: number;
      /**
       * Entity type: Country
       */
      CountryID?: string;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID?: number;
      /**
       * Entity type: Company
       */
      CompanyID?: number;
      AuditChainType?: AuditChainTypes;
      OrganizationUnitName?: string;
      CompanyName?: string;
      DesiredStartSequenceNumber?: number;
      DesiredPrefix?: string;
      DesiredIdentifier?: string;
      CreationTime?: string;
      LastModificationTime?: string;
    }

  }

  /**
   * Updates an existing AuditChainConfiguration, which allows you to configure the starting number of a sequence and its prefix.
   * Updating a configuration for an audit chain that already exists does not apply this updated configuration. A new chain would need to be created by incrementing the Auditing:Version setting.
   */
  export interface UpdateAuditChainConfiguration {
    /**
     * Entity type: AuditChainConfiguration
     */
    ID?: number;
    AuditChainType?: AuditChainTypes;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Company
     */
    CompanyID?: number;
    DesiredStartSequenceNumber?: number;
    DesiredPrefix?: string;
    DesiredIdentifier?: string;
  }

  /**
   * Deletes an AuditChainConfiguration
   */
  export interface DeleteAuditChainConfiguration {
    /**
     * Entity type: AuditChainConfiguration
     */
    ID: number;
  }

  /**
   * Downloads all generated audit files from the selected period as a single zip file, with a separate folder for each organization unit.
   * 
   * When selecting a container organization unit, all underlying organization units will be included.
   */
  export interface DownloadFinancialPeriodAudits {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    FiscalYear: number;
    FiscalMonth?: number;
  }

  /**
   * Used to retrieve the e-invoicing data that was set before via `SetElectronicInvoiceData`
   */
  export interface GetElectronicInvoiceData {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetElectronicInvoiceDataResponse {
    RecipientEmail: string;
    RecipientCode: string;
    PublicProjectCode: string;
    TenderIdentificationCode: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Sets the additional e-invoicing data on the given order. To retrieve the information that has been set use: `GetElectronicInvoiceData`
   */
  export interface SetElectronicInvoiceData {
    /**
     * Entity type: Order
     */
    OrderID: number;
    RecipientEmail?: string;
    RecipientCode?: string;
    PublicProjectCode?: string;
    TenderIdentificationCode?: string;
  }

  /**
   * Retrieves the lottery number for a given order
   */
  export interface GetLotteryNumber {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetLotteryNumberResponse {
    LotteryNumber: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * This service lets you query the EventLedger for auditing purposes.
   * 
   * The request provides a PageConfig (of type ScrollablePageConfig) that lets you filter on the given properties in the EventLedger.
   * Paging is done by providing the request with the `NextResultToken` that you got back from the previous request.
   * As this method of paging is forward-only, you can't go back to a previous page unless you store the token or the results,
   * and the total number of results is unknown, only whether or not there are more results (determined by if the NextResultToken is null).
   * 
   * The response contains the whole EventLedger document.
   * 
   * Possible filters:
   * 
   * - Types: A list of strings that refer to the `Type` field that is in every document.
   * - OrderID: Only return documents that contain a reference to the given OrderID
   * - OrganizationUnitID: Only return documents that were created by someone logged into the given OrganizationUnitID. It's recommended that this filter is always used, due to performance reasons.
   * - DeviceID: Filters on documents that have a reference to the given device, usually associated with a payment or a print command.
   * - FromDate: Only return documents newer than this date. It's recommended that this filter is always used, due to performance reasons.
   * - ToDate: Only return documents older than this date. It's recommended that this filter is always used, due to performance reasons.
   * - UserIDs: Only return documents created by these users. The IDs for this can be gotten by first doing a user search.
   * - FirstName: Filter on documents created by users whose first name starts with this. Achieves the same as filtering on UserIDs, but with one step less. However, due to privacy reasons, this information isn't stored for customers.
   * - FullName: Filter on documents created by users whose full name starts with this. Achieves the same as filtering on UserIDs, but with one step less. However, due to privacy reasons, this information isn't stored for customers.
   * - EmailAddress: Filter on documents created by users whose email starts with this. Achieves the same as filtering on UserIDs, but with one step less. However, due to privacy reasons, this information isn't stored for customers.
   */
  export interface ListEventLedger {
    Query?: string;
    PageConfig?: ScrollablePageConfig<EventLedgerFilters>;
  }

  export interface EventLedgerFilters {
    IDs: string[];
    Types: string[];
    OrderID?: number;
    OrganizationUnitID?: number;
    DeviceID?: number;
    FromDate?: string;
    ToDate?: string;
    UserIDs: number[];
    FinancialPeriodIDs: number[];
    FirstName: string;
    FullName: string;
    EmailAddress: string;
    OrderIDs: number[];
    OnlyAuditedDocuments: boolean;
    Amount: EventLedgerFilters.AmountFilter;
    ExecutionContextName?: string;
  }

  export namespace EventLedgerFilters {
    export interface AmountFilter {
      EqualTo?: number;
      GreaterThan?: number;
      LessThan?: number;
    }

  }

  export interface ListEventLedgerResponse {
    Result: ScrollablePagedResult<EventLedgerDocument>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface EventLedgerDocument {
    ID: string;
    Type: string;
    BackendType: string;
    CreationTime: string;
    OverrideCreationTime?: string;
    IpAddress: string;
    TenantID: string;
    PartitionKey: string;
    Auditing: EventLedgerDocument.AuditingDocument;
    CurrentUser: EventLedgerDocument.CurrentUserDocument;
    Order: EventLedgerDocument.OrderDocument;
    UserTask: EventLedgerDocument.UserTaskDocument;
    DailyTotals: EventLedgerDocument.DailyTotalDocument[];
    ExecutionContext: EventLedgerDocument.ExecutionContextDocument;
    AuthenticationResponse: EventLedgerDocument.AuthenticationResponseDocument;
    PaymentTransaction: EventLedgerDocument.PaymentTransactionDocument;
    FinancialPeriod: EventLedgerDocument.FinancialPeriodDocument;
    Station: EventLedgerDocument.StationDocument;
    Device: EventLedgerDocument.DeviceDocument;
    OrderLines: EventLedgerDocument.OrderLineDocument[];
    Description: string;
    Discount: EventLedgerDocument.DiscountDocument;
    Invoice: EventLedgerDocument.InvoiceDocument;
    Amount?: number;
    Attachments: EventLedgerDocument.AttachmentDocument[];
    MessageTemplate: EventLedgerDocument.MessageTemplateDocument;
    FinancialReportingPeriod: EventLedgerDocument.FinancialReportingPeriodDocument;
    Data: { [key: string]: any };
    BlobID?: string;
    OrganizationUnit: EventLedgerDocument.OrganizationUnitDocument;
    FinancialPeriodAudit: EventLedgerDocument.FinancialPeriodAuditDocument;
    Role: EventLedgerDocument.RoleDocument;
    User: EventLedgerDocument.UserDocument;
    TerminalReport: EventLedgerDocument.TerminalReportDocument;
    CashExpense: EventLedgerDocument.CashExpenseDocument;
    CashDeposit: EventLedgerDocument.CashDepositDocument;
    CashCorrection: EventLedgerDocument.CashCorrectionDocument;
    CashMovement: EventLedgerDocument.CashMovementDocument;
    PriceCorrection: EventLedgerDocument.PriceCorrectionDocument;
    SerialNumber: EventLedgerDocument.SerialNumberDocument;
    Customers: string[];
  }

  export namespace EventLedgerDocument {
    export interface SerialNumberDocument {
      ID: number;
      Number: string;
      ExpectedOrganizationUnitID?: number;
      ExpectedStockLabelID?: number;
      ActualOrganizationUnitID?: number;
      ActualStockLabelID?: number;
    }

    export interface CashDepositDocument {
      ID: number;
      Status: string;
      Number: string;
      Amount: number;
      CurrencyID: string;
      Details: CashDepositDocument.CashDepositDetails;
      SignatureBlobID?: string;
    }

    export namespace CashDepositDocument {
      export interface CashDepositDetails {
        Coins: { [key: number]: number };
        BankNotes: { [key: number]: number };
      }

    }

    export interface CashExpenseDocument {
      ID: number;
      Type: CashExpenseDocument.CashExpenseType;
      Amount: number;
      Description: string;
      TaxCodeID: number;
      TaxRate: number;
      BlobID?: string;
      SignatureBlobID?: string;
    }

    export namespace CashExpenseDocument {
      export interface CashExpenseType {
        ID: number;
        Type: string;
        Name: string;
        Description: string;
      }

    }

    export interface CashCorrectionDocument {
      ID: number;
      CreatedByID: number;
      FinancialPeriodID: number;
      DeviceID?: number;
      Type: string;
      Amount: number;
      Remark: string;
      Reason?: EventLedgerDocument.CashCorrectionReasonDocument;
      CurrencyID?: string;
    }

    export interface CashCorrectionReasonDocument {
      ID: number;
      Name: string;
      BackendID?: string;
    }

    export interface CashMovementDocument {
      ID?: number;
      FinancialPeriodID?: number;
      PaymentTypeID?: number;
      SourceDeviceID?: number;
      DestinationDeviceID?: number;
      CurrencyID?: string;
      Amount?: number;
    }

    export interface PriceCorrectionDocument {
      OrderLineID: number;
      OldValue: number;
      NewValue: number;
    }

    export interface AuditingDocument {
      CumulativeTotalTaxes: number;
      SequenceNumber?: number;
      PreviousSequenceNumber?: number;
      Signature: string;
      PreviousSignature: string;
      Type: string;
      Version: number;
      KeyBlobID?: string;
      ChainID: number;
    }

    export interface AttachmentDocument {
      Name: string;
      Category: string;
      MimeType: string;
      BlobID: string;
      Url: string;
    }

    export interface DailyTotalDocument {
      Description: string;
      ExternalTotal: number;
      ExpectedTotal: number;
      Details: string;
    }

    export interface OrderDocument {
      /**
       * Entity type: Order
       */
      ID: number;
      DisplayID: string;
      Customer: OrderDocument.CustomerDocument;
      HasReturns: boolean;
      CurrencyID: string;
      Type: OrderTypes;
      IsPaid: boolean;
      IsCompleted: boolean;
      IsShipped: boolean;
      IsInvoiced: boolean;
    }

    export namespace OrderDocument {
      export interface CustomerDocument {
        /**
         * Entity type: User
         */
        ID: number;
      }

    }

    export interface OrderLineDocument {
      /**
       * Entity type: OrderLine
       */
      ID: number;
      Description: string;
      /**
       * Entity type: Product
       */
      ProductID?: number;
      TotalQuantityToShip: number;
      QuantityShipped: number;
      QuantityInvoiced: number;
      UnitPrice: number;
      TaxRate: number;
    }

    export interface ShipmentDocument {
      /**
       * Entity type: Shipment
       */
      ID: number;
      TrackingCode: string;
      BackendID: string;
    }

    export interface InvoiceDocument {
      /**
       * Entity type: Invoice
       */
      ID: number;
      ReferencedInvoiceID?: number;
      InvoiceNumber: string;
      FiscalID: string;
      TotalAmount: number;
      InvoiceData: EventLedgerDocument.InvoiceDataDocument[];
    }

    export interface InvoiceDataDocument {
      Type: string;
      Data: string;
    }

    export interface ShipmentLineDocument {
      /**
       * Entity type: ShipmentLine
       */
      ID: number;
      QuantityShipped: number;
    }

    export interface UserTaskDocument {
      /**
       * Entity type: UserTask
       */
      ID: number;
      /**
       * Entity type: User
       */
      UserID?: number;
      StartTime?: string;
      CompletionTime?: string;
      Type: UserTaskDocument.UserTaskTypeDocument;
      Description: string;
    }

    export namespace UserTaskDocument {
      export interface UserTaskTypeDocument {
        ID: number;
        Name: string;
      }

    }

    export interface OrganizationUnitDocument {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
      Type: OrganizationUnitTypes;
    }

    export interface CurrentUserDocument {
      /**
       * Entity type: User
       */
      ID: number;
      FirstName: string;
      FullName: string;
      EmailAddress: string;
      ApplicationID: number;
      LanguageID: string;
      CountryID: string;
      OrganizationUnitID: number;
      StationID?: number;
      Type: UserTypes;
      TimeZone: string;
      OrganizationUnit: EventLedgerDocument.OrganizationUnitDocument;
    }

    export interface ExecutionContextDocument {
      Name: string;
      UserAgent: string;
      ID: string;
      Version: string;
    }

    export interface PaymentTransactionDocument {
      /**
       * Entity type: PaymentTransaction
       */
      ID: number;
      BackendID: string;
      Amount: number;
      PaidAmount: number;
      Description: string;
      Type: PaymentTransactionDocument.PaymentTypeDocument;
      PaymentMethod: string;
      CurrencyID: string;
      AmountToRefund?: number;
      RefundedAmount?: number;
      Status: PaymentStatuses;
    }

    export namespace PaymentTransactionDocument {
      export interface PaymentTypeDocument {
        /**
         * Entity type: PaymentType
         */
        ID: number;
        Name: string;
      }

    }

    export interface StationDocument {
      /**
       * Entity type: Station
       */
      ID: number;
      Name: string;
    }

    export interface DeviceDocument {
      /**
       * Entity type: Device
       */
      ID: number;
      Name: string;
      IpAddress: string;
      Type: DeviceDocument.DeviceTypeDocument;
      OpenCashDrawerReason: DeviceDocument.OpenCashDrawerReasonDocument;
      EcrID: string;
      HardwareID?: string;
      ProxyID?: string;
      GlobalID?: string;
      StationID?: number;
    }

    export namespace DeviceDocument {
      export interface DeviceTypeDocument {
        ID: number;
        IDs: number[];
        Name: string;
        Names: string[];
      }

      export interface OpenCashDrawerReasonDocument {
        ID: number;
        Name: string;
        Description: string;
      }

    }

    export interface DiscountDocument {
      Trigger: DiscountTriggers;
      ActionType: string;
      ActionData: { [key: string]: any };
    }

    export interface MessageTemplateDocument {
      /**
       * Entity type: MessageTemplate
       */
      ID: number;
      Name: string;
      OrganizationUnitID?: number;
      LanguageID: string;
      CountryID: string;
      DestinationID: number;
    }

    export interface FinancialPeriodDocument {
      /**
       * Entity type: FinancialPeriod
       */
      ID: number;
    }

    export interface FinancialReportingPeriodDocument {
      ID: number;
      Type: FinancialReportingPeriodTypes;
      StartDate: string;
      EndDate: string;
    }

    export interface FinancialPeriodAuditDocument {
      /**
       * Entity type: FinancialPeriodAudit
       */
      ID: number;
    }

    export interface RoleDocument {
      /**
       * Entity type: Role
       */
      ID: number;
    }

    export interface UserDocument {
      /**
       * Entity type: User
       */
      ID: number;
      FirstName: string;
      FullName: string;
    }

    export interface TerminalReportDocument {
      CurrencyID: string;
      Number: string;
      Type: TerminalReportType;
      Supplier: Billable;
      Company: Billable;
      Date: string;
      Payments: TerminalReportDocument.Payment[];
      CreditTaxes: TerminalReportDocument.Tax[];
      DebitTaxes: TerminalReportDocument.Tax[];
      Taxes: TerminalReportDocument.Tax[];
      ProductGroups: TerminalReportDocument.ProductGroup[];
      PaymentsPerUser: TerminalReportDocument.PaymentPerUser[];
      CopyReceiptsPrinted: number;
      TotalCopyReceiptsAmount: number;
      ReceiptsPrinted: number;
      CashDrawerOpenings: number;
      ReturnCount: number;
      TotalReturnsAmount: number;
      DiscountCount: number;
      TotalDiscounts: number;
      Change: number;
      GrandTotalCash: number;
      GrandTotal: number;
      GrandTotalNet: number;
      GrandTotalReturns: number;
      OpeningAmount: number;
      ClosingAmount: number;
      CashDepositsTotalAmount: number;
      TotalAmount: number;
    }

    export namespace TerminalReportDocument {
      export interface Payment {
        Type: Payment.Metadata;
        Amount: number;
        Count: number;
      }

      export namespace Payment {
        export interface Metadata {
          ID: number;
          Name: string;
          Code: string;
        }

      }

      export interface Tax {
        Name: string;
        Code: string;
        Rate: number;
        Base: number;
        Amount: number;
      }

      export interface ProductGroup {
        Code: string;
        Amount: number;
        Count: number;
      }

      export interface PaymentPerUser {
        UserID: number;
        EmployeeNumber: string;
        Description: string;
        Amount: number;
        Count: number;
      }

    }

    export interface AuthenticationResponseDocument {
      Result: AuthenticationResults;
    }

  }

  export const enum FinancialReportingPeriodTypes {
    Month = 0,
    FiscalYear = 1
  }

  export const enum TerminalReportType {
    X = 0,
    Z = 1
  }

  export interface Billable {
    AuditingSystemID: string;
    SystemID: string;
    Name: string;
    RegistrationNumber: string;
    TaxRegistrationNumber: string;
    RegistrationCountryID?: string;
    TaxCountryRegion: string;
    PhoneNumber: string;
    Email: string;
    WasteDisposalNumber: string;
    TaxOfficeNumber: string;
    BankAccount?: string;
    Website?: string;
    BIC?: string;
    AuditingFields: { [key: string]: string };
    Address: Address;
    EstablishmentNumber?: string;
    EntityType?: string;
    SocialCapital?: number;
    IndustryCode?: string;
    IsBusinessToBusiness: boolean;
    CustomFields?: string;
    IsWebShop: boolean;
    IsShop: boolean;
  }

  export interface Address {
    Addressee?: string;
    Address1: string;
    Address2: string;
    Number: string;
    City: string;
    PostalCode: string;
    Country: string;
    Region: string;
    CountrySubdivisionID: string;
    State: string;
    Type: AddressType;
  }

  export const enum AddressType {
    Street = 0,
    Postal = 1,
    Billing = 2,
    ShipTo = 3,
    ShipFrom = 4
  }

  /**
   * List available event ledger types.
   */
  export interface GetEventLedgerTypes {
  }

  export interface GetEventLedgerTypesResponse {
    EventLedgerTypes: string[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Lists all `Financial Period Audit` with their possible BlobID's for audition purposes.
   */
  export interface ListFinancialPeriodAudits {
    PageConfig?: PageConfig<ListAuditsFilter>;
  }

  export interface ListAuditsFilter {
    /**
     * The user can see only the audit files for these organization units in case of limited visibility
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs: number[];
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    FiscalYear?: number;
    FiscalMonth?: number;
  }

  export interface ListFinancialPeriodAuditsResponse {
    Result?: PagedResult<FinancialPeriodAuditDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface FinancialPeriodAuditDto {
    /**
     * Entity type: FinancialPeriodAudit
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    StatusID: number;
    /**
     * Entity type: Blob
     */
    BlobID?: string;
    BlobUrl?: string;
    FiscalYear?: number;
    FiscalMonth?: number;
    From?: string;
    To?: string;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    CreatedByFirstName: string;
    CreatedByLastName: string;
    CreationTime: string;
    Blobs: FinancialPeriodAuditBlobDto[];
    Status: FinancialPeriodAuditStatus;
    IsPreview: boolean;
  }

  export interface FinancialPeriodAuditBlobDto {
    Type?: string;
    BlobID: string;
    CreationTime: string;
    Url: string;
  }

  export const enum FinancialPeriodAuditStatus {
    New = 0,
    Processing = 10,
    ProcessingError = 11,
    Processed = 12,
    Exporting = 20,
    ExportingError = 21,
    Exported = 22,
    NothingToBeExported = 999
  }

  /**
   * Sets the lottery number for a given order
   */
  export interface SetLotteryNumber {
    /**
     * Entity type: Order
     */
    OrderID: number;
    LotteryNumber: string;
  }

  /**
   * Validates the given VAT number by the current organization unit auditing provider or by providing a country in the request
   */
  export interface ValidateVatNumber {
    VatNumber: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
  }

  export interface ValidateVatNumberResponse {
    Success: AuditingVatNumberValidationResult;
    Address: string;
    Name: string;
    CountryCode: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Returns all async requests for your current user
   */
  export interface GetAsyncRequestsForUser {
  }

  export interface GetAsyncRequestsForUserResponse {
    Requests: AsyncRequest[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface AsyncRequest {
    ID: string;
    Timestamp: string;
    Type: string;
    ResponseType: string;
    Status: AsyncServiceRequestStatus;
    ResponseBlobUrl: string;
  }

  export const enum AsyncServiceRequestStatus {
    InProgress = 0,
    Completed = 1,
    Failed = 2
  }

  /**
   * Returns a specific async request for your current user
   */
  export interface GetAsyncRequestForUser {
    /**
     * The ID of the async request to retrieve
     */
    ID: string;
  }

  export interface GetAsyncRequestForUserResponse {
    Request: AsyncRequest;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Retrieve configuration settings for the current application as key/value pairs.
   */
  export interface GetApplicationConfiguration {
  }

  export interface GetApplicationConfigurationResponse {
    Configuration: { [key: string]: any };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Return basic information about the application currently in use, including ID and OrganizationUnitID.
   */
  export interface GetCurrentApplication {
  }

  export interface GetCurrentApplicationResponse {
    /**
     * Entity type: Application
     */
    ID: number;
    Name: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    RequiredUserTypeID?: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get a list of all active Applications
   */
  export interface ListApplications {
  }

  export interface ListApplicationsResponse {
    Result: ApplicationDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ApplicationDto {
    /**
     * Entity type: Application
     */
    ID: number;
    Name: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    BaseUrl: string;
    /**
     * Contains the base url where static files should be served from for the application.
     */
    AssetsBaseUrl: string;
  }

  /**
   * Service for retrieving a list of available services
   */
  export interface GetAvailableServices {
  }

  export interface GetAvailableServicesResponse {
    Services: GetAvailableServicesResponse.Service[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetAvailableServicesResponse {
    export interface Service {
      Name: string;
      Type: string;
      Namespace: string;
      Scope?: FunctionalityScope;
      Functionality?: string;
      AllowPublic: boolean;
      AvailableOffline: boolean;
      RequiresElevation: boolean;
      RequiresSudoMode: boolean;
    }

  }

  /**
   * Service for retrieving a list available service details
   */
  export interface GetAvailableServiceDetails {
    Type: string;
  }

  export interface GetAvailableServiceDetailsResponse {
    Description: string;
    Request: GetAvailableServiceDetailsResponse.TypeDefinition;
    Response: GetAvailableServiceDetailsResponse.TypeDefinition;
    Routes: GetAvailableServiceDetailsResponse.Route[];
    AvailableOffline: boolean;
    Deprecation: string;
    Security: GetAvailableServiceDetailsResponse.SecurityInfo;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetAvailableServiceDetailsResponse {
    export interface Route {
      Method: string;
      Path: string;
    }

    export interface SecurityInfo {
      RequiresAuthentication: boolean;
      RequiredFunctionalities: GetAvailableServiceDetailsResponse.FunctionalityInfo[];
      RequiredUserType: UserTypes;
      AllowPublic: boolean;
    }

    export interface FunctionalityInfo {
      Functionality: string;
      Scope: FunctionalityScope;
    }

    export interface TypeDefinition {
      Name: string;
      Description: string;
      Namespace: string;
      Type: string;
      Optional: boolean;
      Deprecation: string;
      Fields: GetAvailableServiceDetailsResponse.TypeDefinition[];
    }

  }

  /**
   * Get the version status of the client compared to the current version of the API. The header EVA-API-Version is required.
   */
  export interface GetCurrentVersion {
  }

  export interface GetCurrentVersionResponse {
    Status: VersionStatus;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum VersionStatus {
    Unknown = 0,
    None = 1,
    Old = 2,
    Ancient = 3
  }

  /**
   * *WARNING* NewBlack only service
   * 
   * Toggle on/off some core features of this environment
   */
  export interface ToggleFeatures {
    CacheRefreshDisabled?: boolean;
    PrefigureDiscountsDisabled?: boolean;
    DiscountEngineDisabled?: boolean;
    SearchUsersDisabled?: boolean;
    SearchProductsDisabled?: boolean;
    WaldoDisabled?: boolean;
    EventExportDisabled?: boolean;
    ScheduledTasksDisabled?: boolean;
    WebshopFinancialPeriodManagementDisabled?: boolean;
    DataSyncToYugabyteDisabled?: boolean;
  }

  export interface ToggleFeaturesResponse {
    CacheRefreshDisabled: boolean;
    PrefigureDiscountsDisabled: boolean;
    DiscountEngineDisabled: boolean;
    SearchUsersDisabled: boolean;
    SearchProductsDisabled: boolean;
    WaldoDisabled: boolean;
    EventExportDisabled: boolean;
    ScheduledTasksDisabled: boolean;
    WebshopFinancialPeriodManagementDisabled: boolean;
    DataSyncToYugabyteDisabled: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Cancel the pending cash PaymentTransactions on the Order to remove the AML checks.
   */
  export interface CancelAMLChecksOnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Validate all AML requirements and finalize the pending PaymentTransactions on the Order.
   */
  export interface FinalizeAMLChecksOnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Force the AML checks to be finalized, even if the requirements are not met.
     */
    Force?: boolean;
  }

  export interface FinalizeAMLChecksOnOrderResponse {
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionIDs: number[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Flag this order to trigger manual AML checks.
   */
  export interface TriggerAMLChecksOnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Flag the Order that the customer has been verified for AML purposes.
   */
  export interface VerifyCustomerOnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * Adds a boarding pass to specified order, by barcode.
   */
  export interface AddBoardingPassToOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Barcode: string;
  }

  /**
   * Create a new Flight object
   */
  export interface CreateFlight {
    Flight: FlightDto;
  }

  export interface FlightDto {
    /**
     * Entity type: Flight
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    AirlineCompanyCode: string;
    FlightNumber: string;
    DestinationCode: number;
    DestinationAirportCode: string;
    FromDate: string;
    ToDate: string;
  }

  export interface CreateFlightResponse {
    /**
     * Entity type: Flight
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update an existing Flight
   */
  export interface UpdateFlight {
    /**
     * Entity type: Flight
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    AirlineCompanyCode?: string;
    FlightNumber?: string;
    DestinationCode?: number;
    DestinationAirportCode?: string;
    FromDate?: string;
    ToDate?: string;
  }

  /**
   * Delete an existing Flight
   */
  export interface DeleteFlight {
    /**
     * Entity type: Flight
     */
    ID: number;
  }

  /**
   * Retrieves an existing Flight
   */
  export interface GetFlight {
    /**
     * Entity type: Flight
     */
    ID: number;
  }

  export interface GetFlightResponse {
    Flight: FlightDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * List all the existing Flights mathing the specified filter
   */
  export interface ListFlights {
    PageConfig?: PageConfig<ListFlightsFilter>;
  }

  export interface ListFlightsFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    AirlineCompanyCode?: string;
    FlightNumber?: string;
    DestinationAirportCode?: string;
  }

  export interface ListFlightsResponse {
    Result?: PagedResult<FlightDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Gets boarding pass information set to given order.
   */
  export interface GetBoardingPass {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetBoardingPassResponse {
    Format: string;
    NumberOfLegs: number;
    Name: string;
    Type: string;
    OperatingCarrierPNRCode: string;
    DepartingAirportCode: string;
    DestinationAirportCode: string;
    AirlineCompanyCode: string;
    FlightNumber: number;
    JulianDate: number;
    Cabin: string;
    Seat: string;
    CheckinSequence: number;
    Status: number;
    Data: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Creates multiple Flight objects for a specific Organization Unit.
   *     The flights are identified from a GRC type file containing the necessary information.
   */
  export interface ImportFlights {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    Data: string;
  }

  /**
   * Download a template format for the flights file to upload.
   */
  export interface DownloadFlightsFileTemplate {
  }

  /**
   * Service for retrieving a list of `AddressBook`
   */
  export interface ListAddressBook {
    PageConfig?: PageConfig<ListAddressBookFilter>;
  }

  export interface ListAddressBookFilter {
    /**
     * Entity type: AddressBook
     */
    ID?: number;
    BackendID?: string;
    DefaultShippingAddress?: boolean;
    DefaultBillingAddress?: boolean;
    DefaultPickupAddress?: boolean;
    /**
     * Entity type: Address
     */
    AddressID?: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    Description?: string;
    /**
     * Entity type: Country
     */
    CountryIDs?: string[];
  }

  export interface ListAddressBookResponse {
    Result?: PagedResult<AddressBookDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface AddressBookDto {
    /**
     * Entity type: AddressBook
     */
    ID?: number;
    BackendID?: string;
    Address?: AddressDto;
    Description?: string;
    DefaultShippingAddress?: boolean;
    DefaultBillingAddress?: boolean;
    DefaultPickupAddress?: boolean;
    CreationTime?: string;
    LastModificationTime?: string;
    CreatedBy?: AddressBookDto.User;
    LastModifiedBy?: AddressBookDto.User;
  }

  export namespace AddressBookDto {
    export interface User {
      /**
       * Entity type: User
       */
      ID?: number;
      FirstName: string;
      LastName: string;
      FullName: string;
    }

  }

  /**
   * Set the given Address Book Item as default BillingAddress for the User of the Address Book
   */
  export interface SetDefaultBillingAddress {
    /**
     * Entity type: AddressBook
     */
    AddressBookID: number;
  }

  /**
   * Set the given Address Book Item as default PickupAddress for the User of the Address Book
   */
  export interface SetDefaultPickupAddress {
    /**
     * Entity type: AddressBook
     */
    AddressBookID: number;
  }

  /**
   * Set the given Address Book Item as default ShippingAddress for the User of the Address Book
   */
  export interface SetDefaultShippingAddress {
    /**
     * Entity type: AddressBook
     */
    AddressBookID: number;
  }

  /**
   * Create a new Address in the AddressBook of an User
   */
  export interface CreateAddressBookItem {
    /**
     * Entity type: User
     */
    UserID?: number;
    BackendID?: string;
    Description?: string;
    Address?: AddressDataDto;
    UseAsDefaultShippingAddress?: boolean;
    UseAsDefaultBillingAddress?: boolean;
    UseAsDefaultPickupAddress?: boolean;
  }

  export interface CreateAddressBookItemResponse {
    /**
     * Entity type: AddressBook
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Update an existing Address in the AddressBook of an User
   */
  export interface UpdateAddressBookItem {
    /**
     * Entity type: AddressBook
     */
    ID: number;
    BackendID?: string;
    Description?: string;
    Address?: AddressDataDto;
    UseAsDefaultShippingAddress?: boolean;
    UseAsDefaultBillingAddress?: boolean;
    UseAsDefaultPickupAddress?: boolean;
  }

  /**
   * Delete an Address in the AddressBook of an User
   * 
   * It's not allowed to delete an address when it's the default and there are more than 1 remaining items in the address book
   */
  export interface DeleteAddressBookItem {
    /**
     * Entity type: AddressBook
     */
    ID: number;
  }

  /**
   * Update an existing Address Requirement object.
   * 
   * This service is using the ID or a PropertyType-CountryID par as input for the finding of the
   * correct address requirement we want to update.
   * If the address requirement is found the visibility and validation of this will be updated.
   */
  export interface UpdateAddressRequirement {
    /**
     * Entity type: AddressRequirement
     */
    ID?: number;
    PropertyType?: PropertyType;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    Visibility?: VisibilityType;
    Validation?: string;
    /**
     * Min: 1
     */
    MinLength?: number;
    /**
     * Min: 1
     */
    MaxLength?: number;
    PredefinedValues?: string[];
  }

  export const enum PropertyType {
    FirstName = 1,
    LastName = 2,
    Address1 = 3,
    Address2 = 4,
    HouseNumber = 6,
    ZipCode = 7,
    Subdistrict = 8,
    District = 9,
    City = 10,
    State = 11,
    CountryID = 12,
    EmailAddress = 13,
    PhoneNumber = 14,
    CountrySubdivisionID = 15,
    Remark = 16
  }

  export const enum VisibilityType {
    Visible = 1,
    NotVisible = 2,
    VisibleAndRequired = 3
  }

  /**
   * Get all available address requirements.
   */
  export interface GetAddressRequirements {
    /**
     * Entity type: Country
     */
    CountryID: string;
    /**
     * When `UseAddressRequirements` isn't enable yet, this boolean can be used to force show the address requirements for configuration purposes.
     */
    ReturnAddressRequirements?: boolean;
  }

  export interface GetAddressRequirementsResponse {
    AddressRequirements: { [key: string]: AddressRequirementDto };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface AddressRequirementDto {
    /**
     * Entity type: AddressRequirement
     */
    ID?: number;
    Visible?: VisibilityType;
    Validation?: string;
    MinLength?: number;
    MaxLength?: number;
    PredefinedValues?: string[];
  }

  /**
   * Service for retrieving a list of suggested addresses
   */
  export interface AutocompleteAddress {
    Query: string;
    Countries?: string[];
    Language?: string;
  }

  export interface AutocompleteAddressResponse {
    Result: AddressSuggestion[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface AddressSuggestion {
    ID: string;
    Reference: string;
    Description: string;
  }

  /**
   * Service for retrieving a `Address` by specifying a Zip Code and House Number.
   * 
   * This only works for addresses in the Netherlands, for a more generic approach look a the AutocompleteAddress service
   */
  export interface GetAddressForZipCode {
    /**
     * Expected format: 9999ZZ
     */
    ZipCode: string;
    HouseNumber: string;
  }

  export interface GetAddressForZipCodeResponse {
    Result: AddressDataDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Service for retrieving address suggestion details by specifying a address suggestion retrieved from `AutocompleteAddress` service
   */
  export interface GetAutocompleteAddressByReference {
    Suggestion: AddressSuggestion;
  }

  export interface GetAutocompleteAddressByReferenceResponse {
    Result?: AddressSuggestionDetails;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface AddressSuggestionDetails {
    Formatted: string;
    Components: AddressSuggestionDetails.Component[];
    Geometry: AddressSuggestionDetails.GeometryDetails;
    UtcOffset: number;
    /**
     * @deprecated Use `Address1` instead
     */
    Street: AddressSuggestionDetails.Component;
    Address1: AddressSuggestionDetails.Component;
    Address2: AddressSuggestionDetails.Component;
    HouseNumber: AddressSuggestionDetails.Component;
    PostalCode: AddressSuggestionDetails.Component;
    Subdistrict: AddressSuggestionDetails.Component;
    District: AddressSuggestionDetails.Component;
    City: AddressSuggestionDetails.Component;
    State: AddressSuggestionDetails.Component;
    Country: AddressSuggestionDetails.Component;
    CountrySubdivision: AddressSuggestionDetails.Component;
    /**
     * @deprecated Use a less generic property - `District`, `Subdistrict` or `State` (or future options `Municipality` or `Province`)
     */
    Region: AddressSuggestionDetails.Component;
    IsValidCountry: boolean;
  }

  export namespace AddressSuggestionDetails {
    export interface Component {
      LongName: string;
      ShortName: string;
      Types: string[];
    }

    export interface GeometryDetails {
      Location: GeometryLocation;
    }

  }

  export interface GeometryLocation {
    Latitude: number;
    Longitude: number;
  }

  /**
   * Get the CountrySubdivisions
   * 
   * Optionally the request can be filtered on countryid
   */
  export interface GetCountrySubdivisions {
    /**
     * Entity type: Country
     */
    CountryID?: string;
  }

  export interface GetCountrySubdivisionsResponse {
    CountrySubdivisions: CountrySubdivisionDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface CountrySubdivisionDto {
    /**
     * Entity type: CountrySubdivision
     */
    ID: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    Name: string;
  }

  /**
   * Gets the full list of countries. When `FetchAll` is set to true, all the `Country` entries are returned, rather than just the ones limited by the `OrganizationUnitCountry` constraint (`false` or `null`, default).
   */
  export interface ListCountries {
    FetchAll?: boolean;
  }

  export interface ListCountriesResponse {
    Result: CountryDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface CountryDto {
    /**
     * Entity type: Country
     */
    ID: string;
    Name: string;
    Code: string;
    Number: number;
    EU: boolean;
    EEA: boolean;
    EFTA: boolean;
  }

  /**
   * Update the addresses on a User
   * 
   * This is deprecated in favour of using the AddressBook services
   */
  export interface UpdateAddress {
    /**
     * Entity type: User
     */
    UserID: number;
    BillToShipping?: boolean;
    ShipToAddress?: AddressDataDto;
    BillToAddress?: AddressDataDto;
  }

  export interface ListUserBoughtProductsFilter {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
  }

  export interface IProductSearchItemPrimaryImage {
    Name: string;
    Type: string;
    Blob: string;
    Url: string;
  }

  export const enum FraudDataType {
    Address = 1,
    IBAN = 2,
    IdentificationDocument = 3
  }

  export interface ListFraudItemsFilter {
    Type?: FraudDataType;
    TypeID?: number;
  }

  export interface ListAssortmentsFilter {
    Name?: string;
    Code?: string;
    /**
     * Entity type: Assortment
     */
    AssortmentIDs?: number[];
  }

  export interface SimpleProductSearchModel {
    Query: string;
    Filters: { [key: string]: FilterModel };
  }

  export interface ListAssortmentProductsFilter {
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    TypeID?: number;
    /**
     * Entity type: Assortment
     */
    AssortmentID?: number;
    /**
     * Entity type: Assortment
     */
    AssortmentIDs?: number[];
    IncludeDeleted?: boolean;
  }

  export interface ListVisibilityGroupsFilter {
    /**
     * Entity type: VisibilityGroup
     */
    IDs?: number[];
    Name?: string;
    Description?: string;
    /**
     * Using this filter will limit the result to a single item.
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export interface ListVisibilityGroupConfigurationsFilter {
    /**
     * Entity type: VisibilityGroup
     */
    FromID?: number;
    /**
     * Entity type: VisibilityGroup
     */
    ToID?: number;
    Orders?: boolean;
    Users?: boolean;
    OrganizationUnits?: boolean;
  }

  export interface UserRequirementProperties {
    Type: string;
    CustomValidators?: { [key: string]: { [key: string]: string } };
  }

  export interface UserRequirementResponse {
    ID: number;
    Display: boolean;
    RequiredFor: UserRequirementFor;
    UserType?: UserTypes;
    AccountType?: UserAccountType;
    Preferred: boolean;
    ShippingMethodID?: number;
    CustomValidators: { [key: string]: any };
  }

  export const enum UserRequirementFor {
    None = 0,
    Create = 1,
    PlaceOrder = 2,
    Payment = 4,
    All = 7
  }

  export interface UserRequirementForSubscriptionResponse {
    Property: string;
    Display: boolean;
    RequiredFor: UserRequirementFor;
    UserType?: UserTypes;
    AccountType?: UserAccountType;
    Preferred: boolean;
    CustomValidators: { [key: string]: any };
  }

  export interface ListSubscriptionOrganizationUnitSetsFilter {
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetIDs?: number[];
    Enabled?: boolean;
  }

  export const enum OrganizationUnitSetTypes {
    System = 0,
    Custom = 1,
    AdHoc = 2
  }

  export const enum SubscriptionType {
    Default = 0,
    Loyalty = 1
  }

  export interface ListSubscriptionUsersFilter {
    /**
     * Entity type: Subscription
     */
    SubscriptionID?: number;
    Status?: SubscriptionStatus;
  }

  export interface ListUserRequirementsFilter {
    /**
     * Entity type: UserRequirement
     */
    IDs?: number[];
    Property?: string;
    /**
     * Entity type: Subscription
     */
    SubscriptionID?: number;
    ShippingMethodID?: number;
    /**
     * Will filter on exact matches
     */
    UserType?: UserTypes;
    /**
     * Will filter on any matches
     */
    OneOfUserTypes?: UserTypes;
    RequiredFor?: UserRequirementFor;
    Preferred?: boolean;
    Display?: boolean;
    /**
     * Entity type: UserRequirementSet
     */
    UserRequirementSetID?: number;
  }

  export interface ListUserRequirementSetsFilter {
    /**
     * Entity type: UserRequirementSet
     */
    IDs?: number[];
    Name?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export interface ListWishlistsFilter {
    /**
     * Entity type: User
     */
    UserID?: number;
    Name?: string;
  }

  export const enum SurveyContext {
    None = 0,
    User = 1,
    Order = 2,
    OrganizationUnit = 3,
    Case = 4,
    Repair = 5
  }

  export interface ListSurveyFilter {
    Name?: string;
    BackendID?: string;
    SurveyTrigger?: string;
    Description?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * You can filter surveys based on their deactivation reason.The array is interpreted as an 'or' value list
     * To get surveys with a specific deactivation reason, only provide the deactivation reason you want. For example:
     * - providing an empty value will return all surveys
     * - providing `None` (0) will return surveys that are active.
     * - providing `Unpublished` (1) will return surveys that are inactive because they are unpublished.
     * - providing `Unpublished` (1) and `DeactivatedByUser` (2) will return surveys that are inactive because they are either unpublished OR deactivated by user.
     * - providing `Unpublished` (1) and `DeactivatedByUser` (2) as a combined flag (3) will return surveys that are inactive because they are unpublished AND deactivated by user.
     */
    DeactivationReasons?: SurveyDeactivationReasons[];
    TimeRange?: ListSurveyFilter.TimeRangeDto;
  }

  export namespace ListSurveyFilter {
    export interface TimeRangeDto {
      StartDate?: string;
      EndDate?: string;
    }

  }

  export const enum SurveyDeactivationReasons {
    None = 0,
    Unpublished = 1,
    DeactivatedByUser = 2,
    BySurveyTimeFrame = 4
  }

  export interface BlobDto {
    Url: string;
    MimeType: string;
  }

  export interface SurveyAfterEffectDto {
    /**
     * Entity type: SurveyAfterEffect
     */
    ID?: number;
    Type: string;
    Data: any;
  }

  export const enum CustomFieldDataTypes {
    String = 0,
    Bool = 1,
    /**
     * Whole numbers, no fractions
     */
    Integer = 2,
    Decimal = 3,
    Enum = 4,
    /**
     * Multiline string
     */
    Text = 5,
    DateTime = 6,
    Date = 7,
    Blob = 8
  }

  export interface SurveyQuestionRouteFilter {
    FilterType: CustomFieldFilterType;
    Filters: SurveyQuestionRouteFilter[];
    Conditions: SurveyQuestionRouteFilterCondition[];
  }

  export interface SurveyQuestionRouteFilterCondition {
    Operator: CustomFieldValueOperator;
    CustomFieldValue: CustomFieldValue;
  }

  export const enum CustomFieldValueOperator {
    Equals = 0,
    NotEquals = 1,
    LowerThan = 2,
    LowerThanOrEqualTo = 3,
    HigherThanOrEqualTo = 4,
    HigherThan = 5,
    Contains = 7,
    DoesNotContain = 8,
    StartsWith = 9,
    DoesNotStartWith = 10,
    EndsWith = 11,
    DoesNotEndWith = 12,
    HasValue = 13,
    DoesntHaveValue = 14
  }

  export const enum SurveyQuestionType {
    Question = 0,
    Statement = 1
  }

  export const enum SurveyResponseStatus {
    Open = 0,
    Started = 1,
    Completed = 2,
    Cancelled = 3,
    Terminated = 4
  }

  export interface StockMutationFilters {
    ID?: number;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    MutationQuantity?: number;
    Remark: string;
    /**
     * Entity type: StockLabel
     */
    SourceStockLabelID?: number;
    /**
     * Entity type: StockLabel
     */
    DestinationStockLabelID?: number;
    /**
     * Entity type: StockMutationReasons
     */
    ReasonIDs: number[];
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    FromDate?: string;
    ToDate?: string;
    /**
     * Entity type: User
     */
    UserIDs: number[];
    /**
     * Entity type: Order
     */
    OrderIDs: number[];
    AutoCorrectedQuantities?: boolean;
    SerialNumbers: string[];
  }

  export interface SearchStockMutationResult {
    /**
     * Entity type: StockMutation
     */
    ID: number;
    CreationTime: string;
    Product: SearchStockMutationResult.ProductResult;
    OrganizationUnit: SearchStockMutationResult.IdNameValue;
    SourceStockLabel: SearchStockMutationResult.IdNameValue;
    DestinationStockLabel: SearchStockMutationResult.IdNameValue;
    MutationQuantity: number;
    AutomaticCorrectionQuantity: number;
    UnitCost: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    Reason: SearchStockMutationResult.ReasonResult;
    Type: SearchStockMutationResult.IdNameValue;
    Remark: string;
    OrderLine: SearchStockMutationResult.OrderLineResult;
    UserTask: SearchStockMutationResult.UserTaskResult;
    ShipmentLine: SearchStockMutationResult.ShipmentLineResult;
    CreatedBy: SearchStockMutationResult.UserResult;
    SerialNumber?: string;
  }

  export namespace SearchStockMutationResult {
    export interface IdNameValue {
      /**
       * Entity type: Enum
       */
      ID: number;
      Name: string;
    }

    export interface UserResult {
      /**
       * Entity type: User
       */
      ID: number;
      EmailAddress: string;
      FirstName: string;
      LastName: string;
    }

    export interface ProductResult {
      /**
       * Entity type: Product
       */
      ID: number;
      CustomID: string;
      BackendID: string;
      PrimitiveName: string;
      Content?: any;
    }

    export interface OrderLineResult {
      /**
       * Entity type: OrderLine
       */
      ID?: number;
      OrderID?: number;
      OrderDisplayID?: string;
    }

    export interface UserTaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Type: SearchStockMutationResult.IdNameValue;
    }

    export interface ShipmentLineResult {
      /**
       * Entity type: ShipmentLine
       */
      ID: number;
      Shipment: SearchStockMutationResult.ShipmentResult;
    }

    export interface ShipmentResult {
      /**
       * Entity type: Shipment
       */
      ID: number;
      TrackingCode: string;
    }

    export interface ReasonResult {
      /**
       * Entity type: StockMutationReasons
       */
      ID: number;
      Name: string;
      BackendID: string;
    }

  }

  export interface ListStockMutationReasonsModelFilters {
    Name?: string;
    Query?: string;
    /**
     * Entity type: StockMutationReasons
     */
    IDs?: number[];
  }

  export interface ListCumulativeStockFilter {
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    OrganizationUnitType?: OrganizationUnitTypes;
    OrganizationUnitName: string;
    HasStock?: boolean;
  }

  export const enum StockAllocationRuleValueTypes {
    Quantity = 0,
    Percentage = 1
  }

  export const enum StockAllocationRuleTypes {
    Reservation = 0,
    Limitation = 1
  }

  export interface ListStockAllocationRulesFilter {
    /**
     * Entity type: OrganizationUnitSupplier
     */
    OrganizationUnitSupplierID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export interface ListStockAllocationRulesItem {
    /**
     * Entity type: StockAllocationRule
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID: number;
    SupplierOrganizationUnitName: string;
    /**
     * Entity type: OrganizationUnitSupplier
     */
    OrganizationUnitSupplierID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    Value: number;
    ValueType: StockAllocationRuleValueTypes;
    RefillPeriodInDays?: number;
    LastRefill?: string;
    Type: StockAllocationRuleTypes;
    StartDate?: string;
    EndDate?: string;
    Priority?: number;
  }

  export interface ListCarriersFilter {
    Name: string;
  }

  export interface ListShippingMethodsFilter {
    /**
     * Entity type: Carrier
     */
    CarrierID?: number;
    Name?: string;
    Code?: string;
    CarrierName?: string;
  }

  export interface ListOrganizationUnitShippingMethodsFilter {
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
  }

  export interface ListShippingCostsFilter {
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
  }

  export interface ListTransportationTimesFilter {
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    FromCountryID?: string;
    ToCountryID?: string;
    TimeInDays?: number;
  }

  export interface ShippingMethodTransportationTimeItem {
    /**
     * Entity type: ShippingMethodTransportationTime
     */
    ID: number;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    ShippingMethodName?: string;
    FromCountryID?: string;
    ToCountryID?: string;
    TimeInDays: number;
  }

  export const enum ShippingRestrictionType {
    SoldFromOrganizationUnit = 0,
    ShipFromOrganizationUnit = 1
  }

  export interface ListShippingRestrictionsFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    ProductPropertyTypeID?: string;
    Type?: ShippingRestrictionType;
    ZipCodeFrom?: string;
    ZipCodeTo?: string;
  }

  export interface ListUserOrganizationUnitRolesFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface ListRolesFilter {
    /**
     * Entity type: Role
     */
    IDs?: number[];
    Name?: string;
    Code?: string;
    UserTypeID?: number;
    DeactivateUserAfterInactiveDays?: number;
    Functionalities?: ListRolesFilter.RoleFilterFunctionality[];
    ExactFunctionalitiesOnly?: boolean;
  }

  export namespace ListRolesFilter {
    export interface RoleFilterFunctionality {
      Functionality: string;
      Scope?: FunctionalityScope;
    }

  }

  export interface ListRoleSetsFilter {
    Name?: string;
    BackendID?: string;
  }

  export interface ListProductSubscriptionsFilter {
    /**
     * The ProductSubscriptionID
     * Entity type: ProductSubscription
     */
    ProductSubscriptionID?: number;
    /**
     * The ProductSubscription BackendID
     */
    ProductSubscriptionBackendID?: string;
    /**
     * The ProductSubscription ProductID
     * Entity type: Product
     */
    ProductSubscriptionProductID?: number;
    /**
     * The ProductSubscription Product BackendID
     * @deprecated Filtering by product backendID is not supported.
     */
    ProductSubscriptionProductBackendID?: string;
    /**
     * The ProductSubscription Name
     * @deprecated Use ProductSubscriptionName
     */
    ProductSubscriptionProductName?: string;
    /**
     * The ProductSubscription Name
     */
    ProductSubscriptionName?: string;
  }

  export interface ProductSubscriptionProductInfo {
    /**
     * Entity type: Product
     */
    ID: number;
    Content: any;
    BackendID: string;
  }

  export interface ListProductBarcodesFilter {
    ProductID?: number;
    Barcode: string;
    UnitOfMeasureID?: number;
    IsSupplierProduct?: boolean;
    Origin?: ProductBarcodeOrigin;
  }

  export const enum ProductBarcodeOrigin {
    Imported = 0,
    UserDefined = 1
  }

  export const enum ProductRequirementDataTypes {
    String = 0,
    Bool = 1,
    Integer = 2,
    Decimal = 3,
    Enum = 4,
    Text = 5
  }

  export interface ProductRequirementOptions {
    EnumValues?: { [key: string]: string };
    IsArray?: boolean;
    IsRequired?: boolean;
  }

  export interface ListProductRequirementsFilter {
    /**
     * Entity type: Product
     */
    ProductID?: number;
    Name?: string;
    DataType?: ProductRequirementDataTypes;
    OrderType?: OrderTypes;
    IsArray?: boolean;
    IsRequired?: boolean;
    Handler?: string;
    BackendID?: string;
  }

  export interface ProductSearchTemplateFilters {
    Name?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
  }

  export const enum ProductSearchTemplateTypes {
    Uncached = 0,
    Cached = 1,
    Static = 2
  }

  export interface ListProductUnitOfMeasuresFilter {
    ProductID?: number;
    UnitOfMeasureID?: number;
    Quantity?: number;
  }

  export interface ListSupplierProductsFilter {
    SupplierOrganizationUnitID: number;
    BackendID: string;
    PrimitiveName: string;
  }

  export interface ListPriceListsForOrganizationUnitFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: PriceList
     */
    PriceListID?: number;
    /**
     * Entity type: PriceListUsageType
     */
    PriceListUsageTypeID?: number;
    IncludeInheritedOrganizationUnits: boolean;
  }

  export interface ListProductPriceLedgerFilter {
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    /**
     * Entity type: PriceList
     */
    PriceListID?: number;
    /**
     * Entity type: PriceListUsageType
     */
    PriceListUsageTypeID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs: number[];
    FromDate?: string;
  }

  export interface RoundingData {
    Targets: RoundingData.RoundingTarget[];
    Direction: RoundingDirection;
    MaximumTolerance?: number;
  }

  export namespace RoundingData {
    export interface RoundingTarget {
      Amount: number;
      Direction?: RoundingDirection;
      AmountType: RoundingAmountType;
      MaximumTolerance?: number;
    }

  }

  export const enum RoundingDirection {
    Closest = 0,
    Up = 1,
    Down = 2
  }

  export const enum RoundingAmountType {
    Fraction = 0,
    Divisor = 1
  }

  export const enum PriceListAdjustmentSystemType {
    Default = 0,
    SecondChance = 1
  }

  export interface ListPriceListAdjustmentsFilter {
    /**
     * Entity type: PriceList
     */
    PriceListID?: number;
    /**
     * Entity type: PriceListAdjustment
     */
    ParentID?: number;
    Type: string;
  }

  export interface ListPriceListsFilter {
    Name: string;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    IncludingVat?: boolean;
    IsActive?: boolean;
    /**
     * Only show price lists that are used somewhere with this usage type. Can be combined with a filter on `OrganizationUnitSetID` to only show pricelists that are used with a specific usagetype in specific organizationunits.
     * Entity type: PriceListUsageType
     */
    PriceListUsageTypeID?: number;
    /**
     * Only show price lists that are used in this organizationunit set. Can be combined with a filter on `PriceListUsageTypeID` to only show pricelists that are used with a specific usagetype in specific organizationunits.
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
  }

  export interface ListManualInputAdjustmentsFilter {
    /**
     * Entity type: PriceListAdjustment
     */
    PriceListAdjustmentID: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    IsActive?: boolean;
  }

  export interface ListPriceListOrganizationUnitsFilter {
    /**
     * Entity type: PriceList
     */
    PriceListID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    TargetOrganizationUnitID?: number;
    /**
     * Entity type: PriceListUsageType
     */
    PriceListUsageTypeID?: number;
  }

  export interface ListPersonalizedPromotionsFilter {
    Name: string;
    Description: string;
    BackendID: string;
    LockAfterFirstApply?: boolean;
  }

  export interface ListSettlementFilesFilter {
    Name?: string;
    Status?: PaymentTransactionSettlementFileStatus;
    Handler?: string;
  }

  export const enum PaymentTransactionSettlementFileStatus {
    New = 0,
    Processing = 1,
    Processed = 2,
    Failed = -10
  }

  export interface ListSettlementsFilter {
    /**
     * Entity type: PaymentTransactionSettlementFile
     */
    SettlementFileID?: number;
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID?: number;
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: PaymentTransactionSettlementType
     */
    Type?: number;
    Offset1?: string;
    Offset2?: string;
    Offset3?: string;
    Offset4?: string;
  }

  export interface ListPaymentTransactionCapturesFilter {
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    Statuses?: PaymentTransactionCaptureStatuses[];
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    IsSettled?: boolean;
  }

  export const enum PaymentTransactionCaptureStatuses {
    /**
     * Payment Transaction Capture is created, but not yet communicated with the PSP.
     */
    New = 0,
    /**
     * The PSP is aware of the payment transaction capture and allows (or is) processing it.
     */
    Pending = 1,
    /**
     * The PSP has confirmed that the payment capture is complete.
     */
    Confirmed = 10,
    /**
     * The PSP has confirmed that the capture has failed.
     */
    Failed = -1
  }

  export interface ListPaymentTransactionsFilter {
    /**
     * Entity type: PaymentType
     */
    TypeIDs?: number[];
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: Device
     */
    DeviceID?: number;
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    /**
     * Only works with `OrganizationUnitID`.
     */
    IncludeChildOrganizationUnits?: boolean;
    BackendID?: string;
    BackendSystemID?: string;
    Statuses?: PaymentStatuses[];
    MinAmount?: number;
    MaxAmount?: number;
    MinPaidAmount?: number;
    MaxPaidAmount?: number;
    MinSettledAmount?: number;
    MaxSettledAmount?: number;
    IsSettled?: boolean;
    FromDate?: string;
    ToDate?: string;
    SettlementOffset1?: string;
    SettlementOffset2?: string;
    SettlementOffset3?: string;
    SettlementOffset4?: string;
  }

  export interface ListOrganizationUnitSetPaymentTypesFilter {
    /**
     * Entity type: PaymentType
     */
    PaymentTypeID?: number;
    PaymentTypeName?: string;
    PaymentTypeCode?: string;
    PaymentMethodName?: string;
    PaymentMethodCode?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetIDs?: number[];
    RefundPriority?: number;
    CaptureMoment?: PaymentTypeCaptureMoment;
    DisableForCarryOutOrders?: boolean;
    DisableForReserveOrders?: boolean;
    DisableForDeliveryOrders?: boolean;
    IsActive?: boolean;
  }

  export interface ListPaymentMethodsFilter {
    Name?: string;
    Code?: string;
    IsCustom?: boolean;
  }

  export const enum PaymentReturnActions {
    Default = 0,
    Blocked = 1,
    Forced = 2
  }

  export const enum PaymentTypeCategory {
    Other = 0,
    Debit = 1,
    Credit = 2,
    Cash = 3,
    Voucher = 4,
    Online = 5,
    Rounding = 6,
    Exchange = 7
  }

  export interface PaymentTypeOptions {
    PspType?: string;
    PspSubType?: string;
    /**
     * Entity type: GiftCardConfiguration
     */
    GiftCardConfigurationID?: number;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    PinHandler?: string;
    PinManualKeyEntry?: boolean;
    RequiredUserType?: UserTypes;
    RequiredFunctionality?: string;
    RequiredFunctionalityScope?: FunctionalityScope;
    Pending?: boolean;
    RefundPending?: boolean;
    /**
     * Setting this to false results in refund only, will therefor only work with CanBeRefunded:true and CanRefundWithoutOriginalPaymentTransaction:true
     */
    CanBeUsedForPayments?: boolean;
    CanBeRefunded?: boolean;
    CanBeCancelled?: boolean;
    CanRefundWithoutOriginalPaymentTransaction?: boolean;
    RequiresInteractionForRefunds?: boolean;
    RequiresAmount?: boolean;
    RequiresConfirmationForPayments?: boolean;
    RequiresConfirmationForRefunds?: boolean;
    OnlyAvailableInLocalMode?: boolean;
    BlockOverPayments?: boolean;
  }

  export interface ListPaymentTypesFilter {
    /**
     * Entity type: PaymentType
     */
    IDs?: number[];
    Name?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    IsActive?: boolean;
    IsRoundingType?: boolean;
    PrintOnDocuments?: boolean;
    ReturnAction?: PaymentReturnActions;
    AutoFinalizeOnOrderPaid?: boolean;
    CashJournalMethod?: PaymentCashJournalMethod;
    Code?: string;
    /**
     * Entity type: PaymentMethod
     */
    PaymentMethodID?: number;
    PaymentMethodName?: string;
    PaymentMethodCode?: string;
    PaymentMethodIsCustom?: boolean;
    BackendID?: string;
  }

  export interface OrganizationUnitSetDefinition {
    CountryFilter?: OrganizationUnitSetDefinition.FilterDefinition;
    LanguageFilter?: OrganizationUnitSetDefinition.FilterDefinition;
    TypeFilter?: OrganizationUnitTypes;
  }

  export namespace OrganizationUnitSetDefinition {
    export interface FilterDefinition {
      Values: string[];
      /**
       * @default false
       */
      Negate?: boolean;
    }

  }

  export const enum OrganizationUnitSetOperatorTypes {
    Add = 0,
    Remove = 1
  }

  export interface ListOrganizationUnitSetsFilter {
    Name?: string;
    BackendID?: string;
    NameOrBackendID?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    ID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    IDs?: number[];
    HasSubsets?: boolean;
    Types?: OrganizationUnitSetTypes[];
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Return only sets that contain all the given OrganizationUnits
     * Entity type: OrganizationUnit
     */
    ContainingOrganizationUnitIDs?: number[];
    IncludedOrganizationUnitTypes?: OrganizationUnitTypes;
    ExcludedOrganizationUnitTypes?: OrganizationUnitTypes;
    /**
     * Entity type: OrganizationUnitSetScope
     */
    ScopeID?: number;
    IncludeWithoutScopeID?: boolean;
    Functionality?: string;
    FunctionalityScope?: FunctionalityScope;
  }

  export interface ListOrganizationUnitSetsItem {
    /**
     * Entity type: OrganizationUnitSet
     */
    ID: number;
    BackendID?: string;
    Name: string;
    GlobalID: string;
    Description: string;
    Type: OrganizationUnitSetTypes;
    OrganizationUnitCount: number;
    OrganizationUnitSubsetCount: number;
    /**
     * Entity type: OrganizationUnitSetScope
     */
    ScopeID?: number;
    ScopeName: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OrganizationUnitBackendID?: string;
  }

  export interface ListCashHandlersFilter {
    Name: string;
    CurrencyID: string;
  }

  export interface OrganizationUnitCurrencyFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    IncludeInheritedOrganizationUnits?: boolean;
  }

  export interface ListOldOpeningHoursFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: OpeningHoursType
     */
    TypeIDs?: number[];
    DayOfWeeks?: DayOfWeek[];
    /**
     * Inclusive
     */
    StartDate?: string;
    /**
     * Inclusive
     */
    EndDate?: string;
    /**
     * When the OpeningHour has no date, but only a weekday
     */
    IsRegular?: boolean;
    IsActive?: boolean;
  }

  export interface OpeningHoursDataDto {
    /**
     * Entity type: OpeningHoursType
     */
    TypeID?: number;
    TypeName?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Only set when returned outside OrganizationUnit context
     */
    OrganizationUnitName?: string;
    DayOfWeek?: DayOfWeek;
    StartTime?: string;
    EndTime?: string;
    Date?: string;
    Description?: string;
    IsSpecial?: boolean;
    IsClosed?: boolean;
    IsActive?: boolean;
  }

  export interface ListCheckoutOptionCategoriesFilter {
    Name?: string;
  }

  export interface ListRefundCorrectionReasonsFilter {
    Name?: string;
    Description?: string;
    BackendID?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitSetIDs?: number[];
  }

  export interface ListUnitPriceCorrectionReasonsFilter {
    Name?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitSetIDs?: number[];
  }

  export const enum ReturnReasonRemarkType {
    Hidden = 0,
    Show = 1,
    Required = 2
  }

  export const enum MessageTemplateTypes {
    Template = 1,
    Partial = 2,
    Layout = 3
  }

  export const enum MessageTemplateDestinations {
    Mail = 1,
    Sms = 2,
    Pdf = 4,
    Thermal = 8,
    Notification = 16,
    Http = 32
  }

  export interface MessageTemplateFilter {
    Name?: string;
    ExactName?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    TypeID?: MessageTemplateTypes;
    DestinationID?: MessageTemplateDestinations;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export const enum MessageTargetContentTypes {
    Html = 0,
    Pdf = 1,
    Plain = 2,
    Png = 3
  }

  export interface ListLoyaltyProgramsFilter {
    /**
     * Entity type: LoyaltyProgramGroup
     */
    LoyaltyProgramGroupID?: number;
    Name?: string;
    BackendID?: string;
    Handler?: string;
    Options?: LoyaltyProgramOptions;
    LoyaltyPointUsageOptions?: LoyaltyPointUsageOptions;
    Status?: LoyaltyProgramStatus;
    /**
     * Entity type: Company
     */
    CompanyID?: number;
  }

  export const enum LoyaltyProgramUsageTypes {
    None = 0,
    AllowAwarding = 1,
    UsableAsPaymentMethod = 2,
    UsableForWithdraw = 4
  }

  export const enum LoyaltyProgramStatus {
    Inactive = 0,
    Active = 1
  }

  export const enum LoyaltyProgramDeactivationReasons {
    None = 0,
    DeactivatedByGroup = 1,
    ManuallyDeactivated = 2,
    TimeFrame = 4,
    BudgetReached = 8
  }

  export interface ListLoyaltyProgramGroupFilter {
    Name?: string;
    BackendID?: string;
    Status?: LoyaltyProgramStatus;
    DeactivationReason?: LoyaltyProgramGroupDeactivationReasons;
  }

  export const enum LoyaltyProgramGroupDeactivationReasons {
    None = 0,
    ManuallyDeactivated = 1,
    TimeFrame = 2,
    BudgetReached = 4
  }

  export const enum LoyaltyPaymentTaxHandlingType {
    InTax = 0,
    UpToTax = 1
  }

  export const enum UserBudgetDeduction {
    None = 0,
    Program = 1,
    PaymentMethod = 2,
    Both = 3
  }

  export interface ListPointAwardingRuleFilter {
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    Name?: string;
    BackendID?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Enabled?: boolean;
  }

  export interface ListInquiriesFilter {
    Name?: string;
    Description?: string;
  }

  export interface ListGiftCardConfigurationsFilter {
    Name?: string;
    Handler?: string;
    UsageType?: GiftCardConfigurationUsageTypes;
  }

  export interface ListProductGiftCardsFilter {
    /**
     * Entity type: GiftCardConfiguration
     */
    GiftCardConfigurationID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    Type?: string;
  }

  export interface ListExchangeRatesFilter {
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    /**
     * Entity type: Currency
     */
    BaseCurrencyID?: string;
  }

  export interface ListCashExpenseTypesFilter {
    Name?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetIDs?: number[];
  }

  export interface ListCashCorrectionReasonsFilter {
    Name?: string;
    BackendID?: string;
  }

  export interface ListProductCostPriceLedgerFilter {
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    FromDate?: string;
    ToDate?: string;
  }

  export interface ListProductCostPriceLedgerItem {
    ID: number;
    CreationTime: string;
    /**
     * Entity type: Product
     */
    ProductID: number;
    ProductBackendID: string;
    ProductName: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    /**
     * Entity type: Order
     */
    OrderID: number;
    OrderDisplayID?: string;
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID: number;
    StockLabelName: string;
    CurrencyID: string;
    Quantity: number;
    UnitCost: number;
  }

  export interface ListStockMutationUnitCostSourceLedgerFilter {
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    /**
     * Entity type: OrderLine
     */
    SourceOrderLineID?: number;
    /**
     * Entity type: Order
     */
    SourceOrderID?: number;
    /**
     * Entity type: OrderLine
     */
    DestinationOrderLineID?: number;
    /**
     * Entity type: Order
     */
    DestinationOrderID?: number;
    /**
     * Entity type: StockMutation
     */
    StockMutationID?: number;
  }

  export interface ListStockMutationUnitCostSourceLedgerItem {
    ID: number;
    /**
     * Entity type: StockMutation
     */
    StockMutationID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    ProductBackendID: string;
    ProductName: string;
    MutationQuantity: number;
    Quantity: number;
    OldQuantity: number;
    NewQuantity: number;
    UnitCost: number;
    /**
     * Entity type: Order
     */
    SourceOrderID?: number;
    /**
     * Entity type: OrderLine
     */
    SourceOrderLineID?: number;
    /**
     * Entity type: Order
     */
    DestinationOrderID?: number;
    /**
     * Entity type: OrderLine
     */
    DestinationOrderLineID?: number;
    CreationTime: string;
    OrganizationUnitName: string;
    StockLabelName: string;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
  }

  export const enum EntityFieldValidatorEntityTypes {
    PriceList = 1,
    PriceListAdjustment = 2
  }

  export const enum EntityFieldValidatorType {
    DefaultValidator = 0,
    StringValidator = 1
  }

  export const enum EntityFieldValidatorUserTypes {
    Employee = 1,
    Customer = 2,
    Api = 4,
    All = 7
  }

  export interface ListEntityFieldValidatorsFilter {
    Entity?: EntityFieldValidatorEntityTypes;
    UserTypes?: EntityFieldValidatorUserTypes;
  }

  export const enum EndpointConfigurationStatus {
    Enabled = 1,
    Disabled = 2,
    Error = 3
  }

  export interface ListDiscountCampaignsFilter {
    Name?: string;
    StartDate?: string;
    EndDate?: string;
    BackendSystemID?: string;
    BackendID?: string;
    BudgetCurrencyID?: string;
  }

  export interface ListDiscountCouponsFilter {
    CouponCode?: string;
    /**
     * Entity type: Discount
     */
    DiscountID?: number;
  }

  export interface ListDiscountLayerFilter {
    Name: string;
    IsExclusive?: boolean;
  }

  export const enum DiscountOrderTypes {
    None = 0,
    Sales = 1,
    Purchase = 2,
    All = 3
  }

  export const enum DaysOfWeek {
    None = 0,
    Monday = 1,
    Tuesday = 2,
    Wednesday = 4,
    Thursday = 8,
    Friday = 16,
    Saturday = 32,
    Sunday = 64,
    All = 127
  }

  export const enum DiscountConditionTypes {
    OneOf = 0,
    All = 1
  }

  export const enum FinancialDespersionType {
    DivideInProportionToProductPrice = 0,
    MostExpensiveToCheapest = 1,
    CheapestToMostExpensive = 2,
    HighestToLowestTaxRate = 3,
    LowestToHighestTaxRate = 4
  }

  export const enum DiscountUserUsagePeriodType {
    Day = 0,
    Week = 1,
    Month = 2,
    Year = 3
  }

  export const enum DiscountCompliancyRule {
    None = 0,
    EmployeeDiscountTaxExclusion = 1
  }

  export interface CustomFieldValidationErrorData {
    /**
     * Entity type: CustomField
     */
    Errors: { [key: number]: CustomFieldValidationErrorData.Error };
    /**
     * Entity type: CustomField
     */
    CustomFieldOptions: { [key: number]: CustomFieldOptions };
  }

  export namespace CustomFieldValidationErrorData {
    export interface Error {
      Type: string;
      Message: string;
    }

  }

  export interface SearchDiscountsByQueryFilter {
    /**
     * Entity type: Discount
     */
    ID?: number;
    /**
     * You can filter discounts based on their deactivation reason.The array is interpreted as an 'or' value list
     * To get discounts with a specific deactivation reason, only provide the deactivation reason you want. For example:
     * - providing an empty value will return all discounts
     * - providing `None` (0) will return discounts that are active.
     * - providing `Unverified` (1) will return discounts that are inactive because they are unverified.
     * - providing `Unverified` (1) and `DisabledByUser` (2) will return discounts that are inactive because they are either unverified OR disabled by user.
     * - providing `Unverified` (1) and `DisabledByUser` (2) as a combined flag (3) will return discounts that are inactive because they are unverified AND disabled by user.
     */
    DeactivationReasons: DiscountDeactivationReasons[];
    DiscountTriggerIDs: DiscountTriggers[];
    Description: string;
    CouponCode: string;
    /**
     * The name of the user who created the discount
     */
    CreatedBy: string;
    BackendID: string;
    OrderType?: OrderTypes;
    /**
     * The discount layer
     * Entity type: DiscountLayer
     */
    LayerID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * If true, the search will also include all child organization units of the specified OrganizationUnitID.
     */
    IncludeChildOrganizationUnits: boolean;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
    /**
     * Entity type: DiscountTemplate
     */
    DiscountTemplateID?: number;
    /**
     * Entity type: DiscountCampaign
     */
    DiscountCampaignID?: number;
    ActiveRange?: SearchDiscountsByQueryFilter.DiscountActiveRange;
    HasRestitutionOrganizationUnit?: boolean;
    /**
     * Entity type: OrganizationUnit
     */
    RestitutionOrganizationUnitID?: number;
  }

  export namespace SearchDiscountsByQueryFilter {
    export interface DiscountActiveRange {
      StartDate?: string;
      EndDate?: string;
    }

  }

  export const enum DiscountDeactivationReasons {
    None = 0,
    Unverified = 1,
    DisabledByUser = 2,
    ByDiscountUsage = 4,
    ByDiscountBudget = 8,
    ByDiscountTimeFrame = 16,
    ByDiscountCampaignBudget = 32,
    ByDiscountCampaignTimeFrame = 64
  }

  export interface ListDiscountTemplatesFilter {
    Description?: string;
    TriggerIDs?: DiscountTriggers[];
    ActionType?: string;
    IsActive?: boolean;
  }

  export interface ListCustomFieldsFilter {
    /**
     * Entity type: CustomFieldType
     */
    TypeID?: number;
    TypeKey?: string;
    Name?: string;
    DataType?: CustomFieldDataTypes;
    BackendID?: string;
  }

  export interface ListCustomFieldOptionsFilter {
    /**
     * Entity type: CustomField
     */
    CustomFieldID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
  }

  export interface CultureFilter {
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
  }

  export interface OrganizationUnitCountryFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    CountryID: string;
    IncludeInheritedOrganizationUnits: boolean;
  }

  export interface OrganizationUnitLanguageFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    LanguageID: string;
    IncludeInheritedOrganizationUnits: boolean;
  }

  export interface ListAppSettingsFilter {
    Name?: string;
    App?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
  }

  export const enum SettingRemovalReason {
    Untyped = 0,
    DeletedOrganizationUnit = 1,
    ParentHasSameValue = 2,
    ValueIsSameAsDefault = 3,
    ArchivedOrganizationUnit = 4
  }

  export interface SettingModel {
    Reason: SettingRemovalReason;
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    Key: string;
    Value: string;
  }

  export interface AppSettingAutocompleteInfo {
    Name: string;
    Description: string;
    DataType: string;
    Default: string;
    Options: string[];
    Converted?: boolean;
  }

  export const enum SettingSensitivityTypes {
    Normal = 0,
    Sensitive = 1,
    Masked = 2,
    Encrypted = 6,
    CloudOnly = 8
  }

  export const enum SettingValueEntityTypes {
    None = 0,
    OrganizationUnit = 1
  }

  export interface DateTimeOffset {
    DateTime: string;
    UtcDateTime: string;
    LocalDateTime: string;
    Date: string;
    Day: number;
    DayOfWeek: DayOfWeek;
    DayOfYear: number;
    Hour: number;
    Millisecond: number;
    Microsecond: number;
    Nanosecond: number;
    Minute: number;
    Month: number;
    Offset: string;
    TotalOffsetMinutes: number;
    Second: number;
    Ticks: number;
    UtcTicks: number;
    TimeOfDay: string;
    Year: number;
  }

  export interface ListAppSettingsHistoryFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    Value?: string;
  }

  export interface ListSettingsHistoryFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    Value?: string;
  }

  export const enum CompanyType {
    Unknown = 0,
    Consumer = 1,
    OrganizationUnit = 2
  }

  export interface ListCompaniesFilter {
    /**
     * Entity type: Company
     */
    IDs?: number[];
    Name?: string;
    VatNumber?: string;
    Type?: CompanyType;
  }

  export interface ListCompaniesItem {
    /**
     * Entity type: Company
     */
    ID: number;
    BackendID?: string;
    Name: string;
    Type: CompanyType;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
  }

  export interface ListCompanyRequirementFilter {
    /**
     * Entity type: CompanyRequirement
     */
    IDs?: number[];
    /**
     * Entity type: Country
     */
    CountryID?: string;
    ApplyToCompanyType?: ApplyToCompanyType;
  }

  export const enum ApplyToCompanyType {
    Consumer = 1,
    OrganizationUnit = 2
  }

  export const enum CompanyRequirementPropertyType {
    BackendID = 1,
    TaxRegistrationNumber = 2,
    FiscalID = 3,
    EmailAddress = 4,
    PhoneNumber = 5,
    TaxRecipientCode = 6,
    TaxRecipientEmail = 7,
    RegistrationNumber = 8,
    RegistrationCountryID = 9,
    RegistrationCountrySubdivisionID = 10,
    TaxOfficeNumber = 11
  }

  export const enum CompanyRequirementVisibilityType {
    Optional = 1,
    Preferred = 2,
    Required = 3,
    Hidden = 4
  }

  export interface ListCasesFilter {
    /**
     * Entity type: Case
     */
    ID?: number;
    /**
     * Entity type: CaseTopic
     */
    TopicID?: number;
    Title?: string;
    BackendID?: string;
    /**
     * Entity type: CaseStatus
     */
    StatusID?: number;
    Priority?: CasePriority;
    /**
     * Entity type: User
     */
    CustomerID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    ExternalOrderIdentifier?: string;
    /**
     * Entity type: User
     */
    AssigneeID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OriginatingOrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    AssignedOrganizationUnitID?: number;
  }

  export const enum RepairStatus {
    WaitingForGoods = 0,
    WaitingForRepair = 1,
    WaitingForPayment = 2,
    WaitingForShipment = 3,
    Finished = 4,
    Cancelled = 5,
    WaitingForPickup = 6,
    Started = 7,
    WaitingForGoods_OnHold = 8,
    WaitingForRepair_OnHold = 9,
    WaitingForShipment_OnHold = 10
  }

  export const enum CaseStatusAction {
    None = 0,
    CreateRepair = 1,
    CreateOrder = 2
  }

  export interface ListCaseInteractionsFilter {
    InteractionType?: InteractionType;
    Text?: string;
  }

  export interface ListCaseStatusesFilter {
    Name?: string;
    Description?: string;
  }

  export interface ListCaseTopicsFilter {
    /**
     * Entity type: CaseTopic
     */
    ParentID?: number;
    Name?: string;
    Description?: string;
    RootOnly?: boolean;
  }

  export const enum AuditingSettingType {
    String = 0,
    Bool = 1,
    Integer = 2,
    Decimal = 3
  }

  export const enum AMLTriggerType {
    Threshold = 1,
    Scripting = 2,
    Manual = 3
  }

  export const enum AMLSystemSurveys {
    US_IRS8300 = 1
  }

  export interface ListConfigurationsFilter {
    CountryID?: string;
  }

  export const enum BookingFlags {
    None = 0,
    WithTaxInformation = 1,
    WithoutOffsets = 2,
    WithOrderNumber = 4,
    WithReference = 8,
    WithInvoiceNumber = 16,
    WithCurrencyInformation = 32
  }

  export const enum AccountType {
    GeneralLedger = 1,
    Debtor = 2,
    Creditor = 3
  }

  export interface ListAccountsFilter {
    Name: string;
    ObjectAccount: string;
  }

  export interface ListAccountsItem {
    /**
     * Entity type: Account
     */
    ID: number;
    Name: string;
    ObjectAccount: string;
    Subsidiary?: string;
    BackendCode?: string;
    BookingFlagsID: number;
    TypeID: number;
    BookingFlags: BookingFlags;
    Type: AccountType;
  }

  /**
   * Create a return order from an existing sales order (`OrderID`).
   * 
   * When a `TargetOrderID` has been specified, newly created lines are added to that specific order. When omitted, the lines are either added to the
   * existing, original order (in case that is still permitted) or a new order is created automatically.
   * 
   * Returns information on the (newly created?) return order.
   */
  export interface CreateCustomerReturn {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Order
     */
    TargetOrderID?: number;
    /**
     * Lines to return
     */
    Lines: CustomerReturnLine[];
    /**
     * The products will not be returned, so the return order will be shipped immediately and the stock will be corrected. It does not work for return reversals.
     */
    ReturnWithoutProducts?: boolean;
    /**
     * When a ReturnWithoutProducts is done, but not the full amount should be refunded, a different amount can be provided - cannot exceed the worth of the returned products
     */
    AmountToRefund?: number;
    /**
     * When not the whole amount is refunded, a reason for this correction can be set. This will only have an affect if `AmountToRefund` is lower than the total amount of this return.
     * Entity type: RefundCorrectionReason
     */
    RefundCorrectionReasonID?: number;
    /**
     * Attach the order to the same OrganizationUnit as the returned order
     * @default false
     */
    CreateInOriginalOrganizationUnit?: boolean;
    /**
     * When the stock should be returned to a specific OrganizationUnit (see `GetReturnableStatusForOrder.StockOrganizationUnits`)
     * Entity type: OrganizationUnit
     */
    StockOrganizationUnitID?: number;
    /**
     * Optional, attached to a possible newly created (return) order - requires `BackendSystemID`
     */
    BackendID?: string;
    /**
     * Optional, attached to a possible newly created (return) order - requires `BackendID`
     */
    BackendSystemID?: string;
    /**
     * User is allowed to create return order when a valid security code is provided. The user has to have the ReturnWithoutSecurityCode role when omitted. `CRM:Return:RequiresOrderSecurityCode` needs to be enabled.
     */
    SecurityCode?: string;
    /**
     * Determines if the order will be auto-refunded or not. This value, when specified, will take precedence over CRM:Refund:AutoRefundOnReturn.
     */
    AutoRefund?: boolean;
  }

  export interface CustomerReturnLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    Quantity: number;
    /**
     * Entity type: ReturnReason
     */
    ReturnReasonID?: number;
    Remark?: string;
    /**
     * When a ReturnWithoutProducts is done, but not the full amount should be refunded, a different amount can be provided - cannot exceed the worth of the returned products
     */
    UnitAmountToRefund?: number;
    /**
     * When not the whole amount is refunded, a reason for this correction can be set. This will only have an affect if `UnitAmountToRefund` is lower than the total amount of this return line.
     * Entity type: RefundCorrectionReason
     */
    RefundCorrectionReasonID?: number;
    /**
     * Return it to the given stocklabel. This is only available for employees.
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    /**
     * The custom fields to store on the orderline. The key of the dictionary should be the name of the custom field.
     */
    CustomFields?: { [key: string]: CustomFieldValue };
    SerialNumber?: string;
  }

  /**
   * Creates a return order for a set of products for which there is no original order in EVA.
   */
  export interface CreateCustomerReturnWithoutOrder {
    /**
     * Entity type: Order
     */
    TargetOrderID?: number;
    OriginalOrderReference?: string;
    OriginalOrderTimestamp?: string;
    Lines?: ProductReturnLine[];
    /**
     * Entity type: User
     */
    CustomerID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    SoldFromOrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    ShipToOrganizationUnitID?: number;
  }

  export interface ProductReturnLine {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * A positive number that indicates the quantity of products returned.
     * Min: 0
     */
    Quantity: number;
    /**
     * Entity type: ReturnReason
     */
    ReturnReasonID?: number;
    Remark?: string;
    SerialNumber?: string;
  }

  /**
   * Create a return that is returned in the store. This will handle the return in the original OU and move stock to the current OU. For now, this only supports orders sold from a webshop.
   */
  export interface CreateInStoreReturn {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Lines: CreateInStoreReturn.Line[];
  }

  export namespace CreateInStoreReturn {
    export interface Line {
      /**
       * The order line that should be returned. Must be part of the given order
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      /**
       * Min: 1
       */
      Quantity?: number;
      /**
       * Optional remark
       */
      Remark?: string;
      /**
       * Entity type: ReturnReason
       */
      ReturnReasonID?: number;
      /**
       * The stock label that the product should be returned to on the current store.
       * Entity type: StockLabel
       */
      ReturnStockLabel?: number;
    }

  }

  export interface CreateInStoreReturnResponse {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Return the customer order return details originally set via `CreateCustomerReturn` or `CreateCustomerReturnWithoutOrder
   */
  export interface GetCustomerReturn {
    /**
     * ID of the returned order
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetCustomerReturnResponse {
    /**
     * Entity type: Order
     */
    OriginalOrderID?: number;
    OriginalOrderTimestamp?: string;
    ReferenceNumber: string;
    ReturnWithoutProducts: boolean;
    /**
     * Entity type: OrganizationUnit
     */
    StockOrganizationUnitID?: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface GetOrdersForReturnOrder {
    /**
     * Entity type: Order
     */
    ReturnOrderID: number;
    /**
     * Also return the original orders for cancelled return lines.
     */
    IncludeCancelledOrderLines?: boolean;
  }

  export interface GetOrdersForReturnOrderResponse {
    Orders: OriginalOrder[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface OriginalOrder {
    /**
     * Entity type: Order
     */
    ID: number;
    BackendID: string;
    BackendSystemID: string;
    IsPaid: boolean;
    IsCompleted: boolean;
    IsShipped: boolean;
  }

  export interface GetReturnOrdersForOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * If set to true, only return orders that have been placed will be returned. If set to false, only return orders that have not been placed will be returned. If not set, all return orders will be returned.
     */
    IsPlaced?: boolean;
  }

  export interface GetReturnOrdersForOrderResponse {
    Orders: ReturnOrder[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ReturnOrder {
    /**
     * Entity type: Order
     */
    ID: number;
    IsReturnWithoutProducts: boolean;
    CreationTime: string;
    TotalAmountInTax: number;
    CurrencyID: string;
    IsPaid: boolean;
    IsCompleted: boolean;
    IsShipped: boolean;
    PaidAmount: number;
    ForeignPaidAmount: number;
    ReturnedToOrganizationUnits: ReturnOrder.OrganizationUnit[];
  }

  export namespace ReturnOrder {
    export interface OrganizationUnit {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Receive a customer return order
   */
  export interface ReceiveReturnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Lines?: ReceiveReturnOrder.ReturnedLine[];
    FinalReceipt?: boolean;
  }

  export namespace ReceiveReturnOrder {
    export interface ReturnedLine {
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      Remark?: string;
      /**
       * Min: 1
       */
      Quantity?: number;
    }

  }

  /**
   * Triggers a refund request for the given Order.
   * 
   * The amount to refund is optional, if not specified it will be the amount available to refund on the order.
   */
  export interface RefundOrder {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    Reason?: string;
    /**
     * Min: 0
     */
    AmountToRefund?: number;
    /**
     * Handle all the refund in process, this can take a long time if multiple transactions are involved.
     */
    WaitForCompletion?: boolean;
  }

  export interface RefundOrderResponse {
    /**
     * Only set when WaitForCompletion is true
     */
    CreatedTransactions?: PaymentTransactionDto[];
    /**
     * Only set when WaitForCompletion is true
     */
    AmountAvailableToRefund?: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Supports the creation of return orders and return reversal orders. Unreferenced reversals will always be treated as normal returns.
   */
  export interface ReturnOrderLines {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    Lines: ReturnLineDto[];
    /**
     * Entity type: Order
     */
    TargetOrderID?: number;
    LineActionType?: LineActionTypes;
    /**
     * Attach the order to the same OrganizationUnit as the returned order
     */
    CreateInOriginalOrganizationUnit?: boolean;
    /**
     * When the stock should be returned to a specific OrganizationUnit.
     * 
     * The available OrganizationUnits are returned from the GetReturnableStatusForOrder.StockOrganizationUnits
     * Entity type: OrganizationUnit
     */
    StockOrganizationUnitID?: number;
  }

  export interface ReturnLineDto {
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    Quantity: number;
    Remark: string;
    /**
     * Entity type: ReturnReason
     */
    ReturnReasonID?: number;
    /**
     * Entity type: StockLabel
     */
    ReturnStockLabel?: number;
    SerialNumber?: string;
  }

  /**
   * Sends a `ReturnMail` stencil to the customer of given return order, attaching order blobs of type `ReturnLabel` (3) and `ReturnForm` (4) if present.
   */
  export interface SendReturnMail {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface SetReturnOrderRefundCorrection {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    NewOpenAmount?: number;
    Reason?: string;
    /**
     * When not the whole amount is refunded, a reason for this correction can be set.
     * Entity type: RefundCorrectionReason
     */
    RefundCorrectionReasonID?: number;
  }

  export interface RequestReindexUserSearchData {
    Script?: string;
    DeleteOldIndex?: boolean;
  }

  export interface RequestReindexOrderSearchData {
    Script?: string;
  }

  export const enum MessageGroups {
    General = 0,
    Events = 1,
    Global = 2
  }

  export const enum ProductCapacityTimeFrame {
    Daily = 0,
    Weekly = 1
  }

  export interface ProductCapacityPlanFilter {
    /**
     * Entity type: ProductCapacityPlan
     */
    ID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID?: number;
    Name?: string;
    Description?: string;
    ProductCapacityTimeFrame?: ProductCapacityTimeFrame;
    Capacity?: number;
    IsDynamic?: boolean;
  }

  export interface ProductRelationTypesFilter {
    /**
     * Entity type: ProductRelationType
     */
    ID?: number;
    Name?: string;
    BackendID?: string;
    Direction?: ProductRelationDirection;
    StockRelationType?: StockRelationType;
  }

  export const enum ParsingErrorType {
    InvalidSyntax = 0,
    DuplicateVariableDeclaration = 1,
    UnknownVariable = 2,
    InvalidSheetType = 3,
    InvalidScopeType = 4,
    InvalidExpressionValueType = 5,
    InvalidOption = 6
  }

  export const enum NodeTypes {
    Root = 0,
    Comparison = 1,
    Number = 2,
    Calculation = 3,
    And = 4,
    ReadVariable = 5,
    Array = 6,
    String = 7,
    DeclareVariable = 8,
    Switch = 9,
    SwitchCase = 10,
    Boolean = 11,
    Or = 12,
    Require = 13,
    Scope = 14,
    BoostScore = 15,
    NullCheck = 16,
    Null = 17,
    Fanout = 18,
    InterpolatedString = 19,
    Group = 20,
    Block = 22,
    DeclareTable = 23,
    ForEach = 24,
    If = 25,
    Lookup = 26,
    Output = 27,
    SetVariable = 28,
    FunctionCall = 30,
    FunctionCallParameter = 31,
    Exit = 32,
    IfBranch = 33,
    TableRow = 34,
    TableCell = 35,
    ArrayAccessor = 36,
    Identifier = 37,
    MemberAccess = 38,
    LambdaFunction = 39,
    Not = 40,
    ExtensionPoint = 1000,
    Recipe = 2000,
    Book = 2001,
    BookLine = 2002,
    BookParameter = 2003,
    Ignore = 2003
  }

  export interface PrintSecondChanceProductPriceLabel {
    /**
     * Entity type: Product
     */
    ID: number;
    /**
     * Entity type: Station
     */
    StationID?: number;
  }

  /**
   * Creates a new interaction associated with a specific repair
   */
  export interface CreateRepairInteraction {
    /**
     * Entity type: Repair
     */
    RepairID: number;
    Type: InteractionType;
    Text?: string;
  }

  export interface CreateRepairInteractionResponse {
    /**
     * Entity type: Interaction
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Create a repair
   */
  export interface CreateRepair {
    /**
     * Will copy as much information as possible from the case.
     * Entity type: Case
     */
    CaseID?: number;
    /**
     * Copy product, serial number and warranty information from the case item.
     * Entity type: CaseRelatedItem
     */
    CaseRelatedItemID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    SerialNumber?: string;
    IsWarranty?: boolean;
    WarrantyExpiration?: string;
    WarrantyAdditionalInformation?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: User
     */
    AssigneeID?: number;
    CustomFields?: CustomFieldKeyValue[];
    /**
     * How to deliver the repair to the store. Immediate means it is already there, Deferred means it will get there later.
     */
    ReceiveMethod?: RepairReceiveMethod;
    /**
     * The date when we expect the goods to arrive. Only used when ReceiveMethod is Deferred.
     */
    ExpectedArrivalDate?: string;
    ShippingOption?: RepairShippingOptions;
    /**
     * Where to print the thermal receipt
     * Entity type: Station
     */
    StationID?: number;
  }

  export const enum RepairReceiveMethod {
    Immediate = 0,
    Deferred = 1
  }

  export const enum RepairShippingOptions {
    Pickup = 0,
    Delivery = 1
  }

  export interface CreateRepairResponse {
    /**
     * Entity type: Repair
     */
    ID: number;
    /**
     * Entity type: Order
     */
    RepairOrderID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface FinishRepair {
    /**
     * Entity type: Repair
     */
    ID: number;
    Result: RepairResult;
    Message?: string;
    Public?: boolean;
  }

  export const enum RepairResult {
    Completed = 0,
    Cancelled = 1
  }

  export interface GetRepair {
    /**
     * Entity type: Repair
     */
    ID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface GetRepairResponse {
    /**
     * Entity type: Repair
     */
    ID: number;
    Blobs: GetRepairResponse.BlobModel[];
    OrganizationUnit: GetRepairResponse.OrganizationUnitModel;
    CompletionTime?: string;
    CancellationTime?: string;
    CompletedBy?: GetRepairResponse.UserModel;
    CancelledBy?: GetRepairResponse.UserModel;
    AssignedTo?: GetRepairResponse.UserModel;
    Customer?: GetRepairResponse.UserModel;
    Product: any;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Entity type: Order
     */
    OriginalOrderID?: number;
    Case: GetRepairResponse.CaseModel;
    /**
     * Entity type: Order
     */
    RepairOrderID: number;
    RepairOrderDisplayID: string;
    /**
     * Entity type: UserTask
     */
    ActiveRepairTaskID?: number;
    ActiveTask: GetRepairResponse.ActiveTaskModel;
    HasOpenAmount: boolean;
    /**
     * Indicates if a repair can be cancelled through `FinishRepair`.
     */
    IsCancellable: boolean;
    /**
     * Indicates if the repair is a warranty repair.
     */
    IsWarranty: boolean;
    /**
     * Warranty information **currently** attached to this product. Might differ from `IsWarranty`.Also, if this is an old repair and the product has been resold (eg: refurbished) this will show the warranty information of the refurbished product,not the warranty at the time of the repair creation.
     */
    WarrantyInformation: GetRepairResponse.WarrantyInfo;
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    SerialNumber?: string;
    ReceiveMethod: RepairReceiveMethod;
    /**
     * Indicates when the repair is expected to arrive at the OrganizationUnit. Not applicable if ReceiveMethod is 'Immediate'.
     */
    ExpectedArrivalDate?: string;
    Status: RepairState;
    StatusHistory: GetRepairResponse.StatusHistoryModel[];
    ShippingOption?: RepairShippingOptions;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetRepairResponse {
    export interface StatusHistoryModel {
      Status: RepairState;
      CreationTime: string;
    }

    export interface WarrantyInfo {
      IsUnderWarranty?: boolean;
      WarrantyExpiryDate?: string;
      AdditionalWarrantyInfo?: string;
    }

    export interface Interaction {
      /**
       * Entity type: Interaction
       */
      ID: number;
      Message: string;
      Type: InteractionType;
      UserModel: GetRepairResponse.UserModel;
      Timestamp: string;
    }

    export interface UserModel {
      /**
       * Entity type: User
       */
      ID: number;
      BackendID: string;
      FullName: string;
      EmailAddress: string;
      PhoneNumber: string;
      BackendSystemID: string;
    }

    export interface BlobModel {
      /**
       * Entity type: Blob
       */
      ID: string;
      Name: string;
      Type: string;
      CreationTime: string;
    }

    export interface OrganizationUnitModel {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
    }

    export interface CaseModel {
      /**
       * Entity type: Case
       */
      ID: number;
      Title: string;
      Description: string;
      Summary: string;
      /**
       * Entity type: CaseTopic
       */
      TopicID?: number;
      TopicName?: string;
      CreationTime: string;
    }

    export interface ActiveTaskModel {
      /**
       * Entity type: UserTask
       */
      TaskID?: number;
      /**
       * Subtype of the task.
       */
      SubType?: EnumDto;
    }

  }

  export const enum RepairState {
    WaitingForGoods = 0,
    WaitingForRepair = 1,
    WaitingForPayment = 2,
    WaitingForShipment = 3,
    Finished = 4,
    Cancelled = 5,
    WaitingForPickup = 6,
    Started = 7,
    OnHold = 8
  }

  /**
   * List the repair interactions
   */
  export interface ListRepairInteractions {
    /**
     * Entity type: Repair
     */
    RepairID: number;
    IncludeCaseInteractions?: boolean;
    InitialPageConfig?: PageTokenConfig<ListRepairInteractionsFilter>;
    PageToken?: string;
  }

  export interface ListRepairInteractionsFilter {
    InteractionType?: InteractionType;
    Text?: string;
  }

  export interface ListRepairInteractionsResponse {
    Results?: ListRepairInteractionsResponse.RepairInteraction[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListRepairInteractionsResponse {
    export interface RepairInteraction {
      /**
       * Entity type: Interaction
       */
      ID: number;
      IsCaseInteraction: boolean;
      InteractionType: InteractionType;
      CanBeMutated: boolean;
      Text: string;
      CreationTime: string;
      LastModificationTime?: string;
      CreatedBy?: ListRepairInteractionsResponse.User;
    }

    export interface User {
      /**
       * Entity type: User
       */
      CreatedByID?: number;
      FirstName: string;
      LastName: string;
      FullName: string;
    }

  }

  /**
   * List Repairs, optionally filtered.
   */
  export interface ListRepairs {
    InitialPageConfig?: PageTokenConfig<ListRepairsFilter>;
    PageToken?: string;
  }

  export interface ListRepairsFilter {
    /**
     * Entity type: Repair
     */
    RepairID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    FromDate?: string;
    ToDate?: string;
    Status?: RepairStatus[];
    SerialNumber?: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: User
     */
    AssignedUserIDs?: number[];
    /**
     * Entity type: User
     */
    CustomerIDs?: number[];
  }

  export interface ListRepairsResponse {
    Results?: ListRepairsResponse.ListRepairsItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListRepairsResponse {
    export interface ListRepairsItem {
      /**
       * Entity type: Repair
       */
      ID: number;
      CreationTime: string;
      Case: ListRepairsItem.CaseModel;
      Product: any;
      OrganizationUnit: ListRepairsItem.OrganizationUnitModel;
      RepairTasks: ListRepairsItem.RepairTaskModel[];
      ReceiveMethod: RepairReceiveMethod;
      Status: RepairState;
      /**
       * Whether the repair can be cancelled.
       */
      IsCancellable: boolean;
      /**
       * Entity type: Order
       */
      RepairOrderID: number;
      RepairOrderDisplayID?: string;
    }

    export namespace ListRepairsItem {
      export interface StatusHistoryModel {
        Status: RepairState;
        CreationTime: string;
      }

      export interface OrganizationUnitModel {
        /**
         * Entity type: OrganizationUnit
         */
        ID: number;
        Name: string;
      }

      export interface CaseModel {
        /**
         * Entity type: Case
         */
        ID: number;
        Title: string;
        Description: string;
      }

      export interface RepairTaskModel {
        /**
         * Entity type: UserTask
         */
        TaskID?: number;
        IsIgnored?: boolean;
        /**
         * Whether the task is completed.
         */
        IsCompleted?: boolean;
        /**
         * Whether the task is active. This means it can be picked up or is being worked on.
         */
        IsActive?: boolean;
        /**
         * The user assigned to the task.
         */
        Assignee?: ListRepairsItem.RepairTaskAssignee;
        /**
         * Subtype of the task.
         */
        SubType?: EnumDto;
      }

      export interface RepairTaskAssignee {
        /**
         * Entity type: User
         */
        ID: number;
        Name: string;
      }

    }

  }

  export interface UpdateRepair {
    /**
     * Entity type: Repair
     */
    ID: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    OnHold?: boolean;
    /**
     * Entity type: User
     */
    AssigneeID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    CaseSummary?: string;
    CaseDescription?: string;
    SerialNumber?: string;
    CustomFields?: CustomFieldKeyValue[];
    IsWarranty?: boolean;
    WarrantyExpiration?: string;
    WarrantyAdditionalInformation?: string;
    ExpectedArrivalDate?: string;
    ShippingOption?: RepairShippingOptions;
    ReceiveMethod?: RepairReceiveMethod;
  }

  /**
   * Completes a Stock Movement Follow Up task, using the `WorkSet` returned by the `StartStockMovementFollowUp` service.
   */
  export interface CompleteStockMovementFollowUp {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * The quantity moved (optional, use in case of a deviation - defaults to the full original amount)
     */
    Quantity?: number;
    SerialNumber?: string;
  }

  export interface StockMovementFollowUpWorkSet {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: UserTask
     */
    StockMovementFollowUpTaskID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    Product: any;
    Quantity: number;
    FromStockLabel: StockMovementFollowUpWorkSet.StockLabelDto;
    ToStockLabel: StockMovementFollowUpWorkSet.StockLabelDto;
  }

  export namespace StockMovementFollowUpWorkSet {
    export interface StockLabelDto {
      /**
       * Entity type: StockLabel
       */
      ID: number;
      Name: string;
      Description: string;
    }

  }

  /**
   * Starts a Stock Movement Follow Up task. Proceed with the `CompleteStockMovementFollowUp` service when finished.
   */
  export interface StartStockMovementFollowUp {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface StartStockMovementFollowUpResponse {
    WorkSet: StockMovementFollowUpWorkSet;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Starts a Composite User Task, returning child meta data.
   */
  export interface StartCompositeUserTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface StartCompositeUserTaskResponse {
    /**
     * Entity type: UserTask
     */
    ID: number;
    Description?: string;
    Tasks: StartCompositeUserTaskResponse.CompositeUserTaskSubTask[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace StartCompositeUserTaskResponse {
    export interface CompositeUserTaskSubTask {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Type: UserTaskTypeDto;
      SubType?: EnumDto;
      Description?: string;
      Sequence: number;
      IsActive: boolean;
      IsCompleted: boolean;
    }

  }

  export interface UserTaskTypeDto {
    ExpectedTimeToComplete?: string;
    DefaultPriority: number;
    DefaultRequired: boolean;
    SubTypes: EnumDto[];
    /**
     * Entity type: Enum
     */
    ID: number;
    /**
     * Usually an internal & unchangable code - for display, use `Description`
     */
    Name: string;
    Description: string;
  }

  /**
   * Complete multiple print SFS tasks.
   */
  export interface CompleteMultipleShipFromStoreTasks {
    /**
     * Entity type: UserTask
     */
    UserTaskIDs: number[];
  }

  /**
   * Completes the ShipFromOrder task, indicating that the shipment of the order has taken place.
   * 
   * The order will be shipped and the shop stock will be moved to Transit.
   */
  export interface CompleteShipFromStoreTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Required for subtypes Pick and Ship
     * Entity type: Station
     */
    StationID?: number;
    /**
     * Optional for subtype Pick
     */
    PickedOrderLines?: CompleteShipFromStoreTask.PickedOrderLine[];
    /**
     * Optional for subtype Ship
     */
    Shipments?: CompleteShipFromStoreTask.Shipment[];
    /**
     * Optional for subtype Ship, requesting to cancel all that was not shipped (also see `UnpickedLinesReasonID`)
     */
    FinalShipment?: boolean;
    /**
     * The reason why not all lines might be picked
     * Entity type: UserTaskNotCompletedReason
     */
    UnpickedLinesReasonID?: number;
    /**
     * If you want to override printing behavior - will default to the `ShouldBePrinting` value from `StartShipFromStoreTask`
     */
    ShouldBePrinting?: boolean;
  }

  export namespace CompleteShipFromStoreTask {
    export interface Shipment {
      /**
       * Entity type: ShippingMethod
       */
      ShippingMethodID?: number;
      TrackingCode?: string;
      Lines?: CompleteShipFromStoreTask.ShipmentLine[];
      Packages?: CompleteShipFromStoreTask.ShipmentPackage[];
    }

    export interface ShipmentLine {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      Quantity: number;
    }

    export interface ShipmentPackage {
      /**
       * Entity type: Package
       */
      PackageID: number;
      Lines?: CompleteShipFromStoreTask.ShipmentLine[];
    }

    export interface PickedOrderLine {
      /**
       * Entity type: OrderLine
       */
      ID?: number;
      /**
       * Assuming original `ProductID` when omitted - useful when using a replacement product
       * Entity type: Product
       */
      ProductID?: number;
      /**
       * Assuming full quantity when omitted - useful for partial picks or replacement products
       */
      Quantity?: number;
      SerialNumber?: string;
    }

  }

  export interface CompleteShipFromStoreTaskResponse {
    Next: NextUserTaskDto[];
    ShipmentIDs: number[];
    CompletionData: any;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface NextUserTaskDto {
    /**
     * Entity type: UserTask
     */
    ID: number;
    /**
     * Entity type: UserTask
     */
    ParentID?: number;
    Description: string;
    Priority: number;
    Type: UserTaskTypeDto;
    SubType: EnumDto;
  }

  /**
   * Retrieves a pre-picked ShipFromStoreTask based on a product ID.
   * Optionally filters by a ConsolidatedPickTask ID or defaults to the latest done, stopped, or paused task.
   */
  export interface GetPrePickedShipFromStoreTask {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
  }

  export interface GetPrePickedShipFromStoreTaskResponse {
    /**
     * The SFS task that was chosen as the most optimal based on the determination algorithm configured
     * Entity type: UserTask
     */
    UserTaskID?: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Gets an active ShipFromStore type User Task for your store, that contains a product with specified `Barcode`.
   * 
   * Use the optional `DeterminationType` to indicate if you prefer the `Oldest`, `Smallest` or `Largest` task that contains your product.
   */
  export interface GetShipFromStoreTaskByBarcode {
    Barcode: string;
    DeterminationType?: DeterminationType;
    Filter?: GetShipFromStoreTaskByBarcodeFilter;
  }

  export const enum DeterminationType {
    Oldest = 0,
    Smallest = 1,
    Largest = 2
  }

  export interface GetShipFromStoreTaskByBarcodeFilter {
    /**
     * Filter the tasks on the product count before choosing which one to return.
     */
    ProductCount?: ProductCountFilter;
  }

  export const enum ProductCountFilter {
    SingleProduct = 1,
    MultiProduct = 2,
    All = 3
  }

  export interface GetShipFromStoreTaskByBarcodeResponse {
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
    /**
     * Entity type: UserTask
     */
    ParentID?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    UserFullName?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Generates a combined pick list for given Ship From Store tasks, starting and assigning them all to the current user.
   * 
   * These tasks need to be ShipFromStore type with subtype Pick, or a CompositeUserTask type with such a task as first child.
   */
  export interface PrintShipFromStoreTasks {
    /**
     * Entity type: UserTask
     */
    UserTaskIDs: number[];
    ProductProperties?: string[];
  }

  /**
   * Starts a ShipFromStore task, identified by its UserTaskID.
   * 
   * The service returns the order that should be shipped from the user's current store as well as the OrderLines
   * that should be part of the shipment. Not necessarily all orderlines of the order should be shipped, so the
   * OrderLineIDs returned by this service should be respected.
   */
  export interface StartShipFromStoreTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    ProductProperties?: string[];
  }

  export interface StartShipFromStoreTaskResponse {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
    OrderDisplayID?: string;
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    AvailableShippingMethods: ShippingMethodByOrderLineDto[];
    TravelDistanceText: string;
    TravelTimeText: string;
    TravelDistanceInMeters?: number;
    TravelTimeInSeconds?: number;
    ShouldBePrinting: boolean;
    SubTypeName: string;
    /**
     * All lines in the order fulfillment.
     */
    Lines: StartShipFromStoreTaskResponse.ShipFromStoreLine[];
    PreferredPriceDisplayMode: OrderPreferredPriceDisplayMode;
    GiftWrappingOptions: StartShipFromStoreTaskResponse.ShipFromStoreGiftWrappingOptions;
    Data: any;
    /**
     * The lines that need to be packed. Only available for the Pack subtype.
     */
    PackLines?: StartShipFromStoreTaskResponse.ShipFromStoreLine[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace StartShipFromStoreTaskResponse {
    export interface ShipFromStoreLine {
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      /**
       * Entity type: Product
       */
      ProductID?: number;
      /**
       * Entity type: Product
       */
      ReplacementProductIDs?: number[];
      /**
       * All possible stock products for this line. If this is not a stock aggregate product, this contains the same product.
       */
      StockProducts: StartShipFromStoreTaskResponse.ShipFromStoreLineStockProduct[];
      Quantity: number;
      Properties: any;
      /**
       * The product requirements for this line
       */
      Requirements: StartShipFromStoreTaskResponse.ShipFromStoreLineProductRequirement[];
      /**
       * The TotalAmount of this line: Quantity * UnitPrice
       */
      TotalAmount: number;
      /**
       * The TotalAmountInTax of this line: Quantity * UnitPrice + Taxes
       */
      TotalAmountInTax: number;
      /**
       * The TotalAmount with the Discounts for this line included
       */
      NetTotalAmount: number;
      /**
       * The TotalAmountInTax with the Discounts for this line included
       */
      NetTotalAmountInTax: number;
      /**
       * The child lines for this line
       */
      ChildLines: StartShipFromStoreTaskResponse.ShipFromStoreLine[];
      /**
       * Entity type: OrderLine
       */
      ParentID?: number;
      GroupID?: string;
      /**
       * Entity type: ProductBundleLine
       */
      ProductBundleLineID?: number;
      CurrencyID: string;
      ProductVariation: { [key: string]: string };
      SerialNumber?: string;
      SerialNumberRequired: boolean;
      /**
       * Entity type: SerialNumberConfiguration
       */
      SerialNumberConfigurationID?: number;
    }

    export interface ShipFromStoreLineProductRequirement {
      Name: string;
      Value?: any;
    }

    export interface ShipFromStoreGiftWrappingOptions {
      GiftWraps: StartShipFromStoreTaskResponse.ShipFromStoreGiftWrap[];
      GreetingCardProductID?: number;
      Message: string;
    }

    export interface ShipFromStoreGiftWrap {
      GreetingCardProductID?: number;
      Message: string;
      Lines: StartShipFromStoreTaskResponse.ShipFromStoreWrapLine[];
    }

    export interface ShipFromStoreWrapLine {
      Line: StartShipFromStoreTaskResponse.ShipFromStoreLine;
      Quantity: number;
    }

    export interface ShipFromStoreLineStockProduct {
      /**
       * Entity type: Product
       */
      ProductID: number;
    }

  }

  /**
   * Add a tracking code to the ReturnToSupplier task shipment.
   * If tracking code is already present, it will be overwritten.
   */
  export interface AddTrackingCodeToReturnToSupplierShipment {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    TrackingCode?: string;
  }

  /**
   * Completes the ReturnToSupplier task.
   * 
   * When CompleteReturnToSupplierTask is called and there are no lines on the task shipment, the shipment will be removed.
   */
  export interface CompleteReturnToSupplierTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  /**
   * List available ReturnToSupplier order lines with quantities.
   */
  export interface ListReturnToSupplierTaskOrderLines {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    PageConfig?: PageConfig<ListReturnToSupplierTaskOrderLineFilter>;
    ProductProperties?: string[];
  }

  export interface ListReturnToSupplierTaskOrderLineFilter {
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    ProductTypes?: ProductTypes;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    Query: string;
  }

  export interface ListReturnToSupplierTaskOrderLinesResponse {
    Result?: PagedResult<ReturnToSupplierTaskOrderLine>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ReturnToSupplierTaskOrderLine {
    OrderLineID: number;
    ParentID?: number;
    GroupID?: string;
    ProductID: number;
    CustomID: string;
    ProductName: string;
    /**
     * Entity type: StockLabel
     */
    StockLabel: number;
    ProductProperties: any;
    Quantity: number;
    SerialNumber?: string;
    SerialNumberRequired: boolean;
    SerialNumberConfigurationID?: number;
    UnitOfMeasures: ReturnToSupplierTaskOrderLine.UnitOfMeasure[];
    OrderDisplayID?: string;
  }

  export namespace ReturnToSupplierTaskOrderLine {
    export interface UnitOfMeasure {
      BackendID: string;
      Name: string;
      Description: string;
      UnitOfMeasureQuantity: number;
      Quantity: number;
      BaseQuantityTotal: number;
    }

  }

  /**
   * List lines for the tasks shipment with quantities.
   */
  export interface ListReturnToSupplierTaskShipmentLines {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    PageConfig?: PageConfig<ListReturnToSupplierTaskOrderLineFilter>;
    ProductProperties?: string[];
  }

  export interface ListReturnToSupplierTaskShipmentLinesResponse {
    Result?: PagedResult<ReturnToSupplierTaskShipmentLine>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ReturnToSupplierTaskShipmentLine {
    OrderLineID: number;
    ParentID?: number;
    GroupID?: string;
    ProductID: number;
    CustomID: string;
    ProductName: string;
    /**
     * Entity type: StockLabel
     */
    StockLabel: number;
    ProductProperties: any;
    Quantity: number;
    UnitOfMeasures: ReturnToSupplierTaskShipmentLine.UnitOfMeasure[];
    SerialNumber?: string;
    SerialNumberRequired: boolean;
    /**
     * Entity type: SerialNumberConfiguration
     */
    SerialNumberConfigurationID?: number;
  }

  export namespace ReturnToSupplierTaskShipmentLine {
    export interface UnitOfMeasure {
      BackendID: string;
      Name: string;
      Description: string;
      UnitOfMeasureQuantity: number;
      Quantity: number;
      BaseQuantityTotal: number;
    }

  }

  /**
   * Print the tasks shipment label.
   */
  export interface PrintReturnToSupplierTaskShipment {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: Station
     */
    StationID: number;
  }

  /**
   * Adds or removes a lines to/from the ReturnToSupplier tasks shipment.
   * 
   * When 'Exclude' is enabled, all lines matching the given ProductID will be removed from the task shipment with a maximum of the given Quantity.
   * When 'Exclude' is disabled, all lines from the ReturnToSupplier order matching the given ProductID will be added to the tasks shipment to the maximum of the given Quantity.
   * 
   * Overshipment is not allowed.
   */
  export interface SetLineForReturnToSupplierShipment {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    Exclude?: boolean;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    /**
     * Min: 0
     */
    Quantity: number;
    SerialNumbers?: string[];
  }

  /**
   * Starts ReturnToSupplier task.
   */
  export interface StartReturnToSupplierTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface StartReturnToSupplierResponse {
    UseExcludePolicyOnReturnToSupplierShipment: boolean;
    ShipmentIdentifiers: StartReturnToSupplierResponse.ShipmentIdentifier[];
    Lines: StartReturnToSupplierResponse.StartReturnToSupplierLineResponse[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace StartReturnToSupplierResponse {
    export interface ShipmentIdentifier {
      /**
       * Entity type: ShipmentIdentifier
       */
      ID: number;
      Name: string;
      RequiredFor: ShipmentIdentifierRequiredFor;
      Type: ShipmentIdentifierTypes;
    }

    export interface StartReturnToSupplierLineResponse {
      QuantityToAdd: number;
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
      /**
       * Entity type: StockLabel
       */
      StockLabelID: number;
      StockLabelName: string;
      SerialNumber?: string;
      SerialNumberRequired: boolean;
      /**
       * Entity type: SerialNumberConfiguration
       */
      SerialNumberConfigurationID?: number;
    }

  }

  /**
   * Complete a ReservationPickupTask task
   */
  export interface CompleteReservationPickupTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface StartReservationPickupTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface StartReservationPickupTaskResponse {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Updates the deadline of a pending ReservationPickup task.
   */
  export interface UpdateReservationPickupTaskDeadline {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    Deadline: string;
  }

  export interface DetachFromRepairUserTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  /**
   * Finish repair user task
   */
  export interface FinishRepairUserTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
    /**
     * Message associated with the completion of this task. This is only useful for the ExecuteRepair task type.
     */
    Message?: string;
    /**
     * Whether the message should be public (same disclaimer as Message applies).
     */
    Public?: boolean;
    Result?: RepairResult;
  }

  /**
   * Print repair thermal receipt
   */
  export interface PrintRepairThermalReceipt {
    /**
     * Entity type: Repair
     */
    RepairID?: number;
    /**
     * Entity type: Station
     */
    StationID?: number;
  }

  /**
   * Start repair user task
   */
  export interface StartRepairUserTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface StartRepairUserTaskResponse {
    Repair: StartRepairUserTaskResponse.RepairModel;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace StartRepairUserTaskResponse {
    export interface RepairModel {
      /**
       * Entity type: Repair
       */
      ID: number;
    }

  }

  /**
   * Creates a new ProductZoneGroup.
   */
  export interface CreateProductZoneGroup {
    Name: string;
    Description?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Entity type: ProductZone
     */
    ZoneIDs?: number[];
  }

  export interface CreateProductZoneGroupResponse {
    /**
     * Entity type: ProductZoneGroup
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Updates an existing ProductZoneGroup.
   */
  export interface UpdateProductZoneGroup {
    /**
     * Entity type: ProductZoneGroup
     */
    ID: number;
    Name?: string;
    Description?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: ProductZone
     */
    ZoneIDs?: number[];
  }

  /**
   * Deletes a ProductZoneGroup by its ID
   */
  export interface DeleteProductZoneGroup {
    /**
     * Entity type: ProductZoneGroup
     */
    ID: number;
  }

  /**
   * Retrieves a ProductZoneGroup by its ID
   */
  export interface GetProductZoneGroup {
    /**
     * Entity type: ProductZoneGroup
     */
    ID: number;
  }

  export interface ProductZoneGroupDto {
    /**
     * Entity type: ProductZoneGroup
     */
    ID: number;
    Name: string;
    Description?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    Zones?: ProductZoneDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ProductZoneDto {
    /**
     * Entity type: ProductZone
     */
    ID?: number;
    Name?: string;
    Description?: string;
    BackendID?: string;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    ProductSearchTemplateName?: string;
    FilterAttribute?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Gets all the ProductZoneGroups based on the given filter and returns a paged response.
   */
  export interface ListProductZoneGroups {
    PageConfig?: PageConfig<ListProductZoneGroupsFilter>;
  }

  export interface ListProductZoneGroupsFilter {
    Name: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: ProductZone
     */
    ProductZoneID?: number;
    /**
     * Entity type: ProductZoneGroup
     */
    ProductZoneGroupIDs: number[];
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetIDs?: number[];
  }

  export interface ListProductZoneGroupsResponse {
    Result?: PagedResult<ProductZoneGroupDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Creates a new ProductZone.
   */
  export interface CreateProductZone {
    Name?: string;
    Description?: string;
    BackendID?: string;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    FilterAttribute?: string;
  }

  export interface CreateProductZoneResponse {
    /**
     * Entity type: ProductZone
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Updates an existing ProductZone.
   */
  export interface UpdateProductZone {
    /**
     * Entity type: ProductZone
     */
    ID: number;
    Name?: string;
    Description?: string;
    BackendID?: string;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    FilterAttribute?: string;
  }

  /**
   * Deletes a ProductZone by its ID
   */
  export interface DeleteProductZone {
    /**
     * Entity type: ProductZone
     */
    ID: number;
  }

  /**
   * Retrieves a ProductZone by its ID
   */
  export interface GetProductZone {
    /**
     * Entity type: ProductZone
     */
    ID: number;
  }

  /**
   * Gets all the ProductZones based on the given filter and returns a paged response.
   */
  export interface ListProductZones {
    PageConfig?: PageConfig<ListProductZonesFilter>;
  }

  export interface ListProductZonesFilter {
    Name: string;
    FilterAttribute: string;
    /**
     * Entity type: ProductZoneGroup
     */
    ProductZoneGroupID?: number;
  }

  export interface ListProductZonesResponse {
    Result?: PagedResult<ProductZoneDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface CompletePrintPriceLabelTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  /**
   * Creates a new Print Price Label task with specified products, or append these to existing tasks when applicable.
   */
  export interface CreatePrintPriceLabelTask {
    /**
     * OrganizationUnitID (defaults to current OU)
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * List of products to print price labels for
     */
    Products: CreatePrintPriceLabelTask.PrintPriceLabelTaskProduct[];
  }

  export namespace CreatePrintPriceLabelTask {
    export interface PrintPriceLabelTaskProduct {
      /**
       * Product ID
       * Entity type: Product
       */
      ProductID: number;
      /**
       * Quantity (defaults to 1)
       */
      Quantity?: number;
    }

  }

  export interface CreatePrintPriceLabelTaskResponse {
    Result: CreatedPrintPriceLabelTask[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface CreatedPrintPriceLabelTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    AlreadyExisted: boolean;
  }

  export interface PrintPriceLabel {
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
    Products?: PrintPriceLabel.ProductPrintRequest[];
    /**
     * Entity type: Station
     */
    StationID: number;
  }

  export namespace PrintPriceLabel {
    export interface ProductPrintRequest {
      /**
       * Entity type: Product
       */
      ProductID: number;
      Quantity?: number;
    }

  }

  export interface PrintPriceLabelResponse {
    Success: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface StartPrintPriceLabelTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface StartPrintPriceLabelTaskResponse {
    Result: StartPrintPriceLabelTaskResponse.PriceLabelProduct[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace StartPrintPriceLabelTaskResponse {
    export interface PriceLabelProduct {
      ProductID: number;
      Quantity: number;
      ProductCustomID: string;
      ProductBackendID: string;
      ProductDisplayValue: string;
      ProductUnitPriceInTax: number;
      ProductUnitPrice: number;
      ProductOriginalUnitPriceInTax?: number;
      ProductOriginalUnitPrice?: number;
    }

  }

  export interface CompletePrintTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Pass as `true` to skip "NotYetPrinted" check and force task completion without it.
     */
    ManuallyPrinted?: boolean;
  }

  /**
   * Create a UserTask in specified organization unit to print a specific `BlobID` or `BlobUrl`.
   */
  export interface CreatePrintTask {
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrl` instead.
     * Entity type: Blob
     */
    BlobID?: string;
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL.
     */
    BlobUrl?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Optional description for the generated UserTask
     */
    Description?: string;
    /**
     * Assign the task to a specific user immediately
     * Entity type: User
     */
    UserID?: number;
    Type: PrintTaskType;
  }

  export const enum PrintTaskType {
    Paper = 0,
    Zebra = 1
  }

  export interface CreatePrintTaskResponse {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Processes the print tasks for each required ID.
   * 
   * This service does not throws an expeption in the case of mulptiple user task ids, but the output will be a dictionary containing
   * an Error (EVA.Framework.Error) for every print task that encounters an issue. The UserTaskID will be the key in that specific Dictionary.
   * 
   * In the case of a single user task id, the service will behave exactly as the depracated ProcessPrintTask service did, throwing the encountered exception.
   */
  export interface ProcessPrintTasks {
    /**
     * Entity type: UserTask
     */
    UserTaskIDs: number[];
    /**
     * Entity type: Station
     */
    StationID?: number;
  }

  export interface ProcessPrintTasksResponse {
    /**
     * Entity type: UserTask
     */
    FailedUserTasks: { [key: number]: Error };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface StartPrintTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface StartPrintTaskResponse {
    /**
     * Entity type: Blob
     */
    BlobID: string;
    BlobUrl: string;
    Type: PrintTaskType;
    IsPrinted: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Completes an Operational task.
   */
  export interface CompleteOperationalTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  /**
   * Creates a new operational task configuration with the specified organization unit set, optional survey, and optional scheduling configuration.
   */
  export interface CreateOperationalTaskConfig {
    /**
     * The organization unit set to which this task configuration applies.
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * The optional survey linked to this config. If provided, users will be asked to fill out a survey before they can complete the task.
     * Entity type: Survey
     */
    SurveyID?: number;
    /**
     * Name of the task. If not provided the survey name will be used.
     */
    Name?: string;
    /**
     * Schedule for the task configuration. This is optional, and if not provided, the tasks can only be created by manually triggering this config.
     */
    SchedulingConfig?: SchedulingConfig;
    /**
     * Trigger this configuration when a financial period is closed.
     */
    TriggerOnFinancialPeriodClosed?: boolean;
    /**
     * Start date for when TriggerOnFinancialPeriodClosed is active. If not provided, triggering is always active.
     */
    TriggerStartDate?: string;
    /**
     * End date for when TriggerOnFinancialPeriodClosed is active. If not provided, triggering is always active.
     */
    TriggerEndDate?: string;
    /**
     * If true, the task will be created only if the store is open on the day of triggering.
     */
    OnlyTriggerIfStoreOpen?: boolean;
    /**
     * Deadline given to the tasks.
     * Min: 0
     */
    DeadlineInMinutes?: number;
    /**
     * The list of roles that these tasks are visible to
     * Entity type: Role
     */
    RoleIDs?: number[];
    /**
     * Defines how to handle existing tasks when a new task is created with this configuration. Skip: Do not create a new task if one already exists. Replace: Replace the existing task with the new one. Add: Create a new task even if one already exists.
     */
    ExistingTaskBehaviorID?: ExistingTaskBehavior;
    /**
     * If true, creates individual tasks for each employee with the specified roles instead of one task per OU.
     */
    IsPersonal?: boolean;
    /**
     * If true, personal tasks are only created for employees whose primary store is the current OU.
     */
    OnlyInPrimaryStore?: boolean;
    /**
     * If true, deactivates existing personal tasks for the same config before creating new ones.
     */
    DeactivateDuplicatePersonalTasks?: boolean;
    /**
     * Auto-expiration period in minutes for personal tasks.
     * Min: 0
     */
    ExpirationInMinutes?: number;
  }

  export interface SchedulingConfig {
    Cron?: string;
    SingleDate?: string;
    Days: SchedulingConfig.DaysObject;
    Weeks: SchedulingConfig.WeeksObject;
    Months: SchedulingConfig.MonthsObject;
    Years: SchedulingConfig.YearsObject;
  }

  export namespace SchedulingConfig {
    export interface DaysObject {
      Start: string;
      End?: string;
      /**
       * Range: 1-1000000
       */
      Interval: number;
    }

    export interface WeeksObject {
      Start: string;
      End?: string;
      /**
       * Range: 1-1000000
       */
      Interval: number;
      Monday: boolean;
      Tuesday: boolean;
      Wednesday: boolean;
      Thursday: boolean;
      Friday: boolean;
      Saturday: boolean;
      Sunday: boolean;
    }

    export interface MonthsObject {
      Start: string;
      End?: string;
      /**
       * Range: 1-1000000
       */
      Interval: number;
      Days: MonthsObject.DayObject[];
    }

    export namespace MonthsObject {
      export interface DayObject {
        /**
         * The how-manieth day of the month. When a DayOfWeek = Monday is provided, this means 1st,2nd,etc.. monday. When DayOfWeek = null is provided, this meanst, 1st,2nd,etc.. day of the month.
         */
        Day: number;
        /**
         * The day of the week, if set to `null` this means 'any day'
         */
        DayOfWeek?: DayOfWeek;
      }

    }

    export interface YearsObject {
      Start: string;
      End?: string;
      Days: YearsObject.DayObject[];
      /**
       * Range: 1-1000000
       */
      Interval?: number;
    }

    export namespace YearsObject {
      export interface DayObject {
        /**
         * The how-manieth day of the month. When a DayOfWeek = Monday is provided, this means 1st,2nd,etc.. monday. When DayOfWeek = null is provided, this meanst, 1st,2nd,etc.. day of the month.
         */
        Day: number;
        /**
         * The month of the year
         */
        Month: number;
        /**
         * The day of the week, if set to `null` this means 'any day'
         */
        DayOfWeek?: DayOfWeek;
      }

    }

  }

  export const enum ExistingTaskBehavior {
    /**
     * If a task already exists, skip creating a new one.
     */
    Skip = 0,
    /**
     * If a task already exists, add the new one so you get 2 tasks.
     */
    Add = 2
  }

  export interface CreateOperationalTaskConfigResponse {
    /**
     * Entity type: OperationalTaskConfig
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface DeleteOperationalTaskConfig {
    /**
     * Entity type: OperationalTaskConfig
     */
    ID: number;
  }

  export interface GetOperationalTaskConfig {
    /**
     * Entity type: OperationalTaskConfig
     */
    ID: number;
  }

  export interface GetOperationalTaskConfigResponse {
    /**
     * The organization unit set to which this task configuration applies.
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Information about the optional survey linked to this config.
     */
    Survey: SurveyInfoDto;
    /**
     * Name of the task. Defaults to the survey name when not set.
     */
    Name: string;
    /**
     * Schedule for the task configuration. This is optional, and if not provided, the tasks can only be created by manually triggering this config.
     */
    SchedulingConfig?: SchedulingConfig;
    /**
     * Whether this configuration is triggered when a financial period closes.
     */
    TriggerOnFinancialPeriodClosed: boolean;
    /**
     * Start date for when TriggerOnFinancialPeriodClosed is active.
     */
    TriggerStartDate?: string;
    /**
     * End date for when TriggerOnFinancialPeriodClosed is active.
     */
    TriggerEndDate?: string;
    /**
     * If true, the task will be created only if the store is open on the day of triggering.
     */
    OnlyTriggerIfStoreOpen: boolean;
    /**
     * Human readable form of the scheduling configuration.
     */
    SchedulingConfigDescription?: string;
    /**
     * Defines how to handle existing tasks when a new task is created with this configuration. Skip: Do not create a new task if one already exists. Replace: Replace the existing task with the new one. Add: Create a new task even if one already exists.
     */
    ExistingTaskBehavior: ExistingTaskBehavior;
    /**
     * Roles that can see the tasks created by this config
     */
    Roles: GetOperationalTaskConfigResponse.RoleObject[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetOperationalTaskConfigResponse {
    export interface RoleObject {
      /**
       * Entity type: Role
       */
      ID: number;
      Name: string;
    }

  }

  export interface SurveyInfoDto {
    /**
     * Entity type: Survey
     */
    ID?: number;
    /**
     * The name of the survey.
     */
    Name: string;
  }

  /**
   * Lists all operational task configurations.
   */
  export interface ListOperationalTaskConfig {
    PageConfig?: PageConfig<ListOperationalTaskConfigFilter>;
  }

  export interface ListOperationalTaskConfigFilter {
    SurveyName?: string;
    ConfigName?: string;
  }

  export interface ListOperationalTaskConfigResponse {
    Result?: PagedResult<OperationalTaskConfigDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface OperationalTaskConfigDto {
    /**
     * Entity type: OperationalTaskConfig
     */
    ID?: number;
    /**
     * The organization unit set to which this task configuration applies.
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * The name of the organization unit set.
     */
    OrganizationUnitSetName?: string;
    /**
     * Name of the task. Defaults to the survey name when not set.
     */
    Name?: string;
    /**
     * Information about the optional survey linked to this config.
     */
    Survey?: OperationalTaskConfigDto.SurveyInfoDto;
    /**
     * Schedule for the task configuration. This is optional, and if not provided, the tasks can only be created by manually triggering this config.
     */
    SchedulingConfig?: SchedulingConfig;
    /**
     * Whether this configuration is triggered when a financial period closes.
     */
    TriggerOnFinancialPeriodClosed?: boolean;
    /**
     * If true, the task will be created only if the store is open on the day of triggering.
     */
    OnlyTriggerIfStoreOpen?: boolean;
    /**
     * Human readable form of the scheduling configuration.
     */
    SchedulingConfigDescription?: string;
    /**
     * Defines how to handle existing tasks when a new task is created with this configuration. Skip: Do not create a new task if one already exists. Replace: Replace the existing task with the new one. Add: Create a new task even if one already exists.
     */
    ExistingTaskBehavior?: ExistingTaskBehavior;
    /**
     * List of roles that can execute tasks created by this configuration.
     */
    Roles?: OperationalTaskConfigDto.RoleInfo[];
  }

  export namespace OperationalTaskConfigDto {
    export interface SurveyInfoDto {
      /**
       * Entity type: Survey
       */
      ID?: number;
      /**
       * The name of the survey.
       */
      Name?: string;
    }

    export interface RoleInfo {
      /**
       * Entity type: Role
       */
      ID?: number;
      Name?: string;
    }

  }

  /**
   * Starts one or more Operational tasks, returning a workset. Pass this workset to the `CompleteOperationalTask` service when all tasks are complete.
   */
  export interface StartOperationalTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface StartOperationalTaskResponse {
    /**
     * If this operational task contains a survey, this is filled with the token to start the survey.
     */
    SurveyToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Manually triggers an operational task configuration for a specific organization unit.
   */
  export interface TriggerOperationalTaskConfig {
    /**
     * The ID of the operational task configuration to trigger.
     * Entity type: OperationalTaskConfig
     */
    ConfigID: number;
  }

  export interface UpdateOperationalTaskConfig {
    /**
     * Entity type: OperationalTaskConfig
     */
    ID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Passing this as `null` will remove the survey.
     * Entity type: Survey
     */
    SurveyID?: number;
    /**
     * Name of the task. Pass null to remove it and fall back to the survey name.
     */
    Name?: string;
    /**
     * Passing this as `null` will remove the scheduling config.
     */
    SchedulingConfig?: SchedulingConfig;
    /**
     * Update whether this configuration is triggered when a financial period closes.
     */
    TriggerOnFinancialPeriodClosed?: boolean;
    /**
     * Start date for when TriggerOnFinancialPeriodClosed is active. Pass null to remove the restriction.
     */
    TriggerStartDate?: string;
    /**
     * End date for when TriggerOnFinancialPeriodClosed is active. Pass null to remove the restriction.
     */
    TriggerEndDate?: string;
    /**
     * If true, the task will be created only if the store is open on the day of triggering.
     */
    OnlyTriggerIfStoreOpen?: boolean;
    /**
     * The list of roles that these tasks are visible to
     * Entity type: Role
     */
    RoleIDs?: number[];
    /**
     * Defines how to handle existing tasks when a new task is created with this configuration. Skip: Do not create a new task if one already exists. Replace: Replace the existing task with the new one. Add: Create a new task even if one already exists.
     */
    ExistingTaskBehaviorID?: ExistingTaskBehavior;
    /**
     * Deadline given to the tasks.
     * Min: 0
     */
    DeadlineInMinutes?: number;
    /**
     * If true, creates individual tasks for each employee with the specified roles instead of one task per OU.
     */
    IsPersonal?: boolean;
    /**
     * If true, personal tasks are only created for employees whose primary store is the current OU.
     */
    OnlyInPrimaryStore?: boolean;
    /**
     * If true, deactivates existing personal tasks for the same config before creating new ones.
     */
    DeactivateDuplicatePersonalTasks?: boolean;
    /**
     * Auto-expiration period in minutes for personal tasks.
     * Min: 0
     */
    ExpirationInMinutes?: number;
  }

  export interface UpdateOperationalTaskConfigResponse {
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * @deprecated Custom usertasks are deprecated and will be removed in the future.
   * Completes a custom usertask
   */
  export interface CompleteCustomUserTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: CustomField
     */
    Values?: { [key: number]: CustomFieldValue };
  }

  /**
   * @deprecated Custom usertasks are deprecated and will be removed in the future.
   * Creates a new custom usertask
   */
  export interface CreateCustomUserTask {
    /**
     * The organization unit to create this task for
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * The type of the custom usertask
     * Entity type: UserTaskSubType
     */
    CustomUserTaskTypeID?: number;
    /**
     * The template to create the usertask from
     * Entity type: CustomUserTaskTemplate
     */
    CustomUserTaskTemplateID?: number;
    /**
     * Custom fields that will override the ones from the template
     */
    Fields?: UserTaskField[];
    Deadline?: string;
    Description?: string;
    Priority?: number;
  }

  export interface UserTaskField {
    /**
     * Entity type: CustomField
     */
    CustomFieldID: number;
    /**
     * If the field is required, a value MUST be set when completing the task.
     */
    IsRequired: boolean;
  }

  export interface CreateCustomUserTaskResponse {
    /**
     * Entity type: UserTask
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * @deprecated Custom usertasks are deprecated and will be removed in the future.
   * Creates a new custom usertask type.
   */
  export interface CreateCustomUserTaskType {
    Name?: string;
  }

  export interface CreateCustomUserTaskTypeResponse {
    /**
     * Entity type: UserTaskSubType
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * @deprecated Custom usertasks are deprecated and will be removed in the future.
   * List all custom usertask types
   */
  export interface ListCustomUserTaskTypes {
  }

  export interface ListCustomUserTaskTypesResponse {
    Types: ListCustomUserTaskTypesResponse.CustomUserTaskType[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListCustomUserTaskTypesResponse {
    export interface CustomUserTaskType {
      /**
       * Entity type: UserTaskSubType
       */
      ID: number;
      Name: string;
    }

  }

  /**
   * Creates a new template for custom user tasks
   */
  export interface CreateCustomUserTaskTemplate {
    Name?: string;
    Description?: string;
    /**
     * Entity type: UserTaskSubType
     */
    TypeID: number;
    Options?: TaskOptions;
  }

  export interface TaskOptions {
    DefaultPriority: number;
    DefaultDeadlineMinutes?: number;
    Fields: UserTaskField[];
  }

  export interface CreateCustomUserTaskTemplateResponse {
    /**
     * Entity type: CustomUserTaskTemplate
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Deletes a specific custom usertask template
   */
  export interface DeleteCustomUserTaskTemplate {
    /**
     * Entity type: CustomUserTaskTemplate
     */
    ID: number;
  }

  /**
   * Updates a template for custom user tasks. If a property is not provided, it will be set to null.
   */
  export interface UpdateCustomUserTaskTemplate {
    /**
     * Entity type: CustomUserTaskTemplate
     */
    ID: number;
    Name?: string;
    Description?: string;
    /**
     * Entity type: UserTaskSubType
     */
    TypeID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Options?: TaskOptions;
  }

  /**
   * @deprecated Custom usertasks are deprecated and will be removed in the future.
   * Lists all of the custom usertask templates
   */
  export interface ListCustomUserTaskTemplate {
    InitialPageConfig?: PageTokenConfig<ListCustomUserTaskTemplateFilter>;
    PageToken?: string;
  }

  export interface ListCustomUserTaskTemplateFilter {
  }

  export interface ListCustomUserTaskTemplateResponse {
    Results?: ListCustomUserTaskTemplateResponse.CustomUserTaskTemplate[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListCustomUserTaskTemplateResponse {
    export interface CustomUserTaskTemplate {
      /**
       * Entity type: CustomUserTaskTemplate
       */
      ID: number;
      Name: string;
      Description: string;
      /**
       * Entity type: UserTaskSubType
       */
      TypeID: number;
      /**
       * Entity type: OrganizationUnitSet
       */
      OrganizationUnitSetID?: number;
      Options: TaskOptions;
    }

  }

  /**
   * @deprecated Custom usertasks are deprecated and will be removed in the future.
   * Retrieve the set values
   */
  export interface GetCustomUserTaskData {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface GetCustomUserTaskDataResponse {
    /**
     * Entity type: CustomField
     */
    CustomFieldValuesWithOptions?: { [key: number]: CustomFieldValueWithOptions };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * @deprecated Custom usertasks are deprecated and will be removed in the future.
   * Starts a new custom usertask
   */
  export interface StartCustomUserTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface StartCustomUserTaskResponse {
    CustomFields: StartCustomUserTaskResponse.CustomFieldInfo[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace StartCustomUserTaskResponse {
    export interface CustomFieldInfo {
      CustomFieldResponse: CustomFieldResponse;
      InputHint: string;
      IsRequired: boolean;
    }

  }

  /**
   * Completes a ConsolidatedPickTask task.
   */
  export interface CompleteConsolidatedPickTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  /**
   * Completes a ConsolidatedZonePickTask
   */
  export interface CompleteConsolidatedZonePickTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    Products: CompleteConsolidatedZonePickTaskProduct[];
  }

  export interface CompleteConsolidatedZonePickTaskProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
    Quantity: number;
  }

  /**
   * Returns a detailed view of a ConsolidatedPickTask by the ID of its UserTask.
   */
  export interface GetConsolidatedPickTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface GetConsolidatedPickTaskResponse {
    /**
     * Entity type: ConsolidatedPickTask
     */
    ID: number;
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    Status: ConsolidatedPickTaskStatus;
    ZonePickTasks: GetConsolidatedPickTaskZonePickTasks[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum ConsolidatedPickTaskStatus {
    New = 0,
    InProgress = 1,
    Done = 2,
    Stopped = 3,
    Paused = 4
  }

  export interface GetConsolidatedPickTaskZonePickTasks {
    /**
     * Entity type: ConsolidatedZonePickTask
     */
    ID?: number;
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
    IsCompleted?: boolean;
    IsActive?: boolean;
    /**
     * Entity type: User
     */
    UserID?: number;
    UserName?: string;
    CreationTime?: string;
    StartTime?: string;
    CompletionTime?: string;
    ProductZone?: GetConsolidatedPickTaskZone;
    TotalProducts?: number;
    TotalQuantity?: number;
    TotalPickedQuantity?: number;
  }

  export interface GetConsolidatedPickTaskZone {
    /**
     * Entity type: ProductZone
     */
    ID: number;
    Name: string;
    FilterAttribute?: string;
  }

  /**
   * Pauses a ConsolidatedPickTask task.
   */
  export interface PauseConsolidatedPickTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  /**
   * Starts a ConsolidatedZonePickTask
   */
  export interface StartConsolidatedZonePickTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface StartConsolidatedZonePickTaskResponse {
    /**
     * Entity type: ConsolidatedZonePickTask
     */
    ID: number;
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    Products: StartConsolidatedZonePickTaskProduct[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface StartConsolidatedZonePickTaskProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
    Product: any;
    Quantity: number;
    PickedQuantity: number;
  }

  /**
   * Updates the picked quantity of products on a ConsolidatedZonePickTask
   */
  export interface UpdateConsolidatedZonePickTask {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    Products: UpdateConsolidatedZonePickTaskProduct[];
  }

  export interface UpdateConsolidatedZonePickTaskProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
    Quantity: number;
  }

  export interface DeactivateUserTask {
    /**
     * Entity type: UserTask
     */
    UserTaskIDs: number[];
    /**
     * A reason, if any, why the tasks were disabled. Optional.
     * Entity type: UserTaskNotCompletedReason
     */
    ReasonID?: number;
  }

  /**
   * Deactivates all active user tasks based on organization unit. Not supported on production environments!
   */
  export interface DeactivateAllUserTasks {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  /**
   * Return the total number of open tasks, and the count per task type.
   */
  export interface GetUserTaskCounts {
    /**
     * Defaults to the current organization when omitted - includes child organizations
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * When specified, will include all assigned tasks in the counts (regardless of whom it is assigned to)
     * @deprecated No longer supported, counts always include all tasks
     */
    IncludeAssignedTasks?: boolean;
    /**
     * When specified, will include all tasks, regardless if the user can execute them
     * @deprecated No longer supported, results are permission-filtered.
     */
    IncludeAllTasks?: boolean;
    /**
     * When specified, will include only tasks from the specified organization unit, excluding child organizations
     * @deprecated No longer supported, result only include the current ou/requested ou
     */
    ExcludeChildOrganizations?: boolean;
    /**
     * Optionally (and additionally) filter on specified types
     */
    UserTaskTypes?: string[];
  }

  export interface GetUserTaskCountsResponse {
    NumberOfTasks: number;
    UrgentTasksCount: number;
    MyTasksCount: number;
    RepairTasksCount: number;
    DetailedNumberOfTasks: { [key: string]: GetUserTaskCountsResponse.UserTaskCount };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetUserTaskCountsResponse {
    export interface UserTaskCount {
      Count: number;
      SubTypeCounts: { [key: string]: number };
    }

  }

  export interface GetUserTaskDetails {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface GetUserTaskDetailsResponse {
    Details: UserTaskDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface UserTaskDto {
    /**
     * Entity type: UserTask
     */
    ID: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    User: UserDto;
    UserFullname: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnit: OrganizationUnitDto;
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    FinancialPeriod: FinancialPeriodDto;
    Type: UserTaskTypeDto;
    Priority: number;
    IsCompleted: boolean;
    IsActive: boolean;
    CreationTime: string;
    Deadline?: string;
    ExpectedTimeToComplete?: string;
    ExpectedStartTime?: string;
    StartTime?: string;
    ExpectedCompletionTime?: string;
    CompletionTime?: string;
    HasUrgency: boolean;
    Description: string;
    Results: UserTaskDto.Result[];
    DeactivationReason: EnumDto;
  }

  export namespace UserTaskDto {
    export interface Result {
      Name: string;
      Description: string;
      Type: string;
      Value: string;
      Data: string;
    }

  }

  /**
   * List the available UserTasks for the current user.
   * 
   * The response has a `Aggregations` property. This property contains the available filters for this set of UserTasks.
   * To apply such a filter it should added in the `Filters` property on the RequestMessage.
   * 
   * Example response:
   * ```
   * {
   * ...
   * ,
   *   "Aggregations": {
   *       "ZonedCycleCountPreCount": {
   *         "CycleCountZoneID": [
   *           {
   *             "Name": "Shelves",
   *             "Value": 10,
   *             "Count": 1
   *           },
   *           {
   *             "Name": "Stockroom",
   *             "Value": 12,
   *             "Count": 6
   *           },
   *           {
   *             "Name": "Store",
   *             "Value": 13,
   *             "Count": 4
   *           }
   *         ]
   *       }
   *     }
   *   }
   * }
   * ```
   * 
   * To apply a matching filter:
   * ```
   * {
   *   "Filters": {
   *     "ZonedCycleCountPreCount": {
   *       "CycleCountZoneID": [10]
   *     }
   *   }
   * }
   * ```
   */
  export interface ListAvailableUserTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
    /**
     * Return only Hidden/Visible UserTasks
     * @default false
     */
    IsHidden?: boolean;
    /**
     * Return only UserTasks of one of the specified types
     */
    UserTaskTypes?: string[];
    /**
     * Return only UserTasks with one of the specified subtypes
     */
    UserTaskSubTypes?: string[];
    /**
     * Return only UserTasks with one of the specified labels
     */
    Labels?: string[];
    /**
     * Filter for a specific UserTaskType.Name using a property name and a list of values.
     */
    Filters?: { [key: string]: { [key: string]: any[] } };
  }

  export interface ListAvailableUserTasksResponse {
    AvailableTasks: AvailableUserTaskDto[];
    Aggregations: { [key: string]: { [key: string]: UserTaskDataAggregation[] } };
    Labels: { [key: string]: number };
    /**
     * Indicates if the store has a full stock count in progress.
     */
    HasActiveFullStockCount: boolean;
    /**
     * Indicates if one or more confirmation tasks (evem the ones without viewing rights) have AllowStockMutationsDuringCount on true
     */
    AllowStockMutationsDuringCount: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface AvailableUserTaskDto {
    /**
     * Entity type: UserTask
     */
    ID: number;
    /**
     * Entity type: UserTask
     */
    ParentID?: number;
    Description: string;
    Priority: number;
    PriorityDescription: string;
    Sequence: number;
    CanBeIgnored: boolean;
    Labels: string[];
    CreationTime: string;
    StartTime?: string;
    ExpectedTimeToComplete?: string;
    ExpectedCompletionTime?: string;
    Deadline?: string;
    User: UserDto;
    Type: UserTaskTypeDto;
    SubType: EnumDto;
    Children: AvailableUserTaskDto[];
    Data: { [key: string]: any };
    HasUrgency: boolean;
  }

  export interface UserTaskDataAggregation {
    Name: string;
    Value: any;
    Count: number;
  }

  /**
   * Returns the current tasks that prevent the current organization units' financial period from closing.
   */
  export interface ListTasksThatBlockPeriodClosing {
  }

  export interface ListTasksThatBlockPeriodClosingResponse {
    Tasks: UserTaskDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface GetUserTaskNotCompletedReasons {
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
  }

  export interface GetUserTaskNotCompletedReasonsResponse {
    Reasons: GetUserTaskNotCompletedReasonsResponse.Reason[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetUserTaskNotCompletedReasonsResponse {
    export interface Reason {
      ReasonID: number;
      Name: string;
      IsSystem: boolean;
      Usages: ReasonUsageWithDescription[];
    }

  }

  export interface ReasonUsageWithDescription {
    UserTaskTypeID?: number;
    UserTaskSubTypeID?: number;
    UserTaskType?: string;
    UserTaskSubType?: string;
    OrganizationUnitSetID?: number;
    OrganizationUnitSetName?: string;
  }

  export interface CreateUserTaskNotCompletedReason {
    Name?: string;
    Usages?: ReasonUsage[];
  }

  export interface ReasonUsage {
    /**
     * Entity type: UserTaskType
     */
    UserTaskTypeID?: number;
    /**
     * Entity type: UserTaskSubType
     */
    UserTaskSubTypeID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitSetID?: number;
  }

  export interface CreateUserTaskNotCompletedReasonResponse {
    /**
     * Entity type: UserTaskNotCompletedReason
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface UpdateUserTaskNotCompletedReason {
    /**
     * Entity type: UserTaskNotCompletedReason
     */
    ID?: number;
    Name?: string;
    Usages?: ReasonUsage[];
  }

  export interface DeleteUserTaskNotCompletedReason {
    /**
     * Entity type: UserTaskNotCompletedReason
     */
    ID: number;
  }

  /**
   * Return all of the configured User Task Priority configurations.
   * 
   * These are used at real-time on the User Task details whenever fetched, translating the User Task `Priority` into a `PriorityDescription`. The
   * `LanguageID` and `CountryID` filters are compared against the user context requesting this information, and the `UserTaskTypeID`, `UserTaskSubTypeID`
   * and `Priority` are taken from the User Task itself. The `Priority` from the User Task will be compared against the `From` and `To` ranges defined,
   * where the `From` priority is an *inclusive* lower bound, while `To` is the *exclusive* upper bound.
   * 
   * The `Description` will be used to describe the priority, but when left empty, will fall back to `Name`.
   * 
   * An example configuration could be as follows;
   * 
   * ```
   * Language | From | To | Description
   * ---------|------|----|------------
   *       NL |      |    | Standaard
   *       NL |   10 |    | Spoed
   *       DE |      | 10 | Unwichtig
   *          |      |    | Default
   * ```
   * 
   * A User Task with priority 9 for a Dutch employee would be labelled "Standaard", while for a German colleague this would be called "Unwichtig". A
   * User Task of priority 10 would be called "Spoed" in Dutch, but "Default" in German.
   * 
   * :sunglasses: For added awesomeness, if you define overlapping priority ranges, we'll select the most narrow range for you.
   */
  export interface GetUserTaskPriorities {
  }

  export interface GetUserTaskPrioritiesResponse {
    Result: UserTaskPriorityDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface UserTaskPriorityDto {
    From?: number;
    To?: number;
    /**
     * Entity type: UserTaskType
     */
    UserTaskTypeID?: number;
    /**
     * Entity type: UserTaskSubType
     */
    UserTaskSubTypeID?: number;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: Enum
     */
    ID: number;
    /**
     * Usually an internal & unchangable code - for display, use `Description`
     */
    Name: string;
    Description: string;
  }

  /**
   * Creates a new User Task Priority.
   */
  export interface CreateUserTaskPriority {
    Name?: string;
    Description?: string;
    /**
     * Inclusive
     */
    From?: number;
    /**
     * Exclusive
     */
    To?: number;
    /**
     * Entity type: UserTaskType
     */
    UserTaskTypeID?: number;
    /**
     * Entity type: UserTaskSubType
     */
    UserTaskSubTypeID?: number;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
  }

  export interface CreateUserTaskPriorityResponse {
    /**
     * Entity type: UserTaskPriority
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Updates an existing User Task Priority.
   */
  export interface UpdateUserTaskPriority {
    /**
     * Entity type: UserTaskPriority
     */
    ID: number;
    Name?: string;
    Description?: string;
    /**
     * Inclusive
     */
    From?: number;
    /**
     * Exclusive
     */
    To?: number;
    /**
     * Entity type: UserTaskType
     */
    UserTaskTypeID?: number;
    /**
     * Entity type: UserTaskSubType
     */
    UserTaskSubTypeID?: number;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
  }

  /**
   * Deletes a User Task Priority.
   */
  export interface DeleteUserTaskPriority {
    /**
     * Entity type: UserTaskPriority
     */
    ID: number;
  }

  export interface CreateUserTaskTypeOrganizationUnitSet {
    /**
     * Entity type: UserTaskType
     */
    UserTaskTypeID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    Required: boolean;
    IgnoreForPeriodClosing?: boolean;
  }

  export interface UserTaskTypeOrganizationUnitSetResponse {
    Result: UserTaskTypeOrganizationUnitSetDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface UserTaskTypeOrganizationUnitSetDto {
    ID: number;
    UserTaskTypeID: number;
    OrganizationUnitSetID: number;
    Required: boolean;
    IgnoreForPeriodClosing: boolean;
  }

  export interface GetUserTaskTypeOrganizationUnitSet {
    /**
     * Entity type: UserTaskType
     */
    UserTaskTypeID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
  }

  export interface UpdateUserTaskTypeOrganizationUnitSet {
    /**
     * Entity type: UserTaskType
     */
    UserTaskTypeID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    Required: boolean;
    IgnoreForPeriodClosing?: boolean;
  }

  export interface DeleteUserTaskTypeOrganizationUnitSet {
    /**
     * Entity type: UserTaskType
     */
    UserTaskTypeID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
  }

  export interface ListUserTaskTypeOrganizationUnitSets {
    PageConfig?: PageConfig<ListUserTaskTypeOrganizationUnitSetsFilter>;
  }

  export interface ListUserTaskTypeOrganizationUnitSetsFilter {
    /**
     * Entity type: UserTaskType
     */
    UserTaskTypeID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    Required?: boolean;
  }

  export interface ListUserTaskTypeOrganizationUnitSetsResponse {
    Result?: PagedResult<UserTaskTypeOrganizationUnitSetDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface GetUserTaskTypes {
    /**
     * If set to true each UserTaskType will also include all of its subtypes, if any.
     */
    IncludeSubTypes?: boolean;
  }

  export interface GetUserTaskTypesResponse {
    Types?: UserTaskTypeDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface UpdateUserTaskType {
    /**
     * Entity type: UserTaskType
     */
    ID: number;
    DefaultPriority?: number;
  }

  export interface CompleteZonedCycleCountPreCount {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    Results: CompleteZonedCycleCountPreCountResult[];
  }

  export interface CompleteZonedCycleCountPreCountResult {
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    /**
     * The stock product ID that was counted, this should be provided if the product of the cycle count is a stock aggregate.
     * Entity type: Product
     */
    StockProductID?: number;
    CountedQuantity?: number;
    SerialNumber?: string;
  }

  export interface CompleteZonedCycleCounts {
    ToComplete: ZonedCycleCountToComplete[];
    CompletionType: CompleteZonedCycleCountCompletionTypes;
  }

  export interface ZonedCycleCountToComplete {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    DeviationReason?: string;
    CountedQuantityCorrections?: ZonedCycleCountToCompleteQuantityCorrection[];
  }

  export interface ZonedCycleCountToCompleteQuantityCorrection {
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    NewCountedQuantity: number;
    /**
     * For which counted product under this cycle count this correction is intended.
     * Entity type: Product
     */
    ProductID?: number;
  }

  export const enum CompleteZonedCycleCountCompletionTypes {
    AcceptPreCount = 0,
    Recount = 1
  }

  export interface CountStockLabelForZonedCycleCount {
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    /**
     * Entity type: Product
     */
    StockProductID?: number;
    CountedQuantity?: number;
    SerialNumber?: string;
  }

  export interface CountStockLabelForZonedCycleCountResponse {
    CountResult: ZonedCycleCountResultTypes;
    IsCompleted: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum ZonedCycleCountResultTypes {
    Accepted = 0,
    Recount = 1,
    CompleteResources = 2
  }

  /**
   * Creates one cycle count for the requested Product and Organization Unit (with origin Manual)
   */
  export interface CreateZonedCycleCount {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
  }

  export interface CreateZonedCycleCountResponse {
    Created: CycleCountEntry[];
    Skipped: CycleCountEntry[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface CycleCountEntry {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    /**
     * Entity type: Product
     */
    ProductID: number;
    ProductName: string;
    ProductBackendID?: string;
    /**
     * Entity type: UserTask
     */
    TaskID?: number;
    NotCreatedReason?: CycleCountNotCreatedReason;
  }

  export const enum CycleCountNotCreatedReason {
    AlreadyExists = 0,
    ProductNotStock = 1,
    ProductNotInAssortment = 2
  }

  /**
   * Creates cycle counts for all requested combinations of Products and Organization Units (with origin Manual). Use this service through the async service endpoints.
   */
  export interface CreateZonedCycleCounts {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs: number[];
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
  }

  export interface CreateZonedCycleCountsResponse {
    Created?: CycleCountEntry[];
    Skipped?: CycleCountEntry[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Creates cycle counts for all requested combinations of (type Stock) Products and Organization Units that match specified filters (with origin Manual). Use this service through the async service endpoints.
   */
  export interface CreateZonedCycleCountsByQuery {
    /**
     * Query for the product search
     */
    Query?: string;
    /**
     * Filters to apply to product search
     */
    Filters?: { [key: string]: FilterModel };
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
  }

  export namespace CreateZonedCycleCountsByQuery {
    export interface OrganizationUnitFilterModel {
      /**
       * Entity type: OrganizationUnit
       */
      IDs: number[];
      BackendIDs: string[];
      /**
       * Entity type: Country
       */
      CountryIDs: string[];
      StatusID?: number;
    }

  }

  export interface CreateZonedCycleCountsByQueryResponse {
    Created?: CycleCountEntry[];
    Skipped?: CycleCountEntry[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface GetCycleCountOriginTypes {
  }

  export interface GetCycleCountOriginTypesResponse {
    Result: EnumDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface UpdateCycleCountOriginType {
    /**
     * Entity type: CycleCountOriginType
     */
    ID: number;
    Description?: string;
  }

  /**
   * Creates a new CycleCountZoneGroup.
   */
  export interface CreateCycleCountZoneGroup {
    Name?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Entity type: CycleCountZone
     */
    ZoneIDs?: number[];
  }

  export interface CreateCycleCountZoneGroupResponse {
    /**
     * Entity type: CycleCountZoneGroup
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Updates an existing CycleCountZoneGroup.
   */
  export interface UpdateCycleCountZoneGroup {
    /**
     * Entity type: CycleCountZoneGroup
     */
    ID: number;
    Name?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    /**
     * Entity type: CycleCountZone
     */
    ZoneIDs?: number[];
  }

  /**
   * Deletes a CycleCountZoneGroup by its ID
   */
  export interface DeleteCycleCountZoneGroup {
    /**
     * Entity type: CycleCountZoneGroup
     */
    ID: number;
  }

  /**
   * Gets all the CycleCountZoneGroups based on the given filter and returns a paged response.
   */
  export interface ListCycleCountZoneGroups {
    PageConfig?: PageConfig<ListCycleCountGroupsFilter>;
  }

  export interface ListCycleCountGroupsFilter {
    Name: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: CycleCountZone
     */
    CycleCountZoneID?: number;
    /**
     * Entity type: CycleCountZoneGroup
     */
    CycleCountZoneGroupIDs: number[];
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetIDs?: number[];
  }

  export interface ListCycleCountZoneGroupsResponse {
    Result?: PagedResult<ListCycleCountZoneGroupsResponse.CycleCountZoneGroupDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListCycleCountZoneGroupsResponse {
    export interface CycleCountZoneGroupDto {
      /**
       * Entity type: CycleCountZoneGroup
       */
      ID: number;
      Name: string;
      /**
       * Entity type: OrganizationUnitSet
       */
      OrganizationUnitSetID: number;
      OrganizationUnitSetName: string;
      Zones: EnumDto[];
    }

  }

  /**
   * Before calling Create/UpdateCycleCountZone group you can call this service to perform some checks on the validity of the new zone group.
   * Currently it only returns warnings and calling it is not required before creating or updating the group, but it is recommended as it prevents confusing situations such as the same OrganizationUnit being part
   * of multiple groups at the same time.
   */
  export interface ValidateCycleCountZoneGroup {
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
  }

  export interface ValidateCycleCountZoneGroupResponse {
    HasWarnings: boolean;
    Warnings: ValidateCycleCountZoneGroupResponse.Warning[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ValidateCycleCountZoneGroupResponse {
    export interface Warning {
      Type: string;
      Message: string;
    }

  }

  export interface CreateCycleCountZone {
    Name: string;
    Description?: string;
  }

  export interface CreateCycleCountZoneResponse {
    /**
     * Entity type: CycleCountZone
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface UpdateCycleCountZone {
    /**
     * Entity type: CycleCountZone
     */
    ID: number;
    Name: string;
    Description?: string;
  }

  export interface DeleteCycleCountZone {
    /**
     * Entity type: CycleCountZone
     */
    ID: number;
  }

  export interface GetUserWhoDeletedCycleCountZoneAndMakeItGreatAgain {
    /**
     * Entity type: CycleCountZone
     */
    ID: number;
  }

  export interface GetUserWhoDeletedCycleCountZoneAndMakeItGreatAgainResponse {
    LastModifiedByID?: number;
    LastModificationTime?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface GetCycleCountZones {
  }

  export interface GetCycleCountZonesResponse {
    Result: CycleCountZoneDto[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface CycleCountZoneDto {
    /**
     * Entity type: CycleCountZone
     */
    ID: number;
    Name: string;
    Description: string;
  }

  export interface ReplaceCycleCountZonesForOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: CycleCountZone
     */
    CycleCountZoneIDs?: number[];
  }

  export interface ListCycleZonesForOrganizationUnits {
    PageConfig?: PageConfig<ListOrganizationUnitCycleCountZonesFilter>;
  }

  export interface ListOrganizationUnitCycleCountZonesFilter {
    OrganizationUnitID: number;
  }

  export interface ListCycleZonesForOrganizationUnitsResponse {
    Result?: PagedResult<CycleCountZonesForOrganizationUnitDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface CycleCountZonesForOrganizationUnitDto {
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    Zones: CycleCountZoneDto[];
  }

  /**
   * Deactivate the given ZonedCycleCounts
   * 
   * Also deactivates linked PreCounts
   */
  export interface DeactivateZonedCycleCount {
    /**
     * Entity type: UserTask
     */
    UserTaskIDs: number[];
    /**
     * A reason, if any, why the tasks were disabled. Optional.
     */
    Reason?: string;
  }

  /**
   * Gets the status of the pre-counts of a cyclecount, if any. The input for this service is either the ID of the main count task (`ZonedCycleCountUserTaskID`)
   * or the ID of a pre-count task (`PreCountUserTaskID`). If `PreCountUserTaskID` is specified, it returns the status of the sibling pre-counts.
   */
  export interface GetStatusForZonedCycleCountPreCounts {
    /**
     * Entity type: UserTask
     */
    ZonedCycleCountUserTaskID?: number;
    /**
     * Entity type: UserTask
     */
    PreCountUserTaskID?: number;
  }

  export interface GetStatusForZonedCycleCountPreCountsResponse {
    PreCounts: GetStatusForZonedCycleCountPreCountsResponse.PreCountStatus[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetStatusForZonedCycleCountPreCountsResponse {
    export interface PreCountStatus {
      CycleCountZone: EnumDto;
      IsCompleted: boolean;
      IsStarted: boolean;
      /**
       * Entity type: User
       */
      UserID?: number;
      UserFullName: string;
      CompletionTime?: string;
      PreCountedQuantity?: number;
      CountResults: PreCountStatus.Result[];
    }

    export namespace PreCountStatus {
      export interface Result {
        StockLabel: EnumDto;
        CountedQuantity: number;
        CreationTime: string;
      }

    }

  }

  /**
   * Returns a detailed view of a ZonedCycleCountPreCount by the ID of its UserTask.
   * 
   * The response contains:
   * 
   * - Which StockLabels to count (`StockLabelsToCount`)
   * - The product that needs to be counted (`Product`); this product contains all the fields in its `Content` object that were requested through the `IncludedFields` property on the request, or a default set of fields if not specified
   * - Zone that needs to be counted (`CycleCountZone`)
   * - List of stock labels to be counted (`StockLabelsToCount`)
   * - List of required resource types (`RequiredResourceTypes`)
   */
  export interface GetZonedCycleCountPreCount {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface GetZonedCycleCountPreCountResponse {
    /**
     * Entity type: ZonedCycleCountPreCount
     */
    ID: number;
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    CycleCountZone: EnumDto;
    StockLabelsToCount: EnumDto[];
    Product: GetZonedCycleCountPreCountResponse.GetZonedCycleCountPreCountProduct;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace GetZonedCycleCountPreCountResponse {
    export interface GetZonedCycleCountPreCountProduct {
      /**
       * Entity type: Product
       */
      ID: number;
      CustomID: string;
      Type: ProductTypes;
      Content: any;
      UnitPriceInTax: number;
      CurrencyID: string;
    }

  }

  /**
   * Returns a detailed view of a ZonedCycleCount by the ID of its UserTask.
   * 
   * The response contains:
   * 
   * - Which StockLabels to count (`StockLabelsToCount`)
   * - The product that needs to be counted. This product contains all the fields in its `Content` object that were requested through the `IncludedFields` property on the request, or a default set of fields if not specified.
   * - Which StockMutations have been created since the first pre-count (if any) per StockLabel (`StockMutationsSincePreCount`)
   * - A list of all pre-counts, complete with the zone that needs to be counted, the user who did the count (if the count already happened) and a list of count results per StockLabel
   * - A list of pre-counted quantityies per StockLabel (`PreCountedQuantities`)
   * - A list of the total quantity of stock mutated per StockLabel (a summary of `StockMutationsSincePreCount`).
   * - The current stock per StockLabel
   * - ExpectedPreCountedQuantity: This is stored on the ZonedCyleCount the moment the last pre-count has been completed, and is a sum of the expected Stock at that moment.
   * - PreCountedQuantity: The quantity that was actually counted in all pre-counts over all StockLabels. This is recorded when all pre-counts have been completed.
   */
  export interface GetZonedCycleCount {
    /**
     * Entity type: UserTask
     */
    ID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface GetZonedCycleCountResponse {
    ID: number;
    UserTaskID: number;
    IsCompleted: boolean;
    IsActive: boolean;
    UserID?: number;
    UserName: string;
    CreatedByID: number;
    CreatedByUserName: string;
    CreationTime: string;
    StartTime?: string;
    CompletionTime?: string;
    ResultStatus?: ZonedCycleCountResultStatus;
    OriginTypeID?: number;
    OriginID?: number;
    IsDeviationReasonRequired: boolean;
    StockLabelsToCount: EnumDto[];
    Product: GetZonedCycleCountProduct;
    StockProducts: GetZonedCycleCountStockProduct[];
    StockMutationsSincePreCount: GetZonedCycleCountStockMutation[];
    PreCounts: GetZonedCycleCountPreCountDto[];
    PreCountedQuantities: GetZonedCycleCountPreCountedQuantity[];
    StockMutationQuantitiesSincePreCount: GetZonedCycleCountStockMutationQuantity[];
    StockLabelQuantities: GetZonedCyleCountStockLabelQuantities[];
    ExpectedPreCountedQuantity?: number;
    PreCountedQuantity?: number;
    Remark?: string;
    SerialNumberRequired: boolean;
    SerialNumberConfigurationID?: number;
    IsMatchOnTotalQuantity: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum ZonedCycleCountResultStatus {
    None = 0,
    /**
     * The results of the PreCounts matched the expected stock, so no stockmutations were created
     */
    Correct = 1,
    /**
     * The cyclecount results were discarded and a new one is created
     */
    RecountRequested = 2,
    /**
     * The results of the PreCounts are modified during finalizing
     */
    Modified = 4,
    /**
     * The finalizing resulted in at least one stockmutation
     */
    Deviated = 8
  }

  export interface GetZonedCycleCountProduct {
    ID: number;
    CustomID: string;
    Type: ProductTypes;
    Content: any;
  }

  export interface GetZonedCycleCountStockProduct {
    /**
     * Entity type: Product
     */
    ID?: number;
    BackendID?: string;
  }

  export interface GetZonedCycleCountStockMutation {
    StockLabel: EnumDto;
    StockMutationReason: EnumDto;
    MutationQuantity: number;
    CreationTime: string;
    /**
     * Entity type: Product
     */
    ProductID: number;
    Remark?: string;
  }

  export interface GetZonedCycleCountPreCountDto {
    /**
     * Entity type: ZonedCycleCountPreCount
     */
    ID: number;
    CycleCountZone: EnumDto;
    User: GetZonedCycleCountPreCountUserDto;
    Results: GetZonedCycleCountPreCountResult[];
  }

  export interface GetZonedCycleCountPreCountUserDto {
    ID: number;
    Name: string;
  }

  export interface GetZonedCycleCountPreCountResult {
    StockLabel: EnumDto;
    CountedQuantity: number;
    CreationTime: string;
    CurrentStock?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
  }

  export interface GetZonedCycleCountPreCountedQuantity {
    StockLabel: EnumDto;
    CountedQuantity?: number;
    MatchType: GetZonedCycleCountMatchType;
    StockProducts: GetZonedCycleCountPreCountedQuantityStockProduct[];
  }

  export const enum GetZonedCycleCountMatchType {
    NoMatch = 0,
    ExactMatch = 1,
    MatchOnTotalQuantity = 2
  }

  export interface GetZonedCycleCountPreCountedQuantityStockProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
    CountedQuantity?: number;
    CurrentStock?: number;
  }

  export interface GetZonedCycleCountStockMutationQuantity {
    TotalMutationQuantity: number;
    Since: string;
    StockLabel: EnumDto;
    StockProducts: GetZonedCycleCountStockProductMutationQuantity[];
  }

  export interface GetZonedCycleCountStockProductMutationQuantity {
    /**
     * Entity type: Product
     */
    ProductID: number;
    MutationQuantity: number;
  }

  export interface GetZonedCyleCountStockLabelQuantities {
    StockLabel: EnumDto;
    CurrentQuantityOnHand: number;
    ExpectedQuantity: number;
    CountedQuantity: number;
    ModifiedQuantity?: number;
    MatchesOnTotalQuantity: GetZonedCycleCountMatchType;
    StockProducts: GetZonedCyleCountStockLabelQuantitiesStockProduct[];
  }

  export interface GetZonedCyleCountStockLabelQuantitiesStockProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
    IsStockAggregate: boolean;
    CurrentQuantityOnHand: number;
    ExpectedQuantity: number;
    CountedQuantity: number;
  }

  /**
   * Returns a count of potential cycle counts that would be created for the combinations of (type Stock) Products and Organization Units that match specified filters. Use this service to preview results before actual creation.
   */
  export interface GetZonedCycleCountsEstimateByQuery {
    /**
     * Query for the product search
     */
    Query?: string;
    /**
     * Filters to apply to product search
     */
    Filters?: { [key: string]: FilterModel };
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
  }

  export interface GetZonedCycleCountsEstimateByQueryResponse {
    /**
     * Estimated total number of cycle counts that would be created
     */
    CycleCountsEstimate: number;
    /**
     * Number of products matching the filters
     */
    ProductsCount: number;
    /**
     * Number of organization units matching the filters
     */
    OrganizationUnitsCount: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Lists results associated with a Zoned Cycle Count PreCount
   */
  export interface ListZonedCycleCountPreCountResult {
    /**
     * Entity type: ZonedCycleCountPreCount
     */
    ZonedCycleCountPreCountID: number;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListZonedCycleCountPreCountResultResponse {
    Result?: PagedResult<ListZonedCycleCountPreCountResultDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListZonedCycleCountPreCountResultDto {
    /**
     * Entity type: ZonedCycleCountPreCount
     */
    ID?: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    /**
     * Entity type: SerialNumber
     */
    SerialNumberID?: number;
    SerialNumber?: string;
  }

  /**
   * Retrieves the status of serial numbers for a specific product and stock label within a Zoned Cycle Count.
   */
  export interface ListZonedCycleCountSerialNumbersStatus {
    /**
     * Entity type: ZonedCycleCount
     */
    ZonedCycleCountID: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID: number;
    PageConfig?: PageConfig<ListZonedCycleCountSerialNumbersStatusFilter>;
  }

  export interface ListZonedCycleCountSerialNumbersStatusFilter {
    Statuses?: ZonedCycleCountSerialNumberStatus[];
    SerialNumbers?: string[];
  }

  export const enum ZonedCycleCountSerialNumberStatus {
    /**
     * Serial number was expected and counted.
     */
    ExpectedAndCounted = 0,
    /**
     * Serial number was expected but not counted.
     */
    ExpectedNotCounted = 1,
    /**
     * Serial number was expected but counted on a different stock label.
     */
    CountedOnDifferentStockLabel = 2,
    /**
     * Serial number was expected but counted on a different organization unit.
     */
    CountedOnDifferentOrganizationUnit = 3,
    /**
     * Serial number was expected but counted as a different product.
     */
    CountedAsDifferentProduct = 4,
    /**
     * Serial number was counted but not expected.
     */
    Unexpected = 5
  }

  export interface ListZonedCycleCountSerialNumbersStatusResponse {
    Result?: PagedResult<ZonedCycleCountSerialNumberStatusDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ZonedCycleCountSerialNumberStatusDto {
    /**
     * Entity type: StockLabel
     */
    ExpectedStockLabelID?: number;
    /**
     * Entity type: StockLabel
     */
    CountedStockLabelID?: number;
    SerialNumber?: string;
    Status?: ZonedCycleCountSerialNumberStatus;
  }

  /**
   * The page size `Limit` has a maximum value of `250` for this service.
   */
  export interface ListZonedCycleCounts {
    PageConfig?: PageConfig<ListZonedCycleCountsFilter>;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProductProperties?: string[];
  }

  export interface ListZonedCycleCountsFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs: number[];
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: UserTask
     */
    UserTaskIDs: number[];
    /**
     * Entity type: CycleCountOriginType
     */
    OriginTypeID?: number;
    IsCompleted?: boolean;
    InProgress?: boolean;
    ResultStatus?: ZonedCycleCountResultStatus;
    IsActive?: boolean;
    FromDate?: string;
    ToDate?: string;
    /**
     * When set to `true`, will overwrite `OrganizationUnitIDs` with given `OrganizationUnitID` and all its children.
     */
    IncludeChildOrganizationUnits?: boolean;
  }

  export interface ListZonedCycleCountsResponse {
    Result?: PagedResult<ListZonedCycleCountsDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListZonedCycleCountsDto {
    ID: number;
    UserTaskID: number;
    IsCompleted: boolean;
    IsActive: boolean;
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    UserID?: number;
    UserName: string;
    CreatedByID: number;
    CreatedByUserName: string;
    CreationTime: string;
    StartTime?: string;
    CompletionTime?: string;
    ResultStatus?: ZonedCycleCountResultStatus;
    OriginTypeID?: number;
    OriginID?: number;
    ProductID: number;
    Product: any;
    BackendID: string;
    CustomID: string;
    ProductBarcode: string;
    ProductDisplayValue: string;
    ExpectedPreCountedQuantity?: number;
    PreCountedQuantity?: number;
    PreCountedDifference?: number;
    DeviationPercentage?: number;
    FinishedPreCountTasks: number;
    TotalPreCountTasks: number;
    PreCountProgression?: number;
  }

  /**
   * 
   */
  export interface ProduceZonedCycleCountHandout {
    /**
     * Entity type: CycleCountZone
     */
    CycleCountZoneIDs: number[];
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: Station
     */
    StationID?: number;
    Channel: TemplateOutputChannel;
  }

  export const enum TemplateOutputChannel {
    Print = 1,
    Download = 2,
    Email = 4,
    Receipt = 8
  }

  export interface ProduceZonedCycleCountHandoutResponse {
    Url: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Starts a ZonedCycleCountPreCount by the ID of its UserTask.
   * 
   * The response contains:
   * 
   * - Which StockLabels to count (`StockLabelsToCount`)
   * - The product that needs to be counted (`Product`); this product contains all the fields in its `Content` object that were requested through the `IncludedFields` property on the request, or a default set of fields if not specified
   * - Zone that needs to be counted (`CycleCountZone`)
   * - List of stock labels to be counted (`StockLabelsToCount`)
   */
  export interface StartZonedCycleCountPreCount {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface StartZonedCycleCountPreCountResponse {
    ID: number;
    UserTaskID: number;
    CycleCountZone: EnumDto;
    StockLabelsToCount: EnumDto[];
    Product: StartZonedCycleCountPreCountResponse.StartZonedCycleCountPreCountProduct;
    StockProducts: StartZonedCycleCountPreCountResponse.StartZonedCycleCountPreCountStockProduct[];
    MatchOnTotalQuantity: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace StartZonedCycleCountPreCountResponse {
    export interface StartZonedCycleCountPreCountProduct {
      ID: number;
      CustomID: string;
      Type: ProductTypes;
      Content: any;
      UnitPriceInTax: number;
      CurrencyID: string;
      SerialNumberRequired: boolean;
      /**
       * Entity type: SerialNumberConfiguration
       */
      SerialNumberConfigurationID?: number;
    }

    export interface StartZonedCycleCountPreCountStockProduct {
      /**
       * Entity type: Product
       */
      ID: number;
      BackendID: string;
    }

  }

  export interface StartZonedCycleCount {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface StartZonedCycleCountResponse {
    ID: number;
    UserTaskID: number;
    StockLabelsToCount: EnumDto[];
    Product: StartZonedCycleCountProduct;
    StockProducts: StartZonedCycleCountStockProduct[];
    StockMutationsSincePreCount: StartZonedCycleCountStockMutation[];
    StockMutationQuantitiesSincePreCount: StartZonedCycleCountStockMutationQuantity[];
    PreCounts: StartZonedCycleCountPreCountDto[];
    PreCountedQuantities: StartZonedCycleCountPreCountedQuantity[];
    CurrentStock: StartZonedCyleCountCurrentStock[];
    ExpectedPreCountedQuantity?: number;
    PreCountedQuantity?: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface StartZonedCycleCountProduct {
    ID: number;
    CustomID: string;
    Type: ProductTypes;
    Content: any;
    UnitPriceInTax: number;
    CurrencyID: string;
    SerialNumberRequired: boolean;
    /**
     * Entity type: SerialNumberConfiguration
     */
    SerialNumberConfigurationID?: number;
  }

  export interface StartZonedCycleCountStockProduct {
    /**
     * Entity type: Product
     */
    ID: number;
    BackendID: string;
  }

  export interface StartZonedCycleCountStockMutation {
    StockLabel: EnumDto;
    StockMutationReason: EnumDto;
    MutationQuantity: number;
    CreationTime: string;
  }

  export interface StartZonedCycleCountStockMutationQuantity {
    TotalMutationQuantity: number;
    Since: string;
    StockLabel: EnumDto;
  }

  export interface StartZonedCycleCountPreCountDto {
    CycleCountZone: EnumDto;
    User: StartZonedCycleCountPreCountUserDto;
    Results: StartZonedCycleCountPreCountResult[];
    IsCompleted: boolean;
  }

  export interface StartZonedCycleCountPreCountUserDto {
    ID: number;
    Name: string;
  }

  export interface StartZonedCycleCountPreCountResult {
    StockLabel: EnumDto;
    CountedQuantity: number;
    CreationTime: string;
    SerialNumber?: string;
    /**
     * Entity type: Product
     */
    ProductID: number;
  }

  export interface StartZonedCycleCountPreCountedQuantity {
    StockLabel: EnumDto;
    CountedQuantity?: number;
  }

  export interface StartZonedCyleCountCurrentStock {
    StockLabel: EnumDto;
    CurrentQuantityOnHand: number;
  }

  /**
   * Download an Excel sample which can be filled with cycle count info. The populated excel can be uploaded through the `UploadCycleCountExcel` service.
   */
  export interface DownloadCycleCountSample {
  }

  /**
   * Uploads an Excel retrieved from `DownloadCycleCountSample`.
   */
  export interface UploadCycleCountExcel {
    Data: string;
  }

  /**
   * Creates a Zoned Cycle Count Schedule.
   * 
   * It is required to specify either a set `Date`, or a `CycleCountIntervalInDays`.
   */
  export interface CreateZonedCycleCountSchedule {
    BackendID?: string;
    Description?: string;
    /**
     * Range: 1-1000
     */
    CycleCountIntervalInDays?: number;
    Date?: string;
    ProductSearchModel: ZonedCycleCountScheduleProductSearchModel;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
  }

  export interface ZonedCycleCountScheduleProductSearchModel {
    Query?: string;
    Filters?: { [key: string]: ZonedCycleCountScheduleProductSearchFilterModel };
  }

  export interface ZonedCycleCountScheduleProductSearchFilterModel {
    Values?: any[];
    From?: string;
    To?: string;
    Negation?: boolean;
    ExactMatch?: boolean;
    IncludeMissing?: boolean;
  }

  export interface CreateZonedCycleCountScheduleResponse {
    /**
     * Entity type: ZonedCycleCountSchedule
     */
    ID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Lists the Zoned Cycle Count Schedules.
   */
  export interface ListZonedCycleCountSchedules {
    PageConfig?: PageConfig<ListZonedCycleCountSchedulesFilter>;
  }

  export interface ListZonedCycleCountSchedulesFilter {
    /**
     * Entity type: ZonedCycleCountSchedule
     */
    ID?: number;
    BackendID?: string;
    Description?: string;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
  }

  export interface ListZonedCycleCountSchedulesResponse {
    Result?: PagedResult<ZonedCycleCountScheduleDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ZonedCycleCountScheduleDto {
    /**
     * Entity type: ZonedCycleCountSchedule
     */
    ID: number;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID: number;
    BackendID: string;
    Description: string;
    CycleCountIntervalInDays?: number;
    Date?: string;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    CreatedByName: string;
    /**
     * Entity type: User
     */
    LastModifiedByID?: number;
    LastModifiedByName: string;
    OrganizationUnitSetName: string;
    ProductSearchModel: ZonedCycleCountScheduleProductSearchModel;
  }

  /**
   * Updates a Zoned Cycle Count Schedule.
   */
  export interface UpdateZonedCycleCountSchedule {
    /**
     * Entity type: ZonedCycleCountSchedule
     */
    ID: number;
    BackendID?: string;
    Description?: string;
    /**
     * Range: 1-1000
     */
    CycleCountIntervalInDays?: number;
    Date?: string;
    ProductSearchModel?: ZonedCycleCountScheduleProductSearchModel;
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
  }

  /**
   * Deletes a Zoned Cycle Count Schedule.
   */
  export interface DeleteZonedCycleCountSchedule {
    /**
     * Entity type: ZonedCycleCountSchedule
     */
    ID: number;
  }

  /**
   * Complete a StockReservation task that has been started with the StartStockReservation(2) service
   * 
   * The service should be called with a line for each orderline that should be reserved. It is not required anymore to send a line for each item on a line.
   * 
   * Provide each line with an OrderLineID and a QuantityTo(Cancel/Reserve/Order).
   */
  export interface CompleteStockReservationTask {
    Task: CompleteStockReservationTask.StockReservationTask;
    /**
     * Station to print the receipt on
     * Entity type: Station
     */
    StationID?: number;
    /**
     * Should we print a receipt? Default true
     */
    PrintReceipt?: boolean;
  }

  export namespace CompleteStockReservationTask {
    export interface StockReservationTask {
      /**
       * Entity type: UserTask
       */
      UserTaskID: number;
      Lines: CompleteStockReservationTask.StockReservationTaskLine[];
    }

    export interface StockReservationTaskLine {
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      /**
       * The actual picked product. Must be provided when a stock aggregate product is returned in the task.
       * Entity type: Product
       */
      ProductID?: number;
      QuantityToCancel?: number;
      QuantityToReserve?: number;
      QuantityToOrder?: number;
      ForceComplete?: boolean;
      SerialNumber?: string;
    }

  }

  /**
   * Retrieve details on a Stock Reservation Task based on an OrderID.
   */
  export interface GetStockReservationTask {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetStockReservationTaskResponse {
    Result: StockReservationTaskDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface StockReservationTaskDto {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
    Order: OrderDto;
    OrderDisplayID?: string;
    Lines: StockReservationTaskLineDto[];
  }

  export interface StockReservationTaskLineDto {
    IsCancelled: boolean;
    IsReserved: boolean;
    Barcodes: string[];
    Product: { [key: string]: any };
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    QuantityOnHand: number;
    ForceComplete: boolean;
    MustBeOrdered: boolean;
    /**
     * Entity type: OrderLine
     */
    Requirements: { [key: number]: any };
  }

  /**
   * Print the Reservation receipt for the given Order
   */
  export interface PrintStockReservationReceipt {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Station
     */
    StationID?: number;
  }

  /**
   * Starts a user task of type Stock Reservation.
   * 
   * - The task will return all required data for display purposes
   * - When no lines are returned, the task is already completed or in progress by someone else
   * - To complete the StockReservation task, use the `CompleteStockReservationTask` service
   */
  export interface StartStockReservation2 {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Force a restart of the task, even when it's already started by a different user.
     * @default false
     */
    Force?: boolean;
  }

  export interface StartStockReservationResponse2 {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
    OrderDisplayID?: string;
    Lines: StartStockReservationLine[];
    ServiceLines: StartStockReservationLine[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface StartStockReservationLine {
    /**
     * Entity type: OrderLine
     */
    OrderLineID: number;
    Quantity: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    ProductCustomID?: string;
    ProductBackendID?: string;
    ProductDisplayValue: string;
    ProductUnitPrice: number;
    ProductPrimaryImage?: string;
    TotalAmount: number;
    ProductVariation?: { [key: string]: string };
    SerialNumber?: string;
    SerialNumberRequired: boolean;
    SerialNumberConfigurationID?: number;
    /**
     * Current stock of this product in the pickuporganizationunit
     */
    QuantityOnHand: number;
    /**
     * The child lines for this line
     */
    ChildLines: StartStockReservationLine[];
    /**
     * Entity type: OrderLine
     */
    ParentID?: number;
    GroupID?: string;
    /**
     * Entity type: ProductBundleLine
     */
    ProductBundleLineID?: number;
    /**
     * Entity type: OrderLine
     */
    Requirements: { [key: number]: any };
    /**
     * All possible stock products for this line. If this is not a stock aggregate product, this contains the same product.
     */
    StockProducts: StartStockReservationLineStockProduct[];
  }

  export interface StartStockReservationLineStockProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
  }

  export interface CompleteReservationCleanup {
    Task: CompleteReservationCleanup.ReservationCleanupTask;
    /**
     * Can be set to true so that lines missing from the workset are copied to a new cleanup task, so these can be done at a later point in time. This is
     * useful when the employee is handling a large order and wants to move a single batch first.
     */
    CreateNewTaskForRemainingLines?: boolean;
    /**
     * Should be set to true when the user did not confirm the order or user task (by means of a barcode scan or something). When set to true, the user will
     * be required to have (or be elevated for) the functionality `CompleteReservationCleanupWithoutConfirmation`.
     */
    NoConfirmation?: boolean;
  }

  export namespace CompleteReservationCleanup {
    export interface ReservationCleanupTask {
      /**
       * Entity type: UserTask
       */
      UserTaskID: number;
      /**
       * Every line on the cleanup task must be represented in this collection and each line must have an indication what needs
       * to happen to it in the context of the cleanup. The options are:
       * 
       * - The product was returned, in which case QuantityReturned must have a value.
       * - There was nothing there to return, in which case NothingToReturn must be set to true. A cyclecount will be generated for the product to make sure.
       * - The reservation must be extended, in which case ReservationExpirationOverride must have a value.
       */
      Lines: CompleteReservationCleanup.ReservationCleanupTaskLine[];
    }

    export interface ReservationCleanupTaskLine {
      QuantityToReturn: number;
      QuantityReturned: number;
      NothingToReturn?: boolean;
      ReservationExpirationOverride?: string;
      NothingToReturnAction?: CompleteReservationCleanup.NothingToReturnAction;
      OrderLine: CompleteReservationCleanup.ReservationCleanupTaskOrderLine;
    }

    export interface ReservationCleanupTaskOrderLine {
      /**
       * Entity type: OrderLine
       */
      ID?: number;
      SerialNumber?: string;
    }

    export const enum NothingToReturnAction {
      Cancel = 0,
      Complete = 1
    }

  }

  export interface StartReservationCleanup {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface StartReservationCleanupResponse {
    Task: ReservationCleanupWorkSet;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ReservationCleanupWorkSet {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: UserTask
     */
    ReservationCleanupTaskID: number;
    Type: ReservationCleanupTaskTypes;
    Order: OrderDto;
    Lines: ReservationCleanupWorkSetOrderLine[];
  }

  export const enum ReservationCleanupTaskTypes {
    Default = 0,
    ReturnToSupplier = 1
  }

  export interface ReservationCleanupWorkSetOrderLine {
    QuantityToReturn: number;
    QuantityReturned: number;
    NothingToReturn: boolean;
    ReservationExpirationOverride?: string;
    OrderLine: OrderLineDto;
    Type: ReservationCleanupTaskLineTypes;
  }

  export const enum ReservationCleanupTaskLineTypes {
    ExpiredReservation = 0,
    Cancellation = 1
  }

  /**
   * Completes a Stock Replenishment task, using the UserTaskIDs from the `WorkSet` returned by the `StartStockReplenishment` service.
   */
  export interface CompleteStockReplenishment {
    /**
     * Entity type: UserTask
     */
    UserTaskIDs: number[];
  }

  /**
   * Creates a new Stock Replenishment task.
   */
  export interface CreateStockReplenishmentTask {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    Quantity: number;
    Type?: StockReplenishmentType;
    Zone?: string;
  }

  export const enum StockReplenishmentType {
    Default = 0,
    Priority = 1,
    AutoGenerated = 2
  }

  /**
   * Creates new Stock Replenishment tasks in bulk, with `DetailedProducts` being an array of products details.
   */
  export interface CreateStockReplenishmentTasks {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    DetailedProducts: CreateStockReplenishmentProduct[];
  }

  export interface CreateStockReplenishmentProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
    Zone: string;
    Quantity: number;
    Type?: StockReplenishmentType;
  }

  /**
   * Get the additional Stock Replenishment task data.
   */
  export interface GetStockReplenishmentTaskData {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface GetStockReplenishmentTaskDataResponse {
    Disabled: boolean;
    AutoGenerateQuantity: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Get the configured zones for your current organization unit.
   */
  export interface GetStockReplenishmentTaskZones {
  }

  export interface GetStockReplenishmentTaskZonesResponse {
    Zones: string[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Lists the additional Stock Replenishment task data.
   */
  export interface ListStockReplenishmentTaskData {
    PageConfig?: PageConfig<ListStockReplenishmentTaskDataFilter>;
  }

  export interface ListStockReplenishmentTaskDataFilter {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    Disabled?: boolean;
  }

  export interface ListStockReplenishmentTaskDataResponse {
    Result?: PagedResult<StockReplenishmentTaskDataDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface StockReplenishmentTaskDataDto {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    Disabled: boolean;
    AutoGenerateQuantity: number;
  }

  /**
   * Starts one or more Stock Replenishment tasks, returning a workset. Pass this workset to the `CompleteStockReplenishment` service when all tasks are complete.
   */
  export interface StartStockReplenishment {
    /**
     * Entity type: UserTask
     */
    UserTaskIDs?: number[];
  }

  export interface StartStockReplenishmentResponse {
    WorkSet: StockReplenishmentWorkSet;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface StockReplenishmentWorkSet {
    Items: StockReplenishmentWorkSetItem[];
  }

  export interface StockReplenishmentWorkSetItem {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: StockReplenishmentTask
     */
    StockReplenishmentTaskID: number;
    Quantity: number;
    Type: StockReplenishmentType;
    Zone: string;
    Product: any;
    Originator: string;
    StockProducts: StockReplenishmentStockProduct[];
  }

  export interface StockReplenishmentStockProduct {
    /**
     * Entity type: Product
     */
    ID: number;
  }

  /**
   * Updates Stock Replenishment task data.
   */
  export interface UpdateStockReplenishmentTaskData {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    Disabled?: boolean;
    AutoGenerateQuantity?: number;
  }

  export interface StartSecondChanceProductRegistration {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
  }

  export interface StartSecondChanceProductRegistrationResponse {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    ProductName: string;
    Description: string;
    SerialNumber?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface CancelSecondChanceProductRegistration {
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
    /**
     * A reason, if any, why the tasks were disabled. Optional.
     */
    Reason?: string;
  }

  export interface CompleteSecondChanceProductRegistration {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    ProductName: string;
    Description: string;
    /**
     * A list of blob urls.
     */
    Images?: string[];
    Price: number;
    NotReturnable?: boolean;
    SerialNumber?: string;
    /**
     * Stock label for original product after stock movement. If unspecified, defaults to Damaged.
     * Entity type: StockLabel
     */
    StockLabelID?: number;
  }

  export interface CompleteSecondChanceProductRegistrationResponse {
    /**
     * Entity type: Product
     */
    ProductID: number;
    Barcode: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface StartReceiveShipment {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProductProperties?: string[];
  }

  export interface StartReceiveShipmentResponse {
    ReceiveMethod: ShipmentReceiveMethods;
    IsCompleted: boolean;
    WorkSet: ReceiveShipmentWorkSet;
    AllowSurplus: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface CanProcessInitialCycleCount {
    /**
     * Entity type: InitialCycleCountLabel
     */
    InitialCycleCountID: number;
  }

  export interface CanProcessInitialCycleCountResponse {
    CanProcess: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface CountProductForInitialCycleCount {
    /**
     * Entity type: InitialCycleCountLabel
     */
    LabelID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    Quantity: number;
  }

  export interface CreateInitialCycleCount {
  }

  export interface CreateInitialCycleCountResponse {
    Result: InitialCycleCountDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface InitialCycleCountDto {
    /**
     * Entity type: InitialCycleCount
     */
    ID: number;
    Status: InitialCycleCountStatus;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export const enum InitialCycleCountStatus {
    New = 0,
    DetailCount = 1,
    Processing = 2,
    Finished = 3
  }

  export interface DeleteInitialCycleCountResult {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: StockLabel
     */
    StockLabel: number;
    /**
     * Entity type: InitialCycleCountLabel
     */
    LabelID: number;
  }

  export interface GetCurrentInitialCycleCount {
  }

  export interface GetCurrentInitialCycleCountResponse {
    Result: InitialCycleCountDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface GetInitialCycleCountLabel {
    /**
     * Entity type: InitialCycleCountLabel
     */
    LabelID: number;
  }

  export interface GetInitialCycleCountLabelResponse {
    Label: InitialCycleCountLabelDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface InitialCycleCountLabelDto {
    /**
     * Entity type: InitialCycleCountLabel
     */
    ID: number;
    Number: number;
    Status: InitialCycleCountLabelStatus;
    /**
     * Entity type: StockLabel
     */
    StockLabel?: number;
    ItemPreCount?: number;
    ItemEndCount?: number;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    CreationTime: string;
    InitialCycleCount: InitialCycleCountDto;
    PreCountedByFullName: string;
    CountedByFullName: string;
  }

  export const enum InitialCycleCountLabelStatus {
    New = 0,
    PreCounted = 1,
    Counted = 2
  }

  export interface ListInitialCycleCountLabels {
    /**
     * Entity type: InitialCycleCount
     */
    InitialCycleCountID: number;
    Start: number;
    Limit: number;
  }

  export interface ListInitialCycleCountLabelsResponse {
    Result: InitialCycleCountLabelDto[];
    Total: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListInitialCycleCountResults {
    /**
     * Min: 0
     */
    Start: number;
    /**
     * Min: 1
     */
    Limit: number;
    ShowAll?: boolean;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    CustomItemNumber?: string;
    /**
     * Entity type: StockLabel
     */
    StockLabel?: number;
    /**
     * Entity type: InitialCycleCountLabel
     */
    LabelID?: number;
  }

  export interface ListInitialCycleCountResultsResponse {
    Results: StockWithInitialCycleCountResultDto[];
    Total: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface StockWithInitialCycleCountResultDto {
    ProductID: number;
    OrganizationUnitID: number;
    QuantityOnHand: number;
    StockLabelID: number;
    StockLabel: number;
    Quantity: number;
    BackendID: string;
    LabelID: string;
    LabelNumber: string;
    ShortDescription: string;
  }

  export interface MissingProductForInitialCycleCount {
    /**
     * Entity type: InitialCycleCountLabel
     */
    LabelID: number;
    Barcode?: string;
    Quantity: number;
    Photo?: string;
    PhotoMimeType?: string;
  }

  export interface PreCountInitialCycleCountLabel {
    /**
     * Entity type: InitialCycleCountLabel
     */
    LabelID: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID: number;
    Quantity: number;
  }

  export interface ProcessInitialCycleCountResults {
  }

  export interface ProduceInitialCycleCountLabels {
    /**
     * Range: 1-100
     */
    Count: number;
    /**
     * The ID of the station, which will be used to determine what printer to use to print the bar codes
     * Entity type: Station
     */
    StationID?: number;
    AsPDF?: boolean;
    /**
     * If this is set all the labels that've currently been created will be re-generated, but no new labels will be created in the process.
     */
    ReprintLabels?: boolean;
    Destination: MessageTemplateDestinations;
  }

  export interface ValidatePreCount {
    /**
     * Entity type: InitialCycleCountLabel
     */
    LabelID: number;
    ConfirmedQuantity?: number;
  }

  export interface ValidatePreCountResponse {
    Result: ValidatePreCountResults;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export const enum ValidatePreCountResults {
    Correct = 1,
    Deviation = 2,
    RedoDetailCount = 3
  }

  /**
   * Lists the products of specified full stock count label.
   */
  export interface ListFullStockCountLabelProducts {
    /**
     * Entity type: FullStockCountLabel
     */
    ID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProperties?: string[];
    PageConfig?: PageConfig<ListFullStockCountLabelProductsFilter>;
  }

  export interface ListFullStockCountLabelProductsFilter {
    /**
     * Entity type: Product
     */
    ProductID?: number;
  }

  export interface ListFullStockCountLabelProductsResponse {
    Result?: PagedResult<ListFullStockCountLabelProductDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListFullStockCountLabelProductDto {
    /**
     * Entity type: Product
     */
    ProductID: number;
    BackendID: string;
    /**
     * Entity type: User
     */
    CurrentCountUserID?: number;
    Quantity: number;
    PreviousQuantity?: number;
    /**
     * Entity type: User
     */
    PreviousCountUserID?: number;
    Properties: any;
    CreationTime: string;
    LastModificationTime?: string;
    IsSerialNumberRequired: boolean;
  }

  /**
   * Returns the information of a single label product. Most notably, this also includes serialnumber information.
   */
  export interface GetFullStockCountLabelProduct {
    /**
     * Entity type: FullStockCountLabel
     */
    ID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProperties?: string[];
    /**
     * Entity type: Product
     */
    ProductID: number;
  }

  export interface GetFullStockCountLabelProductResponse {
    /**
     * Entity type: User
     */
    CurrentCountUserID?: number;
    Quantity?: number;
    PreviousQuantity?: number;
    /**
     * Entity type: User
     */
    PreviousCountUserID?: number;
    Properties?: any;
    CreationTime?: string;
    LastModificationTime?: string;
    /**
     * All serialnumbers scanned as part of this product
     */
    SerialNumbers?: string[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Initiates a recount of the given FullStockCountProduct for the given FullStockCount. FullStockCount will not be completed.
   */
  export interface RecountFullStockCountProduct {
    /**
     * Entity type: FullStockCount
     */
    FullStockCountID: number;
    Recounts?: RecountFullStockCountProduct.Recount[];
  }

  export namespace RecountFullStockCountProduct {
    export interface Recount {
      /**
       * Entity type: StockLabel
       */
      StockLabelID: number;
      /**
       * Entity type: Product
       */
      ProductID: number;
    }

  }

  /**
   * Adds a product count result to specified Full Stock Count label. User task must be active and assigned to the current user.
   */
  export interface AddProductToFullStockCountLabel {
    /**
     * Entity type: FullStockCountLabel
     */
    ID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    Quantity?: number;
    /**
     * This will instead of overwriting, increment the quantity.
     */
    IncrementQuantity?: boolean;
    SerialNumber?: string;
  }

  export interface AddProductToFullStockCountLabelResponse {
    ID: number;
    Product: AddProductToFullStockCountLabelResponse.AddProductToFullStockCountLabelProductDto;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace AddProductToFullStockCountLabelResponse {
    export interface AddProductToFullStockCountLabelProductDto {
      /**
       * Entity type: Product
       */
      ProductID: number;
      BackendID: string;
      CurrentCountUserID?: number;
      Quantity: number;
      PreviousQuantity?: number;
      PreviousCountUserID?: number;
      Properties: any;
      CreationTime: string;
      LastModificationTime?: string;
      SerialNumbers?: string[];
      Barcodes: AddProductToFullStockCountLabelResponse.AddProductToFullStockCountLabelProductBarcodeDto[];
    }

    export interface AddProductToFullStockCountLabelProductBarcodeDto {
      Barcode: string;
    }

  }

  /**
   * Initiates a recount of the given FullStockCountLabel. FullStockCount will not be completed.
   */
  export interface RecountFullStockCountLabel {
    /**
     * Entity type: FullStockCountLabel
     */
    ID: number;
  }

  export interface RecountFullStockCountLabelResponse {
    ID: number;
    UserTaskID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Starts a Full Stock Count label task.
   */
  export interface StartFullStockCountLabel {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface StartFullStockCountLabelResponse {
    ID: number;
    UserTaskID: number;
    FullStockCountID: number;
    Name: string;
    StockLabelID: number;
    StockLabelName: string;
    IsRecount: boolean;
    PredefinedProducts: number[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Cancel a specific Full Stock Count label.
   */
  export interface CancelFullStockCountLabel {
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
    /**
     * Entity type: FullStockCountLabel
     */
    FullStockCountLabelID?: number;
  }

  /**
   * Completes a Full Stock Count label task. User task must be active and assigned to the current user.
   */
  export interface CompleteFullStockCountLabel {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: Product
     */
    Products?: { [key: number]: number };
  }

  /**
   * Lists the Full Stock Count labels.
   */
  export interface ListFullStockCountLabels {
    /**
     * Entity type: FullStockCount
     */
    ID: number;
    PageConfig?: PageConfig<ListFullStockCountLabelsFilter>;
  }

  export interface ListFullStockCountLabelsFilter {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    /**
     * When omitted, all FullStockCountLabels are returned.
     * When false, only uncompleted FullStockCountLabels are returned.
     * When true, only completed or cancelled FullStockCountLabels are returned.
     */
    Completed?: boolean;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
  }

  export interface ListFullStockCountLabelsResponse {
    Result?: PagedResult<ListFullStockCountLabelDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListFullStockCountLabelDto {
    /**
     * Entity type: FullStockCountLabel
     */
    ID: number;
    /**
     * Entity type: FullStockCount
     */
    FullStockCountID: number;
    Name: string;
    /**
     * Entity type: StockLabel
     */
    StockLabelID: number;
    StockLabelName: string;
    IsRecount: boolean;
    State: FullStockCountLabelState;
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    UserFullName: string;
  }

  export const enum FullStockCountLabelState {
    Waiting = 0,
    CountInProgress = 1,
    WaitingRecount = 2,
    RecountInProgress = 3,
    Cancelled = 8,
    Completed = 9
  }

  /**
   * Prints label(s) for specified Full Stock Count to specified station.
   */
  export interface PrintFullStockCountLabels {
    /**
     * Entity type: Station
     */
    StationID?: number;
    /**
     * Prints all labels for this count - required if FullStockCountLabelID is empty
     * Entity type: FullStockCount
     */
    FullStockCountID?: number;
    /**
     * Prints just this label - required if FullStockCountID is empty
     * Entity type: FullStockCountLabel
     */
    FullStockCountLabelID?: number;
  }

  /**
   * Initiate the Full Stock Count process for the current store. **Prevents basic store functionalities once started.**
   */
  export interface CreateFullStockCount {
    /**
     * Indicates if the full stock count is done by an external party.
     * When false, the full stock count will be created and all basic store functionalities will be blocked once started.
     * 
     * When true, the full stock count will be created with a snapshot from the current stock. To set the result of the external full stock count, the 'UploadExternalFullStockCount' can be called.
     * Basic store functionalities will remaining in working order. Deviations will be calculated based on stock mutations.
     * The UserTask will be started automatically.
     */
    IsExternal?: boolean;
    /**
     * When this value is set to true, EVA will allow for stockmutations to be done during the fullstockcount.
     * WARNING: setting this value to true will make the outcome of the fullstockcount unreliable, because quantities on the full stock count label products can be changed before or after a count has been done.
     */
    AllowStockMutationsDuringCount: boolean;
    /**
     * When supplied, it will automatically create a validation recount based on the given recount interval. Ignored when IsExternal is set to true.
     * Min: 1
     */
    RecountInterval?: number;
    /**
     * When supplied, it will automatically call `AddLabelToFullStockCount` for each Shelf defined in your replenishment configuration. Ignored when IsExternal is set to true.
     */
    CreateFullStockCountLabelsForShelves?: boolean;
    /**
     * When supplied, it will automatically call `AddLabelToFullStockCount` for each InitialLabel. Ignored when IsExternal or CreateFullStockCountLabelsForShelves is set to true.
     */
    InitialFullStockCountLabels?: CreateFullStockCount.InitialFullStockCountLabel[];
    /**
     * When set to true, the service will return the current stock information.
     */
    ReturnCurrentStock?: boolean;
  }

  export namespace CreateFullStockCount {
    export interface InitialFullStockCountLabel {
      /**
       * Entity type: StockLabel
       */
      StockLabelID: number;
      Name?: string;
    }

  }

  export interface CreateFullStockCountResponse {
    /**
     * Entity type: FullStockCount
     */
    ID: number;
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    CurrentStock: CreateFullStockCountResponse.ProductStock[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace CreateFullStockCountResponse {
    export interface ProductStock {
      /**
       * Entity type: StockLabel
       */
      StockLabelID: number;
      /**
       * Entity type: Product
       */
      ProductID: number;
      QuantityOnHand: number;
    }

  }

  /**
   * Adds a label to specified full stock count.
   */
  export interface AddLabelToFullStockCount {
    /**
     * Entity type: FullStockCount
     */
    FullStockCountID: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID: number;
    Name?: string;
  }

  export interface AddLabelToFullStockCountResponse {
    /**
     * Entity type: FullStockCountLabel
     */
    ID: number;
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface DownloadFullStockCountLabelUploadTemplate {
  }

  /**
   * Upload an excel with labels to the specified full stock count.
   * Caution! The Name column can only be max 50 chars. Names larger then that will be rejected.
   * Caution! This service will not change existing labels, but only add new ones. Duplicate detection is done on case insensitve Name in combination with StockLabel.
   */
  export interface UploadFullStockCountLabels {
    /**
     * Entity type: FullStockCount
     */
    FullStockCountID: number;
    Data: string;
  }

  export interface UploadFullStockCountLabelsResponse {
    Added: UploadFullStockCountLabelsResponse.AddedLabel[];
    Rejected: UploadFullStockCountLabelsResponse.RejectedLabel[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace UploadFullStockCountLabelsResponse {
    export interface AddedLabel {
      /**
       * Entity type: FullStockCountLabel
       */
      ID: number;
      Name: string;
      /**
       * Entity type: StockLabel
       */
      StockLabelID: number;
    }

    export interface RejectedLabel {
      Name: string;
      StockLabel: string;
      Reason: UploadFullStockCountLabelsResponse.RejectionReason;
    }

    export const enum RejectionReason {
      None = 0,
      NameToLong = 1,
      UknownStockLabel = 2,
      DuplicateInUpload = 3,
      AlreadyExists = 4
    }

  }

  /**
   * Lists the full stock counts.
   */
  export interface ListFullStockCounts {
    PageConfig?: PageConfig<ListFullStockCountsFilter>;
  }

  export interface ListFullStockCountsFilter {
    /**
     * Entity type: FullStockCount
     */
    FullStockCountID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * This filters full stock counts with specific states;
     * `New` returns full stock counts that have been created but not yet started
     * `Active` returns full stock counts which are currenty in count process.
     * `Completed` return full stock counts that are completed (but not cancelled)
     * `Cancelled` return full stock counts that are cancelled
     * 
     * If no states are added (aka; empty list) ALL full stock counts will be returned.
     * If multiple states are desired, you can add both states to the list. For example: to get all completed and cancelled full stock count, both the `Completed` and the `Cancelled` state can be added to the list.
     */
    State?: ListFullStockCountsFilter.FullStockCountFilterState[];
  }

  export namespace ListFullStockCountsFilter {
    export const enum FullStockCountFilterState {
      Open = 0,
      Active = 1,
      Completed = 2,
      Cancelled = 3
    }

  }

  export interface ListFullStockCountsResponse {
    Result?: PagedResult<ListFullStockCountDto>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListFullStockCountDto {
    /**
     * Entity type: FullStockCount
     */
    ID: number;
    IsExternal: boolean;
    AllowStockMutationsDuringCount: boolean;
    RecountInterval: number;
    Type: FullStockCountType;
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    UserFullName: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    IsActive: boolean;
    IsCompleted: boolean;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    CreatedByFullName: string;
    CreationTime: string;
  }

  export const enum FullStockCountType {
    Initial = 1,
    InProgress = 2
  }

  /**
   * Get a Full Stock count task with details.
   */
  export interface GetFullStockCount {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface GetFullStockCountResponse {
    /**
     * Entity type: FullStockCount
     */
    ID: number;
    IsExternal: boolean;
    AllowStockMutationsDuringCount: boolean;
    RecountInterval: number;
    CreatedByFullName: string;
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    UserFullName: string;
    CreationTime: string;
    CompletionTime?: string;
    Type: FullStockCountType;
    Progress: number;
    IsReady: boolean;
    IsActive: boolean;
    IsCompleted: boolean;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Starts a full stock count task. Requires it to be ready.
   */
  export interface StartFullStockCount {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
  }

  export interface StartFullStockCountResponse {
    /**
     * Entity type: FullStockCount
     */
    ID: number;
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    RecountInterval: number;
    Type: FullStockCountType;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * Cancel a full stock count, cancelling all related labels and their results.
   */
  export interface CancelFullStockCount {
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
    /**
     * A reason, if any, why the tasks were disabled. Optional.
     */
    Reason?: string;
  }

  /**
   * Completes a full stock count task. User task must be active and assigned to the current user.
   */
  export interface CompleteFullStockCount {
    /**
     * Entity type: UserTask
     */
    UserTaskID: number;
    /**
     * When set to true, deviations will NOT be processed as stock mutations.
     */
    DismissDeviationsAsStockMutations?: boolean;
    /**
     * Recount all products in the full stock count.
     */
    RecountAllProducts?: boolean;
    /**
     * Recount all products in the full stock count that have a deviation.
     */
    RecountAllDeviations?: boolean;
    /**
     * Products to recount after completion of given full stock count.
     * Entity type: Product
     */
    ProductsToRecount?: number[];
  }

  /**
   * Exports the summary of specified Full Stock Count to Excel.
   */
  export interface DownloadFullStockCountSummaryExcel {
    /**
     * Entity type: FullStockCount
     */
    ID: number;
    OnlyShowDeviations?: boolean;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProperties?: string[];
  }

  /**
   * Exports the summary of specified Full Stock Count to PDF.
   */
  export interface DownloadFullStockCountSummaryPDF {
    /**
     * Entity type: FullStockCount
     */
    ID: number;
    OnlyShowDeviations?: boolean;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProperties?: string[];
  }

  /**
   * Lists the result of specified Full Stock Count.
   */
  export interface ListFullStockCountResult {
    /**
     * Entity type: FullStockCount
     */
    ID?: number;
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProperties?: string[];
    PageConfig?: PageConfig<ListFullStockCountResultFilter>;
  }

  export interface ListFullStockCountResultFilter {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    OnlyShowDeviations?: boolean;
  }

  export interface ListFullStockCountResultResponse {
    FullStockCountStartTime?: string;
    FullStockCountCompletionTime?: string;
    Result?: PagedResult<FullStockCountResult>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface FullStockCountResult {
    /**
     * Entity type: FullStockCountLabel
     */
    FullStockCountLabelID: number;
    Name: string;
    /**
     * Entity type: StockLabel
     */
    StockLabelID: number;
    StockLabelName: string;
    /**
     * Entity type: User
     */
    UserID?: number;
    UserFullName: string;
    /**
     * Entity type: Product
     */
    ProductID: number;
    BackendID: string;
    Quantity: number;
    Properties: any;
    /**
     * Entity type: User
     */
    RecountUserID?: number;
    RecountUserFullName: string;
    RecountQuantity?: number;
  }

  /**
   * Lists the summary of specified Full Stock Count.
   */
  export interface ListFullStockCountSummary {
    /**
     * Entity type: FullStockCount
     */
    ID?: number;
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedProperties?: string[];
    PageConfig?: PageConfig<ListFullStockCountSummaryFilter>;
  }

  export interface ListFullStockCountSummaryFilter {
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    ProductFilters?: { [key: string]: FilterModel };
    OnlyShowDeviations?: boolean;
    OnlyShowWithStockMutations?: boolean;
  }

  export interface ListFullStockCountSummaryResponse {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    CurrencyID: string;
    CreationTime: string;
    /**
     * Entity type: User
     */
    CreatedBy: number;
    CreatedByFullName: string;
    CompletionTime?: string;
    ExternalCountCompletionTime?: string;
    FinalSummaryValues: boolean;
    TotalProducts: number;
    TotalCounted: number;
    TotalDeviations: number;
    IsExternal: boolean;
    AllowStockMutationsDuringCount: boolean;
    IsCompleted: boolean;
    Progress: number;
    TotalPositiveDeviationAmount: number;
    TotalNegativeDeviationAmount: number;
    Result?: PagedResult<FullStockCountSummaryRecord>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface FullStockCountSummaryRecord {
    /**
     * Entity type: FullStockCountProductSummary
     */
    ID: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID: number;
    StockLabelName: string;
    /**
     * Entity type: Product
     */
    ProductID: number;
    BackendID: string;
    CustomID: string;
    Properties: any;
    CountQuantity: number;
    StockMutationQuantity: number;
    CurrentQuantity: number;
    DeviationQuantity: number;
    DeviationAmount: number;
    AbsoluteDeviationQuantity: number;
    AbsoluteDeviationAmount: number;
    CycleCountCreated: boolean;
    CycleCountCountResult?: number;
    SerialNumberRequired: boolean;
    StockProducts?: FullStockCountSummaryRecord.StockProduct[];
  }

  export namespace FullStockCountSummaryRecord {
    export interface StockProduct {
      /**
       * Entity type: Product
       */
      ProductID: number;
      BackendID: string;
      CountQuantity: number;
      CurrentQuantity: number;
      DeviationQuantity: number;
    }

  }

  /**
   * Lists the summary of specified Full Stock Count.
   */
  export interface ListFullStockCountLabelSummary {
    /**
     * Entity type: FullStockCount
     */
    ID: number;
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
    PageConfig?: PageConfig<ListFullStockCountLabelSummaryFilter>;
  }

  export interface ListFullStockCountLabelSummaryFilter {
    /**
     * Entity type: FullStockCountLabel
     */
    FullStockCountLabelID?: number;
    FullStockCountLabelName?: string;
    /**
     * Will only return the labels that contain 1 of these products
     * Entity type: Product
     */
    ProductIDs?: number[];
    /**
     * Will only return the labels that have one of these states
     */
    States?: FullStockCountLabelState[];
    /**
     * Will not return empty labels (the ProductIDs filter does not have influence on this). Only labels that are really empty will be left out.
     */
    IgnoreEmptyLabels?: boolean;
  }

  export interface ListFullStockCountLabelSummaryResponse {
    /**
     * Entity type: FullStockCount
     */
    FullStockCountID: number;
    FullStockCountIsExternal: boolean;
    FullStockCountIsCompleted: boolean;
    AllowStockMutationsDuringCount: boolean;
    Result?: PagedResult<ListFullStockCountLabelSummaryResponse.Label>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListFullStockCountLabelSummaryResponse {
    export interface Label {
      /**
       * Entity type: FullStockCountLabel
       */
      FullStockLabelID: number;
      FullStockLabelName: string;
      State: FullStockCountLabelState;
      IsCompleted: boolean;
      CompletedBy?: ListFullStockCountLabelSummaryResponse.CompletionUser;
      Products: ListFullStockCountLabelSummaryResponse.Product[];
    }

    export interface CompletionUser {
      /**
       * Entity type: User
       */
      ID: number;
      Name: string;
    }

    export interface Product {
      /**
       * Entity type: Product
       */
      ProductID: number;
      BackendID: string;
      CustomID: string;
      Properties: any;
      CountQuantity: number;
      StockProducts?: ListFullStockCountLabelSummaryResponse.StockProduct[];
    }

    export interface StockProduct {
      /**
       * Entity type: Product
       */
      ProductID: number;
      BackendID: string;
      CountQuantity: number;
    }

  }

  /**
   * Retrieves the status of serial numbers for a specific product and stock label within a Full Stock Count.
   */
  export interface ListFullStockCountSerialNumbersStatus {
    /**
     * Entity type: FullStockCount
     */
    FullStockCountID: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    PageConfig?: PageConfig<ListFullStockCountSerialNumbersStatusFilter>;
  }

  export interface ListFullStockCountSerialNumbersStatusFilter {
    Statuses?: FullStockCountSerialNumberStatus[];
    SerialNumbers?: string[];
  }

  export const enum FullStockCountSerialNumberStatus {
    /**
     * Serial number was expected and counted.
     */
    ExpectedAndCounted = 0,
    /**
     * Serial number was expected but not counted.
     */
    ExpectedNotCounted = 1,
    /**
     * Serial number was expected but counted on a different stock label.
     */
    CountedOnDifferentStockLabel = 2,
    /**
     * Serial number was expected but counted on a different organization unit.
     */
    CountedOnDifferentOrganizationUnit = 3,
    /**
     * Serial number was expected but counted as a different product.
     */
    CountedAsDifferentProduct = 4,
    /**
     * Serial number was counted but not expected.
     */
    Unexpected = 5
  }

  export interface ListFullStockCountSerialNumbersStatusResponse {
    Result?: PagedResult<ListFullStockCountSerialNumbersStatusModel>;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export interface ListFullStockCountSerialNumbersStatusModel {
    /**
     * Entity type: StockLabel
     */
    ExpectedStockLabelID?: number;
    /**
     * Entity type: StockLabel
     */
    CountedStockLabelID?: number;
    SerialNumber?: string;
    Status?: FullStockCountSerialNumberStatus;
  }

  /**
   * Creates consolidated pick task
   */
  export interface CreateConsolidatedPickTask {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * @default OldestFirst
     */
    SelectionPriority?: PickTaskSelectionPriority;
    /**
     * The amount of Pick ShipFromStore tasks to be consumed by this operation. If not set, all the pending Pick ShipFromStore tasks will be consumed.
     */
    Limit?: number;
  }

  export const enum PickTaskSelectionPriority {
    /**
     * Oldest First
     */
    OldestFirst = 0,
    /**
     * Newest First
     */
    NewestFirst = 1
  }

  export interface CreateConsolidatedPickTaskResponse {
    /**
     * Entity type: UserTask
     */
    UserTaskID?: number;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  /**
   * List the available ConsolidatedPickTask tasks for the current user.
   */
  export interface ListConsolidatedPickTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
  }

  export interface ListConsolidatedPickTasksResponse {
    Results: ListConsolidatedPickTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListConsolidatedPickTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: ConsolidatedPickUserTaskData;
    }

  }

  export interface ConsolidatedPickUserTaskData {
    /**
     * Entity type: UserTask
     */
    ZonePickUserTaskIDs: number[];
  }

  /**
   * List the available ConsolidatedZonePickTask tasks for the current user.
   */
  export interface ListConsolidatedZonePickTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
  }

  export interface ListConsolidatedZonePickTasksResponse {
    Results: ListConsolidatedZonePickTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListConsolidatedZonePickTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: ConsolidatedZonePickUserTaskData;
    }

  }

  export interface ConsolidatedZonePickUserTaskData {
    /**
     * Entity type: ProductZone
     */
    ProductZoneID?: number;
  }

  /**
   * List the available FullStockCountLabel tasks for the current user.
   */
  export interface ListFullStockCountLabelTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
  }

  export interface ListFullStockCountLabelTasksResponse {
    Results: ListFullStockCountLabelTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListFullStockCountLabelTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: FullStockCountLabelUserTaskData;
    }

  }

  export interface FullStockCountLabelUserTaskData {
    ID: number;
    Name: string;
    StockLabelID: number;
    FullStockCountID: number;
    StockLabelName: string;
    IsRecount: boolean;
  }

  /**
   * List the available FullStockCount tasks for the current user.
   */
  export interface ListFullStockCountTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
  }

  export interface ListFullStockCountTasksResponse {
    HasActiveFullStockCount: boolean;
    AllowStockMutationsDuringCount: boolean;
    Results: ListFullStockCountTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListFullStockCountTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: FullStockCountUserTaskData;
    }

  }

  export interface FullStockCountUserTaskData {
    Progress: number;
    IsReady: boolean;
    IsExternal: boolean;
    AllowStockMutationsDuringCount: boolean;
  }

  /**
   * List the UserTasks for the current user.
   */
  export interface ListMyUserTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    InitialPageConfig?: EVA.Core.PageTokenConfig<{ [key:string]: string }>;
    PageToken?: string;
  }

  export interface ListMyUserTasksResponse {
    Results?: ListMyUserTasksResponse.TaskResult[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListMyUserTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Type: UserTaskTypeDto;
      SubType: EnumDto;
    }

  }

  /**
   * List the available Operational tasks for the current user.
   */
  export interface ListOperationalTasks {
    InitialPageConfig?: PageTokenConfig<ListOperationalTasksFilter>;
    PageToken?: string;
  }

  export interface ListOperationalTasksFilter {
    SurveyName?: string;
    /**
     * Entity type: User
     */
    UserID?: number;
  }

  export interface ListOperationalTasksResponse {
    Results?: ListOperationalTasksResponse.TaskResult[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListOperationalTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Title: string;
      UserID?: number;
      UserFullName?: string;
      Deadline?: string;
      /**
       * Entity type: Survey
       */
      SurveyID?: number;
      SchedulingConfigDescription: string;
    }

  }

  /**
   * List the available PrintPriceLabel tasks for the current user.
   */
  export interface ListPrintPriceLabelTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
  }

  export interface ListPrintPriceLabelTasksResponse {
    Results: ListPrintPriceLabelTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListPrintPriceLabelTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: PrintPriceLabelUserTaskData;
    }

  }

  export interface PrintPriceLabelUserTaskData {
    Products: PrintPriceLabelUserTaskDataProduct[];
  }

  export interface PrintPriceLabelUserTaskDataProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
    Quantity: number;
  }

  /**
   * List the available Print tasks for the current user.
   */
  export interface ListPrintTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
    Filters?: ListPrintTasks.FilterObj;
  }

  export namespace ListPrintTasks {
    export interface FilterObj {
      TypeID?: PrintTaskType;
    }

  }

  export interface ListPrintTasksResponse {
    Results: ListPrintTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListPrintTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: PrintUserTaskData;
    }

  }

  export interface PrintUserTaskData {
    TypeID: PrintTaskType;
  }

  /**
   * List the available ReceiveShipment tasks for the current user.
   */
  export interface ListReceiveShipmentTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
  }

  export interface ListReceiveShipmentTasksResponse {
    Results: ListReceiveShipmentTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListReceiveShipmentTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: ReceiveShipmentUserTaskData;
    }

  }

  export interface ReceiveShipmentUserTaskData {
    /**
     * Entity type: Shipment
     */
    ShipmentID: number;
    ShipmentIdentifiers: ReceiveShipmentUserTaskData.ShipmentIdentifier[];
    TotalQuantityShipped: number;
    NetTotalQuantityShipped: number;
    TrackingCode?: string;
    OriginalDeliveryDate?: string;
    ExpectedDeliveryDate?: string;
    OrderCustomTypeID?: number;
    OrderCustomType?: string;
  }

  export namespace ReceiveShipmentUserTaskData {
    export interface ShipmentIdentifier {
      Name: string;
      Value: string;
      Type: ShipmentIdentifierTypes;
    }

  }

  /**
   * List the available Repair tasks for the current user.
   */
  export interface ListRepairTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
    /**
     * Return only Hidden/Visible UserTasks
     * @default false
     */
    IsHidden?: boolean;
    /**
     * Return only UserTasks with one of the specified subtypes
     */
    UserTaskSubTypes?: string[];
    /**
     * Filter for a specific UserTaskType.Name using a property name and a list of values.
     */
    Filters?: { [key: string]: { [key: string]: any[] } };
  }

  export interface ListRepairTasksResponse {
    Results: ListRepairTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListRepairTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      SubType: EnumDto;
      Data: RepairUserTaskData;
    }

  }

  export interface RepairUserTaskData {
    ProductID?: number;
    ProductName: string;
    /**
     * Entity type: Repair
     */
    RepairID: number;
    ProductImage: string;
    OrderID: number;
    SerialNumber?: string;
  }

  /**
   * List the available ReservationCleanup tasks for the current user.
   */
  export interface ListReservationCleanupTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
  }

  export interface ListReservationCleanupTasksResponse {
    Results: ListReservationCleanupTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListReservationCleanupTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: ReservationCleanupUserTaskData;
    }

  }

  export interface ReservationCleanupUserTaskData {
    OrderID: number;
    Type: ReservationCleanupTaskTypes;
    productIDs: number[];
  }

  /**
   * List the available ReservationDeviation tasks for the current user.
   */
  export interface ListReservationDeviationTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
  }

  export interface ListReservationDeviationTasksResponse {
    Results: ListReservationDeviationTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListReservationDeviationTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: ReservationDeviationUserTaskData;
    }

  }

  export interface ReservationDeviationUserTaskData {
    ProductID: number;
  }

  /**
   * List the available ReservationPickup tasks for the current user.
   */
  export interface ListReservationPickupTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
  }

  export interface ListReservationPickupTasksResponse {
    Results: ListReservationPickupTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListReservationPickupTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: ReservationPickupUserTaskData;
    }

  }

  export interface ReservationPickupUserTaskData {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  /**
   * List the available ReturnToSupplier tasks for the current user.
   */
  export interface ListReturnToSupplierTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
    /**
     * Return only UserTasks with one of the specified subtypes
     */
    UserTaskSubTypes?: string[];
  }

  export interface ListReturnToSupplierTasksResponse {
    Results: ListReturnToSupplierTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListReturnToSupplierTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      SubType: EnumDto;
      Data: ReturnToSupplierUserTaskData;
    }

  }

  export interface ReturnToSupplierUserTaskData {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    Count?: number;
    Quantity?: number;
    TrackingCode: string;
    UseExcludePolicyOnReturnToSupplierShipment: boolean;
    HasMarkedProducts: boolean;
    ProductMarkerValue: string;
    OrderDisplayID?: string;
  }

  /**
   * List the available SecondChanceProductRegistration tasks for the current user.
   */
  export interface ListSecondChanceProductRegistrationTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
  }

  export interface ListSecondChanceProductRegistrationTasksResponse {
    Results: ListSecondChanceProductRegistrationTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListSecondChanceProductRegistrationTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: SecondChanceProductRegistrationUserTaskData;
    }

  }

  export interface SecondChanceProductRegistrationUserTaskData {
    ProductID?: number;
    SerialNumber?: string;
  }

  /**
   * List the available ShipFromStore tasks for the current user.
   */
  export interface ListShipFromStoreTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only UserTasks with one of the specified labels
     */
    Labels?: string[];
  }

  export interface ListShipFromStoreTasksResponse {
    Results: ListShipFromStoreTasksResponse.TaskResult[];
    Labels: { [key: string]: number };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListShipFromStoreTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      Labels: string[];
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      SubType: EnumDto;
      Data: ShipFromStoreUserTaskData;
    }

  }

  export interface ShipFromStoreUserTaskData {
    Count?: number;
    Quantity?: number;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    OrderDisplayID?: string;
    TravelDistanceText: string;
    TravelDistanceInMeters?: number;
    TravelTimeText: string;
    HasMarkedProducts: boolean;
    ProductMarkerValue: string;
    TravelTimeInSeconds?: number;
    /**
     * Entity type: Shipment
     */
    ShipmentID?: number;
    /**
     * Entity type: ShippingMethod
     */
    ShippingMethodID?: number;
    /**
     * Entity type: Product
     */
    productIDs: number[];
    IsPrePicked: boolean;
  }

  /**
   * List the available StockMovementFollowUp tasks for the current user.
   */
  export interface ListStockMovementFollowUpTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
  }

  export interface ListStockMovementFollowUpTasksResponse {
    Results: ListStockMovementFollowUpTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListStockMovementFollowUpTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: StockMovementFollowUpUserTaskData;
    }

  }

  export interface StockMovementFollowUpUserTaskData {
    ProductID?: number;
    SerialNumber?: string;
  }

  /**
   * List the available StockReplenishment tasks for the current user.
   */
  export interface ListStockReplenishmentTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
    /**
     * Filter for a specific UserTaskType.Name using a property name and a list of values.
     */
    Filters?: { [key: string]: { [key: string]: any[] } };
  }

  export interface ListStockReplenishmentTasksResponse {
    Results: ListStockReplenishmentTasksResponse.TaskResult[];
    Aggregations: { [key: string]: UserTaskDataAggregation[] };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListStockReplenishmentTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      Labels: string[];
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: StockReplenishmentUserTaskData;
    }

  }

  export interface StockReplenishmentUserTaskData {
    Quantity: number;
    Type: StockReplenishmentType;
    Zone: string;
    ExpireDate?: string;
    Product?: any;
    Originator: string;
  }

  /**
   * List the available StockReservation tasks for the current user.
   */
  export interface ListStockReservationTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
  }

  export interface ListStockReservationTasksResponse {
    Results: ListStockReservationTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListStockReservationTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: StockReservationUserTaskData;
    }

  }

  export interface StockReservationUserTaskData {
    Count?: number;
    Quantity?: number;
    /**
     * Entity type: Order
     */
    OrderID: number;
    HasMarkedProducts: boolean;
    ProductMarkerValue: string;
    OrderDisplayID: string;
  }

  /**
   * List the UserTasks for the current user.
   */
  export interface ListUrgentTasks {
    InitialPageConfig?: EVA.Core.PageTokenConfig<{ [key:string]: string }>;
    PageToken?: string;
  }

  export interface ListUrgentTasksResponse {
    Results?: ListUrgentTasksResponse.TaskResult[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListUrgentTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Type: UserTaskTypeDto;
      SubType: EnumDto;
    }

  }

  /**
   * List the available ZonedCycleCountPreCount tasks for the current user.
   */
  export interface ListZonedCycleCountPreCountTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
    /**
     * Filter for a specific UserTaskType.Name using a property name and a list of values.
     */
    Filters?: { [key: string]: { [key: string]: any[] } };
  }

  export interface ListZonedCycleCountPreCountTasksResponse {
    Results: ListZonedCycleCountPreCountTasksResponse.TaskResult[];
    Aggregations: { [key: string]: UserTaskDataAggregation[] };
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListZonedCycleCountPreCountTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: ZonedCycleCountPreCountUserTaskData;
    }

  }

  export interface ZonedCycleCountPreCountUserTaskData {
    CycleCountZoneID: number;
    CycleCountZoneName: string;
    ProductID: number;
    OriginTypeID?: number;
    OriginID?: number;
    ProductDisplayValue: string;
    ProductImageBlob: string;
  }

  /**
   * List the available ZonedCycleCount tasks for the current user.
   */
  export interface ListZonedCycleCountTasks {
    /**
     * Return only UserTasks attached to this UserID
     * Entity type: User
     */
    UserID?: number;
    /**
     * Return only Started/Open UserTasks
     */
    IsStarted?: boolean;
  }

  export interface ListZonedCycleCountTasksResponse {
    Results: ListZonedCycleCountTasksResponse.TaskResult[];
    Error?: ServiceError;
    Metadata?: ResponseMessageMetadata;
  }

  export namespace ListZonedCycleCountTasksResponse {
    export interface TaskResult {
      /**
       * Entity type: UserTask
       */
      ID: number;
      Description: string;
      Priority: number;
      DefaultPriority: number;
      PriorityDescription: string;
      IsUrgent: boolean;
      CanBeIgnored: boolean;
      CreationTime: string;
      StartTime?: string;
      ExpectedTimeToComplete?: string;
      ExpectedCompletionTime?: string;
      Deadline?: string;
      User: UserDto;
      Data: ZonedCycleCountUserTaskData;
    }

  }

  export interface ZonedCycleCountUserTaskData {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: ZonedCycleCount
     */
    ZonedCycleCountID?: number;
    Progress: number;
    DisplayValue: string;
    /**
     * Entity type: CycleCountOriginType
     */
    OriginTypeID?: number;
    OriginID?: number;
    Origin: string;
  }

  export interface UserCardTypeDto {
    AmountType: UserCardAmountTypes;
    /**
     * Entity type: Enum
     */
    ID: number;
    /**
     * Usually an internal & unchangable code - for display, use `Description`
     */
    Name: string;
    Description: string;
  }

  export const enum UserCardAmountTypes {
    Currency = 0,
    Points = 1
  }

  export interface ListUserCardsFilter {
    Barcode?: string;
    /**
     * Entity type: UserCardType
     */
    TypeID?: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    User?: string;
  }

  export interface UserCardDto {
    /**
     * Entity type: UserCard
     */
    ID: number;
    /**
     * Entity type: User
     */
    UserID: number;
    TypeID: number;
    Barcode: string;
    IsActive: boolean;
    CurrencyID: string;
    Description: string;
    /**
     * Entity type: Discount
     * @deprecated Use Discount instead.
     */
    DiscountID?: number;
    Discount?: UserCardDto.DiscountDto;
    /**
     * Entity type: LoyaltyProgram
     */
    LoyaltyProgramID?: number;
    User: UserDto;
    CurrentBalance: UserCardBalance;
    Type: UserCardTypeDto;
  }

  export namespace UserCardDto {
    export interface DiscountDto {
      /**
       * Entity type: Discount
       */
      ID: number;
      Description: string;
      MarketingDescription: string;
      PromotionLabel: string;
    }

  }

  export interface UserCardBalance {
    CardBalance: number;
    CurrencyBalance: number;
    CurrencyID: string;
  }

  export const enum UserCardMutationStatuses {
    Pending = 0,
    Completed = 1,
    Cancelled = 2
  }

  export const enum OpenCashDrawerResults {
    Failure = 0,
    Opened = 1,
    AlreadyOpen = 2,
    OpenedAndClosed = 3
  }

  export interface ListByProximityFilter {
    Type?: OrganizationUnitTypes;
    /**
     * Range: -90-90
     */
    Latitude: number;
    /**
     * Range: -180-180
     */
    Longitude: number;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    IDs?: number[];
  }

  export const enum PointPolicyType {
    None = 0,
    Pending = 1,
    Expiration = 2
  }

}declare module EVA.DataLake {

  export namespace Errors {
    export const enum DataLakeBackfill {
      /**
       * DataLake export is disabled.
       */
      DataLakeExportDisabled = 'DataLakeBackfill:DataLakeExportDisabled',
      /**
       * Provide either an id, a list of ids or a from/to range.
       */
      BatchInformationRequired = 'DataLakeBackfill:BatchInformationRequired',
      /**
       * Failed to start DataLake backfill process.
       */
      DataLakeBackfillProcessingFailed = 'DataLakeBackfill:DataLakeBackfillProcessingFailed',
      /**
       * You requested {requested:number} documents, but your max was set to {limit:number}.
       */
      RequestedQuantityExceedsLimit = 'DataLakeBackfill:RequestedQuantityExceedsLimit',
      /**
       * UserBatches backfill only allows from/to range.
       */
      UserBatchesBackfillOnlyAllowsFromTo = 'DataLakeBackfill:UserBatchesBackfillOnlyAllowsFromTo',
      /**
       * Backfill of type '{0:DataLakeBackfillType}' only accepts IDs.
       */
      BackfillTypeOnlyAcceptsIDs = 'DataLakeBackfill:BackfillTypeOnlyAcceptsIDs'
    }

  }


  /**
   * Returns a list of all available Data Lake models.
   */
  export interface GetAvailableDataLakeModels {
  }

  export interface GetAvailableDataLakeModelsResponse {
    Models: GetAvailableDataLakeModelsResponse.Model[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAvailableDataLakeModelsResponse {
    export interface Model {
      Name: string;
      IsIgnored: boolean;
    }

  }

  /**
   * Define which DataLake models should be ignored when exporting to the configured DataLake.
   */
  export interface UpdateDataLakeConfiguration {
    IgnoredModels?: string[];
  }

  /**
   * Manually re-export specific DataLake documents.
   * 
   * These types are currently supported;
   * 
   * * `FinancialPeriods` = 1
   * * `Orders` = 2
   * * `Invoices` = 3
   * * `Users` = 4
   * * `Discounts` = 5
   * * `UserBatches` = 6 (can only be used with `From` and `To`)
   * * `Cases` = 7
   * * `Shipments` = 8
   * * `ZonedCycleCounts` = 9
   * * `UserTasks` = 10
   * * `StockMutations` = 11
   * * `UserLoyaltyPointMutations` = 12 (can only be used with the `ID` or `IDs`. These need to be the user ID's of which the loyalty point mutation will be exported.)
   * * `LoyaltyProgramGroups` = 13 (can only be used with the `ID` or `IDs`.)
   * * `LoyaltyPrograms` = 14 (can only be used with the `ID` or `IDs`.)
   * * `FullStockCounts` = 15 (can only be used with the `ID` or `IDs`.)
   * * `StockNotifications` = 16 (can only be used with the `ID` or `IDs`.)
   * * `ProductSubscriptions` = 17 (can only be used with `From` and `To`)
   * 
   * Specify either a single `ID`, a list of `IDs`, or a datetime range `From` and `To` (inclusive).
   * 
   * For the following types, you can optionally specify an `OrganizationUnitID` to filter results within a datetime range:
   * `FinancialPeriods`, `Orders`, `Invoices`, `Discounts`, `Cases`, `Shipments`, `ZonedCycleCounts`, `UserTasks`, `StockMutations`, `StockNotifications`.
   * 
   * For the following types: `Discounts`, the `OrganizationUnitID` must be a setID
   * 
   * As mandatory safety feature, specify the `MaxNumberOfDocuments` you'd like to run this for. When the amount of documents through above
   * selection exceeds this number, this service will export NOTHING and return to you an error with the amount of documents it prevented you
   * from exporting, so you can adjust your selection or expand your max.
   * 
   * :warning: Triggering large amounts of data may impact system performance!
   * 
   * :point_right: The `ID` you are returned can be used in subsequent services `DataLakeBackfillStatus` and `DataLakeBackfillCancel`.
   */
  export interface DataLakeBackfill {
    Type: DataLakeBackfillType;
    MaxNumberOfDocuments: number;
    /**
     * Entity type: DataModel
     */
    ID?: number;
    /**
     * Entity type: DataModel
     */
    IDs?: number[];
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    From?: string;
    To?: string;
  }

  export const enum DataLakeBackfillType {
    FinancialPeriods = 1,
    Orders = 2,
    Invoices = 3,
    Users = 4,
    Discounts = 5,
    UserBatches = 6,
    Cases = 7,
    Shipments = 8,
    ZonedCycleCounts = 9,
    UserTasks = 10,
    StockMutations = 11,
    UserLoyaltyPointMutations = 12,
    LoyaltyProgramGroups = 13,
    LoyaltyPrograms = 14,
    FullStockCounts = 15,
    StockNotifications = 16,
    ProductSubscriptions = 17
  }

  export interface DataLakeBackfillResponse {
    ID: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Retrieve the status from a previous `DataLakeBackfill` request.
   */
  export interface DataLakeBackfillStatus {
    ID: string;
  }

  export interface DataLakeBackfillStatusResponse {
    Total?: number;
    Done?: number;
    Progress?: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Cancel a previous `DataLakeBackfill` request.
   */
  export interface DataLakeBackfillCancel {
    ID: string;
  }

  /**
   * Preview a datalake export. Use this service sparingly. Not all models can be previewed. This is only for testing purposes. Only a single ID can be specified at a time
   */
  export interface DataLakePreview {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: FinancialPeriod
     */
    FinancialPeriodID?: number;
    /**
     * Entity type: StockMutation
     */
    StockMutationID?: number;
    /**
     * Entity type: Survey
     */
    SurveyID?: number;
  }

  export interface DataLakePreviewResponse {
    Order?: DataLakeOrder;
    User?: DataLakeUser;
    FinancialPeriod?: DataLakeFinancialPeriod;
    StockMutation?: DataLakeStockMutation;
    Survey?: DataLakeSurvey;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface DataLakeOrder {
    DataLakeType: string;
    GenerationTime: string;
    ID: string;
    UserAgent: string;
    BackendID: string;
    BackendSystemID: string;
    Properties: number;
    OrderProperties: string[];
    Description: string;
    Type: string;
    GroupID?: string;
    CreationTime: string;
    LastModificationTime?: string;
    CaptureDate?: string;
    CreatedByID: string;
    Remark: string;
    CurrencyID: string;
    IsCompleted: boolean;
    IsPaid: boolean;
    IsShipped: boolean;
    IsTaxExempt: boolean;
    HasProductSubscriptions: boolean;
    HasReturns: boolean;
    PaymentDate?: string;
    ShipmentDate?: string;
    CompletionDate?: string;
    InvoiceDate?: string;
    PlacementDate?: string;
    BillingAddress: DataLakeAddress;
    ShippingAddress: DataLakeAddress;
    Customer: DataLakeSimpleUser;
    Lines: DataLakeOrderLine[];
    Payments: DataLakePayment[];
    TotalAmountIncludingTaxes: number;
    TotalAmountInvoiced: number;
    TotalItems: number;
    TotalLineCount: number;
    OriginatingOrganizationUnit: DataLakeSimpleOrganizationUnit;
    SoldToOrganizationUnit: DataLakeSimpleOrganizationUnit;
    SoldFromOrganizationUnit: DataLakeSimpleOrganizationUnit;
    ShipToOrganizationUnit: DataLakeSimpleOrganizationUnit;
    ShipFromOrganizationUnit: DataLakeSimpleOrganizationUnit;
    PickupOrganizationUnit: DataLakeSimpleOrganizationUnit;
    CustomStatus: string[];
    OrderLedgers: DataLakeOrderLedger[];
    CustomFields: DataLakeSimpleCustomField[];
    GiftWrapping: DataLakeGiftWrappingOptions;
    Amounts: EVA.Core.OpenOrderAmounts;
    OrderCustomStatus: DataLakeEnum.WithBackendID;
    OrderCustomType: DataLakeEnum.WithBackendID;
    LoyaltyProgramID: string;
    FiscalID: string;
    VatNumber: string;
    Status: string;
    BoardingPass?: DataLakeOrderFlightData;
  }

  export interface DataLakeAddress {
    FirstName: string;
    LastName: string;
    AddressedTo: string;
    HouseNumber: string;
    Address1: string;
    Address2: string;
    ZipCode: string;
    Subdistrict: string;
    District: string;
    City: string;
    State: string;
    Region: string;
    CountryID: string;
    CountrySubdivisionID: string;
    Street: string;
  }

  export interface DataLakeSimpleUser {
    ID: string;
    BackendID: string;
    BackendSystemID: string;
    Nickname: string;
    EmailAddress: string;
    FirstName: string;
    LastName: string;
    FullName: string;
    Gender: string;
    DateOfBirth?: string;
    PlaceOfBirth: string;
    PhoneNumber: string;
    LanguageID: string;
    CountryID: string;
    Salutation: string;
    FiscalID: string;
    CustomFields: DataLakeSimpleCustomField[];
  }

  export interface DataLakeSimpleCustomField {
    CustomFieldID?: number;
    Name?: string;
    BackendID?: string;
    Value?: any;
  }

  export interface DataLakeOrderLine {
    ID: string;
    ParentID: string;
    ReturnedOrderID: string;
    ReturnedOrderLineID: string;
    Description: string;
    IsExported: boolean;
    CreationTime: string;
    LastModificationTime?: string;
    CreatedByID: string;
    UnitPrice: number;
    UnitPriceInTax: number;
    UnitPricePriceListID: string;
    UnitPriceBeforeCorrection?: number;
    UnitPriceBeforeCorrectionInTax?: number;
    UnitPriceCorrectionReason?: DataLakeEnum;
    OriginalUnitPrice?: number;
    OriginalUnitPriceInTax?: number;
    UnitCost?: number;
    OriginalAmountInTax?: number;
    TaxRate: number;
    CurrencyID: string;
    CostPriceCurrencyID: string;
    QuantityOrdered: number;
    QuantityCancelled: number;
    QuantityShipped: number;
    QuantityCommitted: number;
    QuantityExported: number;
    QuantityDelivered: number;
    QuantityReserved: number;
    QuantityInvoiced: number;
    TotalQuantityToShip: number;
    IsShipped: boolean;
    IsInvoiced: boolean;
    IsCancelled: boolean;
    IsCompleted: boolean;
    Type: string;
    Discounts: DataLakeDiscountDetail[];
    DiscountCouponID?: string;
    DiscountCouponCode?: string;
    Product: DataLakeProduct;
    SoldBy: DataLakeSimpleUser;
    SerialNumber?: string;
    IsCarryOut: boolean;
    IsDelivery: boolean;
    /**
     * Don't use this, rely on `IsCarryOut` and `IsDelivery` instead
     */
    IsReservation: boolean;
    /**
     * Don't use this, rely on `IsCarryOut` and `IsDelivery` instead
     */
    IsOrdered: boolean;
    RequestedDate?: string;
    AvailabilityStatus: string;
    ExpectedAvailabilityDate?: string;
    PreSaleDate?: string;
    Remark: string;
    DiscountAmount: number;
    ShippingMethod: string;
    Reference: string;
    CustomOrderLineType: string;
    FulfillmentOrganizationUnitID: string;
    DiscountID: string;
    TaxCodeID: string;
    CustomFields: DataLakeSimpleCustomField[];
    ProductVariationLines?: DataLakeProductVariationLine[];
    ProductRequirements?: DataLakeProductRequirementValue[];
    Amounts: DataLakeOrderLineAmounts;
    ReturnReason: DataLakeReturnReason;
    TaxDetails?: DataLakeTaxDetails[];
  }

  export interface DataLakeEnum {
    ID: string;
    Name: string;
    Description: string;
  }

  export namespace DataLakeEnum {
    export interface WithBackendID {
      BackendID: string;
      ID: string;
      Name: string;
      Description: string;
    }

  }

  export interface DataLakeDiscountDetail {
    DiscountID: string;
    DiscountBackendID: string;
    DiscountOrderLineID: string;
    Amount: number;
    CompliancyRule: string;
  }

  export interface DataLakeProduct {
    ID: string;
    Name: string;
    BackendID: string;
    LedgerClassID: string;
    BackendSystemID: string;
    ManufacturerID: string;
  }

  export interface DataLakeProductVariationLine {
    ID: string;
    Label: string;
    Value: string;
  }

  export interface DataLakeProductRequirementValue {
    ID: string;
    Name: string;
    Value: any;
  }

  export interface DataLakeOrderLineAmounts {
    TotalAmountInTax: number;
    TotalTaxAmount: number;
    TotalAmount: number;
    NetTotalAmountInTax: number;
    NetTotalTaxAmount: number;
    NetTotalAmount: number;
    DiscountAmount: number;
  }

  export interface DataLakeReturnReason {
    ID: string;
    Name: string;
    BackendID: string;
  }

  export interface DataLakeTaxDetails {
    Name: string;
    Type: string;
    Rate: number;
    Amount: number;
  }

  export interface DataLakePayment {
    ID: string;
    BackendID: string;
    BackendSystemID: string;
    IsConfirmed: boolean;
    IsRefund: boolean;
    Code: string;
    Description: string;
    Amount: number;
    PaidAmount: number;
    CurrencyID: string;
    PaymentDate?: string;
    PaymentMethod: string;
    BackendRelationID: string;
    DeviceID?: string;
    CardID?: string;
    CardNumber?: string;
    CustomFields: DataLakeSimpleCustomField[];
  }

  export interface DataLakeSimpleOrganizationUnit {
    ID: string;
    Name: string;
    BackendID: string;
  }

  export interface DataLakeOrderLedger {
    ID: number;
    Type: string;
    Description: string;
    OldValue: string;
    OrderLineID: string;
    NewValue: string;
    CreationTime: string;
    CreatedBy: DataLakeSimpleUser;
  }

  export interface DataLakeGiftWrappingOptions {
    WrapOrder: boolean;
    WrapIndividually: boolean;
    Message: string;
    GreetingCardProductID: string;
    Wraps: DataLakeGiftWrappingOptionsWrap[];
  }

  export interface DataLakeGiftWrappingOptionsWrap {
    Lines: DataLakeGiftWrappingOptionsWrapLine[];
    GreetingCardProductID: string;
    Message: string;
  }

  export interface DataLakeGiftWrappingOptionsWrapLine {
    OrderLineID: string;
    Quantity: number;
  }

  export interface DataLakeOrderFlightData {
    Success: boolean;
    Format: string;
    NumberOfLegs: number;
    Name: string;
    Type: string;
    OperatingCarrierPNRCode: string;
    DepartingAirportCode: string;
    DestinationAirportCode: string;
    AirlineCompanyCode: string;
    FlightNumber: number;
    JulianDate: number;
    Cabin: string;
    Seat: string;
    CheckinSequence: number;
    Status: number;
    DataLength: string;
    Data: string;
    Flight?: DataLakeFlight;
  }

  export interface DataLakeFlight {
    ID: string;
    OrganizationUnitID: string;
    AirlineCompanyCode: string;
    FlightNumber: string;
    DestinationCode: number;
    DestinationAirportCode: string;
    FromDate: string;
    ToDate: string;
  }

  export interface DataLakeUser {
    DataLakeType: string;
    ID: string;
    GenerationTime: string;
    CreationTime: string;
    LastModificationTime: string;
    CustomFields: DataLakeSimpleCustomField[];
    EmailAddress: string;
    BackendRelationID: string;
    Initials: string;
    FirstName: string;
    LastName: string;
    DateOfBirth?: string;
    Gender: string;
    PlaceOfBirth: string;
    LanguageID: string;
    CountryID: string;
    TypeID: number;
    Types: string[];
    ShippingAddress: DataLakeAddress;
    BillingAddress: DataLakeAddress;
    DeactivationDate?: string;
    LastSuccessfulLogin?: string;
    Nickname: string;
    CompanyID: string;
    FiscalID: string;
    BankAccount: string;
    PhoneNumber: string;
    TimeZone: string;
    BackendSystemID: string;
    BackendID: string;
    UserAgent: string;
    GlobalID: string;
    Title: string;
    Salutation: string;
    PreferredStoreID: string;
    OriginatingOrganizationUnitID: string;
    CustomID: string;
    PricingGroupID: string;
    UserSubscriptions: DataLakeUserSubscription[];
  }

  export interface DataLakeUserSubscription {
    SubscriptionID?: string;
    Status?: string;
    IsBlocked?: boolean;
    UserAgent?: string;
    SubscribeFromSourceOrganizationUnit?: DataLakeSimpleOrganizationUnit;
    SubscribeFromSourceUserAgent?: string;
    SubscribeFromSourceIdentifier?: string;
    UnsubscribeFromSourceOrganizationUnit?: DataLakeSimpleOrganizationUnit;
    UnsubscribeFromSourceUserAgent?: string;
    UnsubscribeFromSourceIdentifier?: string;
    UnsubscribeFromSourceReason?: string;
    OriginatingOrganizationUnit?: DataLakeSimpleOrganizationUnit;
    Subscription?: DataLakeSubscription;
  }

  export interface DataLakeSubscription {
    ID: string;
    LoyaltyProgramID: string;
    BackendID: string;
    Name: string;
  }

  export interface DataLakeFinancialPeriod {
    DataLakeType: string;
    ID: string;
    FinancialPeriodNumber: string;
    PreviousFinancialPeriodID: string;
    OpeningTime?: string;
    ClosingTime?: string;
    AutoOpened: boolean;
    AutoClosed: boolean;
    Status: string;
    OrganizationUnitID: string;
    /**
     * User who closed the period
     */
    User: DataLakeSimpleUser;
    /**
     * User who opened the period
     */
    OpenedByUser: DataLakeSimpleUser;
    CashDeposits: DataLakeCashDeposit[];
    CashJournals: DataLakeCashJournal[];
    Expenses: DataLakeCashExpense[];
    CashCorrections: DataLakeCashCorrection[];
    Employees: DataLakeFinancialPeriodEmployee[];
    LoyaltyProgram: DataLakeFinancialPeriodLoyaltyProgram;
    CurrencyID: string;
    CostPriceCurrencyID: string;
    FinancialPeriodAuditID: string;
    GenerationTime: string;
  }

  export interface DataLakeCashDeposit {
    DeviceID: string;
    CreationTime: string;
    CurrencyID: string;
    PaymentTypeID: string;
    PaymentType: DataLakePaymentType;
    Number: string;
    Amount: number;
    Status: string;
    CashTransactionLedgerID: string;
    CashTransactionLedger: DataLakeCashTransactionLedger;
    Details: DataLakeCashDepositDetail;
  }

  export interface DataLakePaymentType {
    PaymentMethodID: string;
    Name: string;
    Code: string;
    LedgerClassID: string;
    BackendRelationID: string;
    Category: string;
    CashJournalMethod: string;
  }

  export interface DataLakeCashTransactionLedger {
    ID: string;
    CurrencyID: string;
    CashJournalID: string;
    Description: string;
    Amount: number;
    CreationTime: string;
    CreatedByID: string;
    Details: DataLakeCashTransactionLedgerDetail;
    GroupID?: string;
    Type: string;
    PaymentTransactionID: string;
  }

  export interface DataLakeCashTransactionLedgerDetail {
    Coins: { [key: number]: number };
    BankNotes: { [key: number]: number };
    CashDeposits: { [key: number]: number };
  }

  export interface DataLakeCashDepositDetail {
    Coins: { [key: number]: number };
    BankNotes: { [key: number]: number };
  }

  export interface DataLakeCashJournal {
    ID: string;
    FinancialPeriodID: string;
    PreviousCashJournalID: string;
    PaymentTypeID: string;
    PaymentType: DataLakePaymentType;
    CurrencyID: string;
    Type: string;
    OpeningTime: string;
    ClosingTime?: string;
    OpeningAmount: number;
    ClosingAmount?: number;
    OpeningDeviation?: number;
    ClosingDeviation?: number;
    StationID: string;
    DeviceID: string;
    DeviceTypeID: string;
    DeviceName: string;
    OpeningDetailsObject: DataLakeCashJournalOpeningDetails;
    ClosingDetailsObject: DataLakeCashJournalClosingDetails;
  }

  export interface DataLakeCashJournalOpeningDetails {
    Coins: { [key: number]: number };
    BankNotes: { [key: number]: number };
    CashDeposits: { [key: number]: number };
  }

  export interface DataLakeCashJournalClosingDetails {
    Coins: { [key: number]: number };
    BankNotes: { [key: number]: number };
    CashDeposits: { [key: number]: number };
    Data: { [key: string]: any };
  }

  export interface DataLakeCashExpense {
    FinancialPeriodID: string;
    CashTransactionLedgerID: string;
    TypeID: string;
    TaxRate: number;
    Amount: number;
    TaxCodeID: string;
    Description: string;
    BlobID?: string;
    Type: DataLakeCashExpenseType;
  }

  export interface DataLakeCashExpenseType {
    ID: string;
    BackendID: string;
    Name: string;
  }

  export interface DataLakeCashCorrection {
    ID: string;
    FinancialPeriodID: string;
    Type: string;
    Amount: number;
    Remark: string;
    CashTransactionLedgerID: string;
    CashTransactionLedger: DataLakeCashTransactionLedger;
  }

  export interface DataLakeFinancialPeriodEmployee {
    UserID: string;
    CommissionShare?: number;
  }

  export interface DataLakeFinancialPeriodLoyaltyProgram {
    ID: string;
  }

  export interface DataLakeStockMutation {
    DataLakeType: string;
    GenerationTime: string;
    ID: string;
    Product: DataLakeProduct;
    OrganizationUnit: DataLakeSimpleOrganizationUnit;
    SourceStockLabel: string;
    DestinationStockLabel: string;
    Quantity: number;
    UnitCost: number;
    Reason: string;
    Remark: string;
    OrderLineID: string;
    BackendSystemID: string;
    BackendID: string;
    SerialNumber?: string;
    Ledgers: DataLakeProductLedger[];
    CreationTime: string;
    CreatedByID: string;
    AutomaticCorrectionQuantity: number;
  }

  export interface DataLakeProductLedger {
    StockLabel: string;
    Quantity: number;
  }

  export interface DataLakeSurvey {
    DataLakeType: string;
    GenerationTime: string;
    ID: string;
    Version: number;
    IsSystem: boolean;
    BackendID: string;
    OrganizationUnitSetID: string;
    Name: string;
    Description: string;
    IntroductionTitle: string;
    IntroductionMessage: string;
    IntroductionBlobID?: string;
    ClosingRemarkTitle: string;
    ClosingRemarkMessage: string;
    ClosingRemarkBlobID?: string;
    SurveyContext: DataLakeEnum;
    SurveyTrigger: string;
    SurveyDistributionHandler: string;
    StartDate: string;
    EndDate?: string;
    LastPublishedByID?: string;
    LastPublishedOn?: string;
    IsDeactivated: boolean;
    LastDeactivatedByID?: string;
    LastDeactivatedOn?: string;
    FirstQuestionID: string;
    Questions: DataLakeSurvey.DataLakeSurveyQuestion[];
  }

  export namespace DataLakeSurvey {
    export interface DataLakeSurveyQuestion {
      ID: string;
      Sequence: number;
      BackendID: string;
      Description: string;
      Remark: string;
      Text: string;
      DataType: DataLakeEnum;
      Type: DataLakeEnum;
      Required: boolean;
      DisplayType: string;
      InputHint: string;
      MinimumLength?: number;
      MaximumLength?: number;
      MinimumDate?: string;
      MaximumDate?: string;
      MinimumValue?: number;
      MaximumValue?: number;
      BlobID?: string;
      OptionalAnswers: { [key: string]: string };
      AllowMultipleAnswers: boolean;
      SurveyContextCustomFieldID?: string;
      StoreAnswerOnContextCustomField: boolean;
      UseContextCustomFieldDataAsPrefill: boolean;
    }

  }

}declare module EVA.Global {

  export interface GetGlobalBlob {
    BlobID: string;
  }

  export interface GetGlobalBlobResponse {
    Data: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GetGlobalBlobInfo {
    BlobID: string;
  }

  export interface GetGlobalBlobInfoResponse {
    Found: boolean;
    OriginalName: string;
    Category: string;
    ExpireDate?: string;
    MimeType: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GetGlobalCurrencies {
  }

  export interface GetGlobalCurrenciesResponse {
    Currencies: GetGlobalCurrenciesResponse.Currency[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetGlobalCurrenciesResponse {
    export interface Currency {
      Name: string;
      Description: string;
      Precision: number;
    }

  }

  export interface GetGlobalMessageTemplates {
  }

  export interface GetGlobalMessageTemplatesResponse {
    Templates: GetGlobalMessageTemplatesResponse.MessageTemplate[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetGlobalMessageTemplatesResponse {
    export interface MessageTemplate {
      Name: string;
      OrganizationUnitGlobalID: string;
      LanguageID: string;
      CountryID: string;
      Template: string;
      Helpers: string;
      Type: EVA.Core.MessageTemplateTypes;
      Layout: string;
      Destination: EVA.Core.MessageTemplateDestinations;
      PaperPropertiesData: string;
      IsDisabled: boolean;
      GlobalID: string;
    }

  }

  export interface GetGlobalOpeningHours {
  }

  export interface GetGlobalOpeningHoursResponse {
    Types: GetGlobalOpeningHoursResponse.TypeData[];
    Templates: GetGlobalOpeningHoursResponse.Template[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetGlobalOpeningHoursResponse {
    export interface TypeData {
      Name: string;
      BackendID: string;
      Description: string;
    }

    export interface Template {
      GlobalID: string;
      TypeName: string;
      OrganizationUnitGlobalID: string;
      Description: string;
      IsImported: boolean;
      Details: GetGlobalOpeningHoursResponse.TemplateDetail[];
      OrganizationUnitSetGlobalIDs: string[];
    }

    export interface TemplateDetail {
      GlobalID: string;
      DayOfWeek?: EVA.Core.DayOfWeek;
      Date?: string;
      Description: string;
      OpeningSlots: GetGlobalOpeningHoursResponse.TemplateDetailSlot[];
    }

    export interface TemplateDetailSlot {
      StartTime: string;
      EndTime: string;
    }

  }

  export interface GetGlobalOrganizationUnitSets {
  }

  export interface GetGlobalOrganizationUnitSetsResponse {
    OrganizationUnitSets: GetGlobalOrganizationUnitSetsResponse.GlobalOrganizationUnitSet[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetGlobalOrganizationUnitSetsResponse {
    export interface GlobalOrganizationUnitSet {
      GlobalID: string;
      OrganizationUnitGlobalID: string;
      SerializedDefinition: string;
      Name: string;
      Type: EVA.Core.OrganizationUnitSetTypes;
      Subsets: GetGlobalOrganizationUnitSetsResponse.Subset[];
    }

    export interface Subset {
      GlobalID: string;
      Type: EVA.Core.OrganizationUnitSetOperatorTypes;
      SequenceNumber: number;
    }

  }

  export interface GetGlobalOrganizationUnits {
  }

  export interface GetGlobalOrganizationUnitsResponse {
    OrganizationUnits: GetGlobalOrganizationUnitsResponse.GlobalOrganizationUnit[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetGlobalOrganizationUnitsResponse {
    export interface GlobalOrganizationUnit {
      GlobalID: string;
      BackendID: string;
      Name: string;
      Description: string;
      Notes: string;
      ParentID: string;
      RegisterCashLimit?: number;
      SafeCashLimit?: number;
      CashHandler: GlobalOrganizationUnit.CashHandlerDto;
      BackendRelationID: string;
      BackendCompanyID: string;
      BranchNumber: string;
      GlobalLocationNumber: string;
      OpeningHours: GlobalOrganizationUnit.OpeningHour[];
      Address: EVA.Core.AddressDataDto;
      Latitude?: number;
      Longitude?: number;
      Type: EVA.Core.OrganizationUnitTypes;
      Status: EVA.Core.OrganizationUnitStatus;
      Subnet: string;
      BankAccount: string;
      VatNumber: string;
      RegistrationNumber: string;
      EmailAddress: string;
      PhoneNumber: string;
      UseForAccounting: boolean;
      AttachedToUserID: string;
      IpAddress: string;
      CountryID: string;
      LanguageID: string;
      CurrencyID: string;
      CostPriceCurrencyID: string;
      CashFloat?: number;
      TimeZone: string;
      TaxProvider: GlobalOrganizationUnit.TaxProviderDto;
      AccountingOrganizationUnitID: string;
      AssortmentCode: string;
      RoleSetID: string;
      RegionID: string;
      ReturnOrganizationUnitID: string;
    }

    export namespace GlobalOrganizationUnit {
      export interface OpeningHour {
        DayOfWeek?: EVA.Core.DayOfWeek;
        StartTime?: string;
        EndTime?: string;
        Date?: string;
        Description: string;
        ClosedForReceipts: boolean;
        Type: string;
      }

      export interface CashHandlerDto {
        Name: string;
        CurrencyID: string;
        RoundingFactor: number;
        Coins: number[];
        BankNotes: number[];
      }

      export interface TaxProviderDto {
        Name: string;
        Type: string;
        BackendID: string;
        Description?: string;
      }

    }

  }

  export interface GetGlobalPaymentTypes {
  }

  export interface GetGlobalPaymentTypesResponse {
    PaymentTypes: GetGlobalPaymentTypesResponse.PaymentTypeDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetGlobalPaymentTypesResponse {
    export interface PaymentTypeDto {
      IsActive: boolean;
      OrganizationUnitSetGlobalID: string;
      PaymentMethodCode: string;
      Name: string;
      Code: string;
      CashJournalMethod: EVA.Core.PaymentCashJournalMethod;
      LedgerClassID: string;
      PrintOnDocuments: boolean;
      BackendRelationID: string;
      AutoFinalizeOnOrderPaid: boolean;
    }

  }

  export interface GetGlobalRegions {
  }

  export interface GetGlobalRegionsResponse {
    Regions: GetGlobalRegionsResponse.Region[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetGlobalRegionsResponse {
    export interface Region {
      Name: string;
      Code: string;
      ApiEndPoint: string;
      IsIsolated: boolean;
      IsPrimary: boolean;
      Prefix: string;
    }

  }

  export interface GetGlobalRoles {
  }

  export interface GetGlobalRolesResponse {
    Roles: GetGlobalRolesResponse.Role[];
    RoleSets: GetGlobalRolesResponse.RoleSet[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetGlobalRolesResponse {
    export interface Role {
      Name: string;
      Code: string;
      UserType: EVA.Core.UserTypes;
      GlobalID: string;
      Functionalities: GetGlobalRolesResponse.Functionality[];
      DeactivateUserAfterInactiveDays?: number;
    }

    export interface Functionality {
      Name: string;
      Scope: EVA.Core.FunctionalityScope;
    }

    export interface RoleSet {
      Name: string;
      BackendID: string;
      GlobalID: string;
      Roles: string[];
    }

  }

  export interface GetGlobalSettings {
    RegionCode?: string;
  }

  export interface GetGlobalSettingsResponse {
    OrganizationUnits: GetGlobalSettingsResponse.OrganizationUnitSettings[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetGlobalSettingsResponse {
    export interface OrganizationUnitSettings {
      GlobalID: string;
      Settings: GetGlobalSettingsResponse.Setting[];
    }

    export interface Setting {
      Name: string;
      Value: string;
      SensitivityTypeID: number;
    }

  }

  export interface GetGlobalUser {
    RegionCode: string;
    Username: string;
    Password: string;
    AsEmployee?: boolean;
  }

  export interface GetGlobalUserResponse {
    User: GetGlobalUserResponse.UserDto;
    Roles: GetGlobalUserResponse.OrganizationUnitRole[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetGlobalUserResponse {
    export interface UserDto {
      EmailAddress: string;
      BackendRelationID: string;
      Initials: string;
      FirstName: string;
      LastName: string;
      DateOfBirth?: string;
      Gender: string;
      PlaceOfBirth: string;
      LanguageID: string;
      CountryID: string;
      Type: EVA.Core.UserTypes;
      Nickname: string;
      FiscalID: string;
      SocialSecurityNumber: string;
      BankAccount: string;
      PhoneNumber: string;
      TimeZone: string;
      BackendSystemID: string;
      BackendID: string;
      GlobalID: string;
      Title: string;
      Salutation: string;
      PricingGroupID?: string;
    }

    export interface OrganizationUnitRole {
      OrganizationUnitGlobalID: string;
      OrganizationUnitSetGlobalID: string;
      RoleGlobalID: string;
      UserType: EVA.Core.UserTypes;
    }

  }

}declare module EVA.GlobalBlue {

  export namespace Errors {
    export const enum GlobalBlue {
      /**
       * Order {0:number} has no valid EligibilityCheck yet.
       */
      NoValidEligibilityCheckDone = 'GlobalBlue:NoValidEligibilityCheckDone',
      /**
       * Order {0:number} is already issued with GlobalBlue.
       */
      OrderAlreadyIssued = 'GlobalBlue:OrderAlreadyIssued',
      /**
       * Order {0:number} is not invoiced yet, TaxFreeForm unavailable.
       */
      OrderNotInvoiced = 'GlobalBlue:OrderNotInvoiced',
      /**
       * Order {0:number} has no TaxFreeForm yet, request it first before printing.
       */
      NoTaxFreeFormAvailable = 'GlobalBlue:NoTaxFreeFormAvailable',
      /**
       * The supplier identifier is not valid, it should start with 308604.
       */
      InvalidGlobalBlueIdentifier = 'GlobalBlue:InvalidGlobalBlueIdentifier',
      /**
       * Global Blue is not enabled for the current organizationunit.
       */
      Disabled = 'GlobalBlue:Disabled'
    }

  }


  /**
   * Fetch the eligibility information for the current order.
   * 
   * When no BillingAddress is available on the Order, the country of residence has to be provided in the CountryCode field.
   * 
   * If the response TaxFreeAvailble is true, the user can proceed with calling the GlobalBlueStartTaxFree service.
   * 
   * If the response is false, tax free is not available. This can be due to several reasons:
   * - CountryEligibility == false: the selected CountryOfResidence is not eligible for TaxFree
   * - Amounts.AmountBelowMinimum: the total amount of the order is not enough to qualify for tax free, it should be at least Amounts.MinAmount
   * - Amounts.AmountOverMaximum: the total amount of the order is to much to qualify for tax free, it should be lower than Amounts.MaxAmount
   */
  export interface GlobalBlueGetEligibilityInformation {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Country of residence of the customer, overrides billingaddress CountryID
     * Entity type: Country
     */
    CountryCode?: string;
  }

  export interface GlobalBlueGetEligibilityInformationResponse {
    /**
     * Is this order eligible for a taxfree form
     */
    TaxFreeAvailable: boolean;
    /**
     * Is the provided country eligible for a taxfree form
     */
    CountryEligibility: boolean;
    Amounts: GlobalBlueGetEligibilityInformationResponse.GrossAmounts;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GlobalBlueGetEligibilityInformationResponse {
    export interface GrossAmounts {
      /**
       * Amount that should be added to the order to validate for TaxFree
       */
      AmountBelowMinimum: number;
      MinAmount: number;
      /**
       * Amount that should be removed from the order to validate for TaxFree
       */
      AmountOverMaximum: number;
      MaxAmount: number;
    }

  }

  /**
   * Fetch the reissue information for the current return order.
   * 
   * It will return the orders that will be voided, but are not fully returned, so it would make sense to reissue these orders.
   */
  export interface GlobalBlueGetOrdersToReissue {
    /**
     * The return order
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GlobalBlueGetOrdersToReissueResponse {
    Orders: GlobalBlueGetOrdersToReissueResponse.ReturnOrder[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GlobalBlueGetOrdersToReissueResponse {
    export interface ReturnOrder {
      /**
       * Entity type: Order
       */
      OrderID: number;
    }

  }

  /**
   * This service can be used to print the TaxFree form after it has been issued for an Order.
   * 
   * The OrderID is required, the StationID is optional when it's provided in the header.
   */
  export interface GlobalBluePrintForm {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: Station
     */
    StationID?: number;
  }

  /**
   * After a GlobalBlue card is scanned the number can be stored on the order to allow fast TaxFree handling.
   * 
   * To remove the GlobalBlueIdentifier from the Order call this service without providing the GlobalBlueIdentifier property.
   */
  export interface GlobalBlueSetGlobalBlueIdentifier {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    GlobalBlueIdentifier?: string;
  }

  /**
   * Start the GlobalBlue TaxFreeForm issuing process.
   * 
   * This will only work for Orders that passed the Eligibility check done by the GlobalBlueGetEligibilityInformation service.
   * The order should also be Invoiced.
   * 
   * The property PosIdentification should contain a unique identifier for the POS device performing this operation.
   */
  export interface GlobalBlueStartTaxFree {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Random GUID unique for the current POS/Companion instance
     */
    PosIdentification: string;
  }

  export interface GlobalBlueStartTaxFreeResponse {
    Url: string;
    FormData: { [key: string]: string };
    GroupID: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

}declare module EVA.Intersolve {

  export namespace Errors {
    export const enum Intersolve {
      /**
       * Failed to issue giftcard on order {0:number}
       */
      IssuingFailed = 'Intersolve:IssuingFailed',
      /**
       * A CardNumber is required to activate a giftcard
       */
      MissingCardNumber = 'Intersolve:MissingCardNumber',
      /**
       * A PaymentTransaction can only be refunded for the full amount
       */
      RefundsCanOnlyBeDoneForTheFullAmount = 'Intersolve:RefundsCanOnlyBeDoneForTheFullAmount',
      /**
       * No CardActionLedger could be found for the PaymentTransaction
       */
      NoCardActionLedgerFound = 'Intersolve:NoCardActionLedgerFound',
      /**
       * Card with SerialNumber {0:string} was not found
       */
      CardNotFound = 'Intersolve:CardNotFound',
      /**
       * Trying to pay with '{currencyID:string}' but the card is in '{cardCurrencyID:string}'
       */
      CurrencyMismatch = 'Intersolve:CurrencyMismatch',
      /**
       * Failed to create a payment: {0:string}
       */
      CardActivationFailed = 'Intersolve:CardActivationFailed',
      /**
       * Failed to cancel the transaction: {0:string}
       */
      CardTransactionCancellationFailed = 'Intersolve:CardTransactionCancellationFailed',
      /**
       * Code {Code:number}: {Message:string}
       */
      UnknownResultCode = 'Intersolve:UnknownResultCode',
      /**
       * Error in the configuration at the Intersolve side. Please contact Intersolve.
       */
      ConfigurationError = 'Intersolve:ConfigurationError',
      /**
       * Service failed. This can be a typo in the command.
       */
      ServiceFailed = 'Intersolve:ServiceFailed',
      /**
       * Invalid operation.
       */
      Error_1 = 'Intersolve:Error_1',
      /**
       * XML Syntax error
       */
      Error_2 = 'Intersolve:Error_2',
      /**
       * Authorization failed, not logged in.
       */
      Error_3 = 'Intersolve:Error_3',
      /**
       * Login failed (Reason not specified).
       */
      Error_4 = 'Intersolve:Error_4',
      /**
       * Invalid parameters (e.g. no CardId specified).
       */
      Error_5 = 'Intersolve:Error_5',
      /**
       * Not allowed to import this card holder.
       */
      Error_6 = 'Intersolve:Error_6',
      /**
       * Retailer not in Group.
       */
      Error_7 = 'Intersolve:Error_7',
      /**
       * Invalid Identifier.
       */
      Error_8 = 'Intersolve:Error_8',
      /**
       * Invalid/unknown Retailer.
       */
      Error_9 = 'Intersolve:Error_9',
      /**
       * Invalid/unknown Terminal.
       */
      Error_10 = 'Intersolve:Error_10',
      /**
       * Invalid Terminal/password does not match. Not authorized.
       */
      Error_11 = 'Intersolve:Error_11',
      /**
       * Invalid Terminal originating address.
       */
      Error_12 = 'Intersolve:Error_12',
      /**
       * No configuration available.
       */
      Error_13 = 'Intersolve:Error_13',
      /**
       * Origination address not authorized.
       */
      Error_14 = 'Intersolve:Error_14',
      /**
       * No transaction available to confirm or cancel.
       */
      Error_15 = 'Intersolve:Error_15',
      /**
       * RetailerId/TerminalId combination does not exist.
       */
      Error_16 = 'Intersolve:Error_16',
      /**
       * Unable to cancel. Pos cannot cancel transaction.
       */
      Error_18 = 'Intersolve:Error_18',
      /**
       * Transaction can not be cancelled at this moment, please try again later.
       */
      Error_19 = 'Intersolve:Error_19',
      /**
       * Add card failed.
       */
      Error_20 = 'Intersolve:Error_20',
      /**
       * Card already exists.
       */
      Error_21 = 'Intersolve:Error_21',
      /**
       * Unknown brand type.
       */
      Error_22 = 'Intersolve:Error_22',
      /**
       * Login failed: Device blocked due to license agreement violation.
       */
      Error_23 = 'Intersolve:Error_23',
      /**
       * Login failed: Device usage exceeds license agreement.
       */
      Error_24 = 'Intersolve:Error_24',
      /**
       * Post issue failed.
       */
      Error_100 = 'Intersolve:Error_100',
      /**
       * Card or Customer does not exist.
       */
      Error_101 = 'Intersolve:Error_101',
      /**
       * Card is expired.
       */
      Error_102 = 'Intersolve:Error_102',
      /**
       * Card is blocked.
       */
      Error_103 = 'Intersolve:Error_103',
      /**
       * Insufficient balance to perform transaction.
       */
      Error_104 = 'Intersolve:Error_104',
      /**
       * Usr/pwd does not match with cardholder.
       */
      Error_105 = 'Intersolve:Error_105',
      /**
       * Cardholder not registered.
       */
      Error_106 = 'Intersolve:Error_106',
      /**
       * Invalid sequence number.
       */
      Error_107 = 'Intersolve:Error_107',
      /**
       * Card not related to a Group.
       */
      Error_108 = 'Intersolve:Error_108',
      /**
       * Invalid CardId. Invalid EAN.
       */
      Error_109 = 'Intersolve:Error_109',
      /**
       * Invalid Email address.
       */
      Error_110 = 'Intersolve:Error_110',
      /**
       * Invalid Country.
       */
      Error_111 = 'Intersolve:Error_111',
      /**
       * Invalid ObjectId/ObjectType.
       */
      Error_112 = 'Intersolve:Error_112',
      /**
       * Invalid CardCode in CustomerId.
       */
      Error_113 = 'Intersolve:Error_113',
      /**
       * Card is already active.
       */
      Error_114 = 'Intersolve:Error_114',
      /**
       * Invalid GroupId.
       */
      Error_115 = 'Intersolve:Error_115',
      /**
       * Invalid Card Format.
       */
      Error_116 = 'Intersolve:Error_116',
      /**
       * Invalid Scheme.
       */
      Error_117 = 'Intersolve:Error_117',
      /**
       * Card is transferred.
       */
      Error_118 = 'Intersolve:Error_118',
      /**
       * Card is not active / Inactive Brand Type.
       */
      Error_119 = 'Intersolve:Error_119',
      /**
       * Incorrect activation or purchase value / Pre dominated rule violated / Minimum balance rule violated.
       */
      Error_120 = 'Intersolve:Error_120',
      /**
       * Customer already exists.
       */
      Error_121 = 'Intersolve:Error_121',
      /**
       * Card already exists.
       */
      Error_122 = 'Intersolve:Error_122',
      /**
       * Customer does not exist.
       */
      Error_123 = 'Intersolve:Error_123',
      /**
       * Maximum number of transactions per day reached.
       */
      Error_124 = 'Intersolve:Error_124',
      /**
       * Maximum number of transactions per day per retailer reached.
       */
      Error_125 = 'Intersolve:Error_125',
      /**
       * Maximum issue points per day is reached.
       */
      Error_126 = 'Intersolve:Error_126',
      /**
       * Card not available. / Out of cards stock.
       */
      Error_127 = 'Intersolve:Error_127',
      /**
       * Not allowed to redeem on date of first transaction (business rule 107 indicates that you are only allowed to perform a redeem one day after the first issue transaction).
       */
      Error_128 = 'Intersolve:Error_128',
      /**
       * Number of points for issue or redeem transaction is too high (MaxPointsPerIssue or MaxPointsPerRedeem).
       */
      Error_129 = 'Intersolve:Error_129',
      /**
       * The service is not available on the card.
       */
      Error_130 = 'Intersolve:Error_130',
      /**
       * The service cannot be verified.
       */
      Error_131 = 'Intersolve:Error_131',
      /**
       * Receipt not found.
       */
      Error_132 = 'Intersolve:Error_132',
      /**
       * Receipt already claimed.
       */
      Error_133 = 'Intersolve:Error_133',
      /**
       * Invalid block date.
       */
      Error_134 = 'Intersolve:Error_134',
      /**
       * SchemeId already exists.
       */
      Error_135 = 'Intersolve:Error_135',
      /**
       * Balance not available.
       */
      Error_136 = 'Intersolve:Error_136',
      /**
       * Invalid Brand.
       */
      Error_140 = 'Intersolve:Error_140',
      /**
       * Invalid BrandType.
       */
      Error_141 = 'Intersolve:Error_141',
      /**
       * Maximum card balance is reached.
       */
      Error_161 = 'Intersolve:Error_161',
      /**
       * Card is not reloadable. / Too many reload transactions. / Wrong balance on Reload.
       */
      Error_162 = 'Intersolve:Error_162',
      /**
       * Card is already assigned to a customer.
       */
      Error_163 = 'Intersolve:Error_163',
      /**
       * Wrong currency.
       */
      Error_164 = 'Intersolve:Error_164',
      /**
       * Transaction would exceed configured limits.
       */
      Error_165 = 'Intersolve:Error_165',
      /**
       * Login failed: Unknown user.
       */
      Error_201 = 'Intersolve:Error_201',
      /**
       * Maximum simultaneous logins reached.
       */
      Error_202 = 'Intersolve:Error_202',
      /**
       * User is already logged in.
       */
      Error_203 = 'Intersolve:Error_203',
      /**
       * Login account is set inactive.
       */
      Error_204 = 'Intersolve:Error_204',
      /**
       * Database is locked.
       */
      Error_205 = 'Intersolve:Error_205',
      /**
       * Database is expired and now set to locked.
       */
      Error_206 = 'Intersolve:Error_206',
      /**
       * Login failed: Invalid password.
       */
      Error_207 = 'Intersolve:Error_207',
      /**
       * Invalid Username.
       */
      Error_208 = 'Intersolve:Error_208',
      /**
       * Invalid SecretAnswer.
       */
      Error_209 = 'Intersolve:Error_209',
      /**
       * Invalid SecretQuestion.
       */
      Error_210 = 'Intersolve:Error_210',
      /**
       * Invalid PIN.
       */
      Error_211 = 'Intersolve:Error_211',
      /**
       * Invalid EAN code.
       */
      Error_212 = 'Intersolve:Error_212',
      /**
       * Invalid E-mail address.
       */
      Error_250 = 'Intersolve:Error_250',
      /**
       * E-mail or customer information is missing.
       */
      Error_251 = 'Intersolve:Error_251',
      /**
       * E-mail address already in use.
       */
      Error_252 = 'Intersolve:Error_252',
      /**
       * Invalid ConfigurationId.
       */
      Error_300 = 'Intersolve:Error_300',
      /**
       * Invalid VoucherId.
       */
      Error_301 = 'Intersolve:Error_301',
      /**
       * Invalid IssuedVoucherId. The specified issued voucher does not exist or does not have the correct status.
       */
      Error_302 = 'Intersolve:Error_302',
      /**
       * Voucher not found.
       */
      Error_303 = 'Intersolve:Error_303',
      /**
       * Voucher not available.
       */
      Error_304 = 'Intersolve:Error_304',
      /**
       * Invalid Voucher/Owner combination.
       */
      Error_305 = 'Intersolve:Error_305',
      /**
       * Invalid MediaId/MediaType.
       */
      Error_306 = 'Intersolve:Error_306',
      /**
       * Voucher has been redeemed already.
       */
      Error_307 = 'Intersolve:Error_307',
      /**
       * Refund not supported for this voucher.
       */
      Error_308 = 'Intersolve:Error_308',
      /**
       * Voucher redeem currently denied for this voucher.
       */
      Error_309 = 'Intersolve:Error_309',
      /**
       * Invalid redeem currently denied for this voucher.
       */
      Error_310 = 'Intersolve:Error_310',
      /**
       * Maximum number of voucher issues exceeded for this voucher.
       */
      Error_311 = 'Intersolve:Error_311',
      /**
       * Invalid Brand Type ID. / Voucher has been purchased already.
       */
      Error_312 = 'Intersolve:Error_312',
      /**
       * Voucher Reservation Expired.
       */
      Error_313 = 'Intersolve:Error_313',
      /**
       * Invalid Delivery Method.
       */
      Error_314 = 'Intersolve:Error_314',
      /**
       * CardId/InitialAccessCode mismatch.
       */
      Error_401 = 'Intersolve:Error_401',
      /**
       * Scheme not found.
       */
      Error_402 = 'Intersolve:Error_402',
      /**
       * Invalid RegisterCode.
       */
      Error_403 = 'Intersolve:Error_403',
      /**
       * Card does not belong to the customer.
       */
      Error_404 = 'Intersolve:Error_404',
      /**
       * The source and destination card must be specified.
       */
      Error_405 = 'Intersolve:Error_405',
      /**
       * May not transfer to the same card.
       */
      Error_406 = 'Intersolve:Error_406',
      /**
       * Transfer customer failed.
       */
      Error_407 = 'Intersolve:Error_407',
      /**
       * Customer not found.
       */
      Error_408 = 'Intersolve:Error_408',
      /**
       * Invalid CustomerId format.
       */
      Error_409 = 'Intersolve:Error_409',
      /**
       * No active draw.
       */
      Error_500 = 'Intersolve:Error_500',
      /**
       * Draw is closed. New sales starts tomorrow.
       */
      Error_501 = 'Intersolve:Error_501',
      /**
       * No lottery tickets available.
       */
      Error_502 = 'Intersolve:Error_502',
      /**
       * No active draw for this product.
       */
      Error_503 = 'Intersolve:Error_503',
      /**
       * Sold out. Select a different day.
       */
      Error_504 = 'Intersolve:Error_504',
      /**
       * Customer does not exist.
       */
      Error_550 = 'Intersolve:Error_550',
      /**
       * Validation field 1 not valid.
       */
      Error_551 = 'Intersolve:Error_551',
      /**
       * Validation field 2 not valid.
       */
      Error_552 = 'Intersolve:Error_552',
      /**
       * Validation field 3 not valid.
       */
      Error_553 = 'Intersolve:Error_553',
      /**
       * Delivery type is not supported.
       */
      Error_554 = 'Intersolve:Error_554',
      /**
       * Card already has a PIN.
       */
      Error_555 = 'Intersolve:Error_555',
      /**
       * Card does have a PIN.
       */
      Error_556 = 'Intersolve:Error_556',
      /**
       * Invalid PIN.
       */
      Error_557 = 'Intersolve:Error_557',
      /**
       * Could not encrypt PIN.
       */
      Error_558 = 'Intersolve:Error_558',
      /**
       * Payment Ok.
       */
      Error_700 = 'Intersolve:Error_700',
      /**
       * Payment failed.
       */
      Error_701 = 'Intersolve:Error_701',
      /**
       * Payment declined.
       */
      Error_702 = 'Intersolve:Error_702',
      /**
       * Payment pending.
       */
      Error_703 = 'Intersolve:Error_703',
      /**
       * Payment revoked.
       */
      Error_704 = 'Intersolve:Error_704',
      /**
       * Transaction not found.
       */
      Error_705 = 'Intersolve:Error_705',
      /**
       * Payment needs to be cancelled.
       */
      Error_706 = 'Intersolve:Error_706',
      /**
       * Special fixed value activation already done.
       */
      Error_914 = 'Intersolve:Error_914',
      /**
       * Special fixed value activation.
       */
      Error_919 = 'Intersolve:Error_919',
      /**
       * No bueno.
       */
      NoBueno = 'Intersolve:NoBueno'
    }

  }


  export interface AddVoucherToShoppingCart {
    /**
     * Entity type: Order
     */
    OrderID: number;
    VoucherID: number;
  }

  export interface ListVoucherConfigurations {
  }

  export interface ListVoucherConfigurationsResponse {
    VoucherProviders: VoucherProvider[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface VoucherProvider {
    Options: VoucherOption[];
    Name: string;
  }

  export interface VoucherOption {
    Name: string;
    VoucherID: number;
    EAN: string;
    Value: number;
    LayoutID: string;
    Layout: string;
    UnitCost: number;
  }

}declare module EVA.Kafka {

  /**
   * Export Kafka message history to CSV. Only accessible by NewBlack
   */
  export interface KafkaHistoryExportRequest {
    /**
     * Optional configuration ID to use as a filter
     * Entity type: EventExportConfiguration
     */
    EventExportConfigurationID?: number;
    /**
     * Optional specific message identifiers to filter
     */
    Identifiers?: string[];
    /**
     * Maximum number of messages to export
     */
    MaxMessages?: number;
    /**
     * Group to export from (when no event export config is specified)
     * @default Events
     */
    MessageGroup?: EVA.Core.MessageGroups;
  }

}declare module EVA.Monitor {

  export namespace Errors {
    export const enum Monitors {
      /**
       * You are not allowed to edit this monitor.
       */
      NotAllowedToEditMonitor = 'Monitors:NotAllowedToEditMonitor',
      /**
       * This handler does not support conditions.
       */
      HandlerDoesNotSupportConditions = 'Monitors:HandlerDoesNotSupportConditions',
      /**
       * The handler with name {0:string} does not exist
       */
      InvalidHandler = 'Monitors:InvalidHandler',
      /**
       * An unknown error occurred while executing this monitor
       */
      UnknownError = 'Monitors:UnknownError'
    }

  }


  /**
   * Creates a monitor. See documentation for handler arguments.
   */
  export interface CreateMonitor {
    Handler?: string;
    Name?: string;
    DefaultLevel?: MonitorLevel;
    Description?: string;
    Cron?: string;
    Data?: { [key: string]: any };
    /**
     * Entity type: Script
     */
    ScriptID?: number;
  }

  export const enum MonitorLevel {
    Info = 0,
    Warning = 1,
    Error = 2,
    Fatal = 3
  }

  export interface CreateMonitorResponse {
    /**
     * Entity type: Monitor
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Deletes a monitor.
   */
  export interface DeleteMonitor {
    /**
     * Entity type: Monitor
     */
    ID: number;
  }

  /**
   * Download the last monitor results as excel
   */
  export interface DownloadMonitorResult {
    /**
     * Entity type: Monitor
     */
    MonitorID: number;
  }

  /**
   * Get available conditions for monitors.
   */
  export interface GetAvailableConditionsForMonitorHandler {
    Handler?: string;
  }

  export interface GetAvailableConditionsForMonitorHandlerResponse {
    AvailableConditions?: GetAvailableConditionsForMonitorHandlerResponse.AvailableCondition[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAvailableConditionsForMonitorHandlerResponse {
    export interface AvailableCondition {
      Name?: string;
      ValueOperators?: string[];
    }

  }

  /**
   * Returns available monitor handlers.
   */
  export interface GetAvailableMonitorHandlers {
  }

  export interface GetAvailableMonitorHandlersResponse {
    Handlers?: GetAvailableMonitorHandlersResponse.AvailableHandler[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAvailableMonitorHandlersResponse {
    export interface AvailableHandler {
      Name?: string;
      SupportsConditions?: boolean;
      ScriptingExtensionType?: string;
    }

  }

  /**
   * Gets the last result of a monitor.
   */
  export interface GetMonitorResult {
    /**
     * Entity type: Monitor
     */
    ID?: number;
  }

  export interface GetMonitorResultResponse {
    /**
     * Entity type: Monitor
     */
    ID?: number;
    Name?: string;
    Handler?: string;
    IsDefaultMonitor?: boolean;
    Description?: string;
    LastResult?: { [key: string]: any };
    LastResultCount?: number;
    LastRun?: string;
    DefaultLevel?: MonitorLevel;
    LastNotification?: NotificationDetails;
    LastNotificationDate?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface NotificationDetails {
    /**
     * Entity type: MonitorNotification
     */
    ID?: number;
    Description?: string;
    Threshold?: number;
    Inverse?: boolean;
    Level?: MonitorLevel;
  }

  /**
   * Gets Monitor by ID and returns basic information
   */
  export interface GetMonitor {
    /**
     * Entity type: Monitor
     */
    ID?: number;
  }

  export interface GetMonitorResponse {
    /**
     * Entity type: Monitor
     */
    ID?: number;
    Name?: string;
    Description?: string;
    Handler?: string;
    Data?: { [key: string]: any };
    IsDefaultMonitor?: boolean;
    CreationTime?: string;
    RoleOwners?: GetMonitorResponse.RoleOwnerData[];
    ConfiguredNotifications?: NotificationDetails[];
    DefaultLevel?: MonitorLevel;
    LastNotification?: NotificationDetails;
    LastNotificationDate?: string;
    IsAllowedToEdit?: boolean;
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    ScriptingExtensionType?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetMonitorResponse {
    export interface RoleOwnerData {
      /**
       * Entity type: Role
       */
      RoleID?: number;
      Name?: string;
      IsAllowedToEdit?: boolean;
    }

    export interface UserOwnerData {
      /**
       * Entity type: User
       */
      UserID?: number;
      Name?: string;
      IsAllowedToEdit?: boolean;
    }

  }

  /**
   * Gets all visible monitors by current user.
   */
  export interface GetUserMonitors {
    Handler?: string;
  }

  export interface GetUserMonitorsResponse {
    Monitors?: GetUserMonitorsResponse.UserMonitor[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetUserMonitorsResponse {
    export interface UserMonitor {
      /**
       * Entity type: Monitor
       */
      ID?: number;
      Name?: string;
      Handler?: string;
      IsDefaultMonitor?: boolean;
      Description?: string;
      IsAllowedToEdit?: boolean;
      LastRun?: string;
      LastResultCount?: number;
      DefaultLevel?: MonitorLevel;
      LastNotification?: NotificationDetails;
      LastNotificationDate?: string;
    }

  }

  /**
   * Gets the last result of a monitor.
   */
  export interface ListScriptedMonitorResults {
    InitialPageConfig?: EVA.Core.PageTokenConfig<ListScriptedMonitorResultFilter>;
    PageToken?: string;
  }

  export interface ListScriptedMonitorResultFilter {
    /**
     * Entity type: Monitor
     */
    MonitorID: number;
  }

  export interface ListScriptedMonitorResultsResponse {
    Results?: ListScriptedMonitorResultsResponse.ResultItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListScriptedMonitorResultsResponse {
    export interface ResultItem {
      DataModelID?: string;
      Data?: any;
    }

  }

  /**
   * This service can be called to manually trigger a monitor.
   */
  export interface RunMonitor {
    /**
     * Entity type: Monitor
     */
    ID: number;
  }

  /**
   * Set permissions for a monitor.
   */
  export interface SetMonitorPermissions {
    /**
     * Entity type: Monitor
     */
    ID?: number;
    RoleOwners?: SetMonitorPermissions.RoleOwnerData[];
  }

  export namespace SetMonitorPermissions {
    export interface RoleOwnerData {
      /**
       * Entity type: Role
       */
      RoleID: number;
      IsAllowedToEdit: boolean;
    }

    export interface UserOwnerData {
      /**
       * Entity type: User
       */
      UserID: number;
      IsAllowedToEdit: boolean;
    }

  }

  /**
   * Updates a monitor.
   */
  export interface UpdateMonitor {
    /**
     * Entity type: Monitor
     */
    ID: number;
    Description?: string;
    Cron?: string;
    Name?: string;
    Data?: { [key: string]: any };
    /**
     * Entity type: Script
     */
    ScriptID?: number;
    DefaultLevel?: MonitorLevel;
  }

  /**
   * Creates a role owner for a monitor.
   */
  export interface CreateMonitorRoleOwner {
    /**
     * Entity type: Monitor
     */
    MonitorID?: number;
    /**
     * Entity type: Role
     */
    RoleID?: number;
    IsAllowedToEdit?: boolean;
  }

  export interface CreateMonitorRoleOwnerResponse {
    Result: CreateMonitorRoleOwnerResult;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export const enum CreateMonitorRoleOwnerResult {
    Created = 0,
    Updated = 1
  }

  /**
   * Deletes a monitor role owner.
   */
  export interface DeleteMonitorRoleOwner {
    /**
     * Entity type: Monitor
     */
    MonitorID: number;
    /**
     * Entity type: Role
     */
    RoleID: number;
  }

  /**
   * Creates a email recipient for a Notification.
   */
  export interface CreateMonitorNotificationEmailRecipient {
    /**
     * Entity type: MonitorNotification
     */
    NotificationID?: number;
    EmailAddress?: string;
  }

  export interface CreateMonitorNotificationEmailRecipientResponse {
    /**
     * Entity type: MonitorNotificationEmailRecipient
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Creates a monitor Notification.
   */
  export interface CreateMonitorNotification {
    /**
     * Entity type: Monitor
     */
    MonitorID?: number;
    Level?: MonitorLevel;
    Threshold?: number;
    /**
     * @default false
     */
    Inverse?: boolean;
    Description?: string;
    EmailSubject?: string;
    EmailRecipients?: CreateMonitorNotification.EmailRecipientData[];
  }

  export namespace CreateMonitorNotification {
    export interface EmailRecipientData {
      EmailAddress?: string;
    }

  }

  export interface CreateMonitorNotificationResponse {
    /**
     * Entity type: MonitorNotification
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Deletes email recipient for given monitor Notification.
   */
  export interface DeleteMonitorNotificationEmailRecipient {
    /**
     * Entity type: MonitorNotificationEmailRecipient
     */
    ID: number;
  }

  /**
   * Deletes a monitor Notification.
   */
  export interface DeleteMonitorNotification {
    /**
     * Entity type: MonitorNotification
     */
    ID: number;
  }

  /**
   * Returns information about given recipient.
   */
  export interface GetMonitorNotificationEmailRecipient {
    /**
     * Entity type: MonitorNotificationEmailRecipient
     */
    ID?: number;
  }

  export interface GetMonitorNotificationEmailRecipientResponse {
    /**
     * Entity type: MonitorNotificationEmailRecipient
     */
    ID?: number;
    EmailAddress?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Gets all email recipients for given monitor Notification.
   */
  export interface GetMonitorNotificationEmailRecipients {
    /**
     * Entity type: MonitorNotification
     */
    NotificationID?: number;
  }

  export interface GetMonitorNotificationEmailRecipientsResponse {
    Recipients?: GetMonitorNotificationEmailRecipientsResponse.EmailRecipient[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetMonitorNotificationEmailRecipientsResponse {
    export interface EmailRecipient {
      /**
       * Entity type: MonitorNotificationEmailRecipient
       */
      ID?: number;
      EmailAddress?: string;
    }

  }

  /**
   * Returns information about given monitor Notification.
   */
  export interface GetMonitorNotification {
    /**
     * Entity type: MonitorNotification
     */
    ID?: number;
  }

  export interface GetMonitorNotificationResponse {
    /**
     * Entity type: MonitorNotification
     */
    ID?: number;
    Level?: MonitorLevel;
    Threshold?: number;
    Inverse?: boolean;
    Description?: string;
    EmailSubject?: string;
    EmailRecipients?: GetMonitorNotificationResponse.EmailRecipientData[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetMonitorNotificationResponse {
    export interface EmailRecipientData {
      EmailAddress?: string;
    }

  }

  /**
   * Returns all Notifications for given monitor.
   */
  export interface GetMonitorNotifications {
    /**
     * Entity type: Monitor
     */
    MonitorID?: number;
  }

  export interface GetMonitorNotificationsResponse {
    Notifications?: GetMonitorNotificationsResponse.MonitorNotification[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetMonitorNotificationsResponse {
    export interface MonitorNotification {
      /**
       * Entity type: MonitorNotification
       */
      ID?: number;
      Level?: MonitorLevel;
      Threshold?: number;
      Inverse?: boolean;
      Description?: string;
      EmailSubject?: string;
      EmailRecipients?: MonitorNotification.EmailRecipientData[];
    }

    export namespace MonitorNotification {
      export interface EmailRecipientData {
        EmailAddress?: string;
      }

    }

  }

  export interface UpdateMonitorNotificationEmailRecipient {
    /**
     * Entity type: MonitorNotification
     */
    ID?: number;
    EmailAddress?: string;
  }

  /**
   * Updates monitor Notification details.
   */
  export interface UpdateMonitorNotification {
    /**
     * Entity type: MonitorNotification
     */
    ID: number;
    Level?: MonitorLevel;
    Threshold?: number;
    Inverse?: boolean;
    Description?: string;
    EmailSubject?: string;
    EmailRecipients?: UpdateMonitorNotification.EmailRecipientData[];
  }

  export namespace UpdateMonitorNotification {
    export interface EmailRecipientData {
      EmailAddress?: string;
    }

  }

}declare module EVA.PDF {

  export namespace Errors {
    export const enum MergePdfBlobs {
      /**
       * Too many blobs
       */
      TooManyBlobs = 'MergePdfBlobs:TooManyBlobs'
    }

    export const enum BlobMerger {
      /**
       * Blob {blobID:string} has invalid mime type {mimeType:string}
       */
      InvalidMimeType = 'BlobMerger:InvalidMimeType',
      /**
       * Merging PDFs failed
       */
      MergeFailed = 'BlobMerger:MergeFailed'
    }

  }


  /**
   * Merges blobs into one PDF
   */
  export interface MergePdfBlobs {
    /**
     * Can be used for standard blobs - for secure blobs, use `BlobUrls` instead. Limited to 100 entries.
     * Entity type: Blob
     */
    Blobs?: string[];
    /**
     * Can be used for both standard- and secured blobs - must match environment assets URL. Limited to 100 entries.
     */
    BlobUrls?: string[];
  }

}declare module EVA.PIM {

  export namespace Errors {
    export const enum Assortment {
      /**
       * Assortment is missing content culture.
       */
      MissingContentCulture = 'Assortment:MissingContentCulture'
    }

    export const enum SecondChanceProductRegistration {
      /**
       * MimeType {MimeType:string} for BlobID {BlobID:string} is an invalid MimeType for an image
       */
      InvalidMimeTypeForImage = 'SecondChanceProductRegistration:InvalidMimeTypeForImage',
      /**
       * The specified serial number {serialNumber:string} must either be new or it must belong to the original product {productID:number}.
       */
      InvalidSerialNumber = 'SecondChanceProductRegistration:InvalidSerialNumber',
      /**
       * The specified serial number {serialNumber:string} must match the regex of configuration {configurationID:number}.
       */
      InvalidSerialNumberForConfiguration = 'SecondChanceProductRegistration:InvalidSerialNumberForConfiguration'
    }

    export const enum CustomContent {
      /**
       * Error converting property {0:string}: {1:string}
       */
      DataTypeError = 'CustomContent:DataTypeError'
    }

    export const enum ImportProducts {
      /**
       * Product {productID:string} uses unknown TaxCode {taxCode:string}
       */
      UnknownTaxCode = 'ImportProducts:UnknownTaxCode',
      /**
       * The provided request did not pass validation. Failures: {0:string}
       */
      ValidationFailures = 'ImportProducts:ValidationFailures',
      /**
       * The assortment '{0:string}' is not known.
       */
      UnknownAssortment = 'ImportProducts:UnknownAssortment'
    }

    export const enum ProductCapacityPlans {
      /**
       * Either a ProductSearchTemplateID or ProductSearchFilters are required for a dynamic ProductCapacityPlan.
       */
      FiltersAreRequiredForADynamicCapacityPlan = 'ProductCapacityPlans:FiltersAreRequiredForADynamicCapacityPlan',
      /**
       * Cannot add or remove products on a dynamic ProductCapacityPlan.
       */
      CannotAddOrRemoveProductsOnADynamicCapacityPlan = 'ProductCapacityPlans:CannotAddOrRemoveProductsOnADynamicCapacityPlan',
      /**
       * Products already linked to a static ProductCapacityPlan.
       */
      ProductsAlreadyHaveAStaticProductCapacityPlan = 'ProductCapacityPlans:ProductsAlreadyHaveAStaticProductCapacityPlan',
      /**
       * Cannot convert ProductCapacityPlan from static to dynamic.
       */
      CannotConvertProductCapacityPlanFromStaticToDynamic = 'ProductCapacityPlans:CannotConvertProductCapacityPlanFromStaticToDynamic',
      /**
       * Exception requires `DayOfWeek` or `Date` to be given.
       */
      ExceptionRequiresDayOfWeekOrDate = 'ProductCapacityPlans:ExceptionRequiresDayOfWeekOrDate'
    }

    export const enum ProductExcelServices {
      /**
       * Cannot find header row
       */
      MissingHeaderRow = 'ProductExcelServices:MissingHeaderRow',
      /**
       * Unit Of Measure {0:string} does not exist
       */
      UnitOfMeasureNotFound = 'ProductExcelServices:UnitOfMeasureNotFound',
      /**
       * Product with CustomID {0:string} cannot be found
       */
      ProductNotFound = 'ProductExcelServices:ProductNotFound',
      /**
       * Invalid quantity {quantity:number} for Unit of Measure {unitOfMeasure:string} for product {productCustomID:string}
       */
      InvalidUnitOfMeasureQuantity = 'ProductExcelServices:InvalidUnitOfMeasureQuantity',
      /**
       * Duplicate barcode {0:string} found
       */
      DuplicateBarcode = 'ProductExcelServices:DuplicateBarcode'
    }

    export const enum ProductSearchSynonyms {
      /**
       * The line {0:string} is not a valid synonym rule.
       */
      InvalidRule = 'ProductSearchSynonyms:InvalidRule'
    }

    export const enum ProductContent {
      /**
       * Property {0:string} has not been defined, a property must be defined before the content for that property can be stored.
       */
      UnknownProductPropertyType = 'ProductContent:UnknownProductPropertyType'
    }

    export const enum ProductPropertyType {
      /**
       * The value {0:string} cannot be converted to a data type of {1:ProductPropertyTypeDataTypes}
       */
      CannotConvertValueToDataType = 'ProductPropertyType:CannotConvertValueToDataType'
    }

  }


  /**
   * Get the current DB values for a product, used to update these properties with the UpdateProduct service.
   */
  export interface GetProductByID {
    /**
     * Entity type: Product
     */
    ID: number;
  }

  export interface GetProductByIDResponse {
    /**
     * Entity type: Product
     */
    ID: number;
    BackendID: string;
    CustomID: string;
    PrimitiveName: string;
    TypeID: number;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID: number;
    /**
     * Entity type: LedgerClass
     */
    LedgerClassID: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update the core properties of a Product
   */
  export interface UpdateProduct {
    /**
     * Entity type: Product
     */
    ID: number;
    BackendID?: string;
    CustomID?: string;
    PrimitiveName?: string;
    /**
     * @deprecated Use Type instead
     */
    TypeID?: number;
    Type?: EVA.Core.ProductTypes;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID?: number;
    LedgerClassID?: string;
    CommodityCode?: string;
    CountryOfOriginID?: string;
    ManufacturerID?: string;
  }

  /**
   * Replaces all search synonyms for a given LanguageID/CountryID with the provided ones.
   * Any synonyms not present in the request but that currently exist will be deleted.
   * 
   * ## Rules
   * The `Rule` must be formatted according to [what Elasticsearch accepts](https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-synonym-tokenfilter.html#_solr_synonyms):
   * 
   * - Comma-separated values: `jump, leap, hop` causes any of the matched terms to be replaced by all of the terms.
   * - Arrow notation: `britain=>england` causes the left side to be replaced by the right side.
   * 
   * To create a synonym, a `LanguageID` is required.
   */
  export interface ReplaceProductSearchSynonyms {
    Rules: string[];
    /**
     * Entity type: Language
     */
    LanguageID: string;
  }

  /**
   * Gets all currently created search synonyms for the provided LanguageID (required) and CountryID (optional).
   */
  export interface GetProductSearchSynonyms {
    /**
     * Entity type: Language
     */
    LanguageID: string;
  }

  export interface GetProductSearchSynonymsResponse {
    Result: GetProductSearchSynonymsResponse.ProductSearchSynonym[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetProductSearchSynonymsResponse {
    export interface ProductSearchSynonym {
      ID: number;
      Rule: string;
      LanguageID: string;
    }

  }

  export interface ApplyRevision {
    /**
     * Entity type: Revision
     */
    RevisionID: number;
  }

  export interface CreateRevision {
    Name?: string;
  }

  export interface CreateRevisionResponse {
    Result: CreatedRevision;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface CreatedRevision {
    /**
     * Entity type: Revision
     */
    ID: number;
    Name: string;
  }

  /**
   * Delete a revision
   * 
   * All Edits in this revision will be deleted
   */
  export interface DeleteRevision {
    /**
     * Entity type: Revision
     */
    ID: number;
  }

  export interface GetRevisionStatus {
    /**
     * Entity type: Revision
     */
    RevisionID: number;
  }

  export interface GetRevisionStatusResponse {
    Status: RevisionProgress;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface RevisionProgress {
    TotalItems: number;
    HandledItems: number;
    State: ProductCompositionProgressState;
    Progress: number;
    ValidationErrors: number;
  }

  export const enum ProductCompositionProgressState {
    None = 0,
    Composing = 1,
    PostProcessing = 2,
    Publishing = 3,
    Complete = 4
  }

  export interface ListRevisions {
    PageConfig?: EVA.Core.PageConfig<ListRevisionsFilter>;
  }

  export interface ListRevisionsFilter {
    Name?: string;
    /**
     * Entity type: Product
     */
    ProductID?: number;
    Status?: RevisionStatus;
    IncludeSystemRevisions?: boolean;
  }

  export const enum RevisionStatus {
    Open = 1,
    Applied = 2,
    Inactive = 4
  }

  export interface ListRevisionsResponse {
    Result?: EVA.Core.PagedResult<RevisionDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface RevisionDto {
    /**
     * Entity type: Revision
     */
    ID?: number;
    Name?: string;
    /**
     * Entity type: Application
     */
    ApplicationID?: number;
    Status?: RevisionStatus;
    AppliedOn?: string;
    CreatedBy?: ListRevisionUser;
    CreationTime?: string;
  }

  export interface ListRevisionUser {
    FullName?: string;
  }

  export interface CreateNewSearchDataIndex {
    DeleteOldIndex?: boolean;
  }

  /**
   * Recreate aliases on all productsearch indices. Use to recover from a state where the aliases exist, but without filters.
   */
  export interface RecreateAliases {
  }

  export interface RequestReindexSearchData {
    Script?: string;
    LanguageID?: string;
    CountryID?: string;
    ApplyProductSearchConfiguration?: boolean;
  }

  export interface RequestReindexSearchDataResponse {
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface AddReferenceDataToProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
    Data?: any;
    Name?: string;
  }

  /**
   * Creates a new Product, given at least your `PrimitiveName` and `ProductType`.
   * 
   * - [x]  Given `PrimitiveName` is a name for the product to help you recognise it, but is rarely exposed to users or customers. This property does not support localization or translations!
   * - [x]  `TaxCodeID` is an integer value indicating one of the configured TaxCodes.
   * - [x]  The `ProductType` is a flag enumeration value with one or more of the following possible values;
   * 
   *   * `0` None
   *   * `1` Stock
   *   * `2` Insurance
   *   * `4` Marketing
   *   * `8` Gift Card
   *   * `16` Service
   *   * `64` Custom Pricing
   *   * `128` External
   *   * `256` Order Costs
   *   * `512` System Generated
   *   * `1024` Product Set
   *   * `2048` Bundle Product
   *   * `16384` Configurable
   *   * `32768` Supplier Product
   *   * `65536` Template
   * 
   * Optionally, you can supply some additional information;
   * 
   * - [] `BackendID` is a number to help you identify this product. **Unique per `OrganizationUnitID` and `BackendSystemID`.**
   * - [] `BackendSystemID` is a string value to idenfity the source this product originated from - can be anything.
   * - [] `OrganizationUnitID` is the Organization Unit this product is linked to, or `null` when this is a generic EVA product.
   * - [] `CustomID` is a string value to help you identify this product, without any constraints, but indexed for optimal performance.
   * - [] `BrandID` to link it to any `Brand` entity.
   */
  export interface CreateProduct {
    PrimitiveName?: string;
    ProductType?: EVA.Core.ProductTypes;
    /**
     * Entity type: Brand
     */
    BrandID?: number;
    BackendID?: string;
    BackendSystemID?: string;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    CustomID?: string;
    /**
     * Entity type: TaxCode
     */
    TaxCodeID?: number;
    LogicalLevel?: string;
    LedgerClassID?: string;
    CommodityCode?: string;
    CountryOfOriginID?: string;
    ManufacturerID?: string;
  }

  export interface CreateProductResponse {
    /**
     * Entity type: Product
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a second chance product.
   */
  export interface CreateSecondChanceProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
    ProductName: string;
    Description: string;
    Price: number;
    BlobImageUrls?: string[];
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * @default false
     */
    NotReturnable?: boolean;
    /**
     * Specify a serial number.
     */
    SerialNumber?: string;
    /**
     * Moves stock from the original product to the second chance product.
     * @default false
     */
    MoveStock?: boolean;
    /**
     * The stock label of the original product. If unspecified, defaults to `Damaged`.
     * Entity type: StockLabel
     * @deprecated Use `SourceStockLabelID`.
     */
    StockLabelID?: number;
    /**
     * The stock label of the original product. If unspecified, defaults to `Damaged`.
     * Entity type: StockLabel
     */
    SourceStockLabelID?: number;
    /**
     * The stock label of the second chance product. If unspecified, defaults to `Sellable`.
     * Entity type: StockLabel
     */
    DestinationStockLabelID?: number;
    /**
     * Please ensure the key is a valid ProductPropertyTypes.
     */
    CustomContent?: { [key: string]: any };
  }

  export interface CreateSecondChanceProductResponse {
    /**
     * Entity type: Product
     */
    ProductID: number;
    Barcode: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Modifies given product by its `ID` for a specific `RevisionID`.
   * 
   * The `Edits` is a list of `ProductEdit` objects, that defines some `Content` and the `LanguageID`, `CountryID` and  `LayerID` it applies to. The `Content` is a Json object with key-value pairs that holds
   * product information. The keys are simple strings, but the value can be a scalar value (like an int or string), an array of scalar values or an array of objects.
   * 
   * A `Revision` is a versioning container in which one or more product modifications are buffered. The changes to the product do not apply directly, but instead are stored in this `Revision` until it is
   * ready to be published. Also see the `CreateRevision` and `ApplyRevision` services. When omitted, a new 'quick' `Revision` is created and used here.
   * 
   * A `Layer` is a hierarchical solution to building product data. Every layer has its own `Level`, where the bottom layers will be overwritten by higher layers for colliding properties. A `Layer` has a
   * `Revision`. Also see the `CreateLayer` service. When omitted, a new 'quick' `Layer` is created and used here.
   */
  export interface EditProduct {
    /**
     * Entity type: Product
     */
    ID: number;
    /**
     * Entity type: Revision
     */
    RevisionID?: number;
    Edits: ProductEdit[];
  }

  export interface ProductEdit {
    /**
     * Entity type: ContentLayer
     */
    LayerID?: number;
    Content: { [key: string]: any };
    LanguageID: string;
    CountryID: string;
  }

  /**
   * Retrieves a `Product` with detailed information per `Layer`, from the given `ID` and `RevisionID` parameter.
   * 
   * In the response, `Content` is a Json formatted object containing key-value pair data, where the keys are simple strings and the value can be a scalar value (like an int or string), an array of scalar
   * values or an array of objects.
   * 
   * The `Types` property in the response data holds meta-data information about the property keys used in the `Content` object like property name, group and (of course) data type.
   * 
   * :point_right: Use the `GetProductForQuickEditByID` service when you want to apply all published `Revision`'s and only need the compressed `Layer` version of `Content`.
   */
  export interface GetProductForEditByID {
    /**
     * Entity type: Product
     */
    ID: number;
    /**
     * Entity type: Revision
     */
    RevisionID: number;
  }

  export interface GetProductForEditByIDResponse {
    /**
     * Entity type: Product
     */
    ID: number;
    /**
     * Entity type: Catalog
     */
    CatalogID?: number;
    DisplayValue: string;
    LayersWithContent: LayerWithContentDto[];
    Types: { [key: string]: ProductPropertyTypeModel };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface LayerWithContentDto {
    /**
     * Entity type: ContentLayer
     */
    ID: number;
    Name: string;
    Level: number;
    /**
     * Entity type: Application
     */
    ApplicationID?: number;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    ArrayHandling: ContentLayerArrayHandling;
    Content: { [key: string]: any };
    Description: string;
    DisplayValue: string;
  }

  export const enum ContentLayerArrayHandling {
    Merge = 0,
    Overwrite = 1
  }

  export interface ProductPropertyTypeModel {
    ID: string;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    EditFunctionality: string;
    SearchType: ProductPropertyTypeSearchTypes;
    DataType: ProductPropertyTypeDataTypes;
    IsArray: boolean;
    Category: ProductPropertyTypeModel.CategoryModel;
    type_id: string;
    language_id: string;
    country_id: string;
    functionality: string;
    /**
     * Entity type: Application
     */
    application_id: number;
    search_type: ProductPropertyTypeSearchTypes;
    data_type: ProductPropertyTypeDataTypes;
    array: boolean;
    Intent: ProductPropertyTypeIntents;
    intent: ProductPropertyTypeIntents;
    category_id: string;
    category: ProductPropertyTypeModel.CategoryModel;
  }

  export namespace ProductPropertyTypeModel {
    export interface CategoryModel {
      ID: string;
      EditFunctionality: string;
      category_id: string;
      functionality: string;
    }

  }

  export const enum ProductPropertyTypeSearchTypes {
    None = 0,
    Keyword = 1,
    Text = 2,
    IsHidden = 4
  }

  export const enum ProductPropertyTypeDataTypes {
    None = 0,
    Integer = 1,
    Double = 2,
    Boolean = 3,
    String = 4,
    Blob = 5,
    Date = 6,
    RichText = 7
  }

  export const enum ProductPropertyTypeIntents {
    RichAttribute = 0,
    SimpleField = 1,
    RootLevelOnly = 2
  }

  /**
   * Retrieves a `Product` with detailed information, based on all currently applied `Revision`'s and the `Layer` data compressed into a single truth, from the given `ID` parameter.
   * 
   * In the response, `Content` is a Json formatted object containing key-value pair data, where the keys are simple strings and the value can be a scalar value (like an int or string), an array of scalar
   * values or an array of objects.
   * 
   * The `Types` property in the response data holds meta-data information about the property keys used in the `Content` object like property name, group and (of course) data type.
   * 
   * :point_right: Use the `GetProductForEditByID` service when you want to specify the `Revision` to apply and receive per-layer `Content`.
   */
  export interface GetProductForQuickEditByID {
    /**
     * Entity type: Product
     */
    ID: number;
  }

  export interface GetProductForQuickEditByIDResponse {
    /**
     * Entity type: Product
     */
    ID: number;
    /**
     * Entity type: Catalog
     */
    CatalogID?: number;
    DisplayValue: string;
    Content: { [key: string]: any };
    Types: { [key: string]: ProductPropertyTypeModel };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GetReferenceDataForProduct {
    /**
     * Entity type: Product
     */
    ProductID: number;
  }

  export interface GetReferenceDataForProductResponse {
    Data: { [key: string]: any };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * This service lets you create and update a set of products and their content.
   * 
   * The set is products is hierarchical in nature. For example, if you have a shirt that comes in 3 colors and 5 sizes per color, you would normally define a root product that then contains the 3 color products
   * and each color product would contain the 5 different sizes, which would be the SKU. How you define the hierarchy is up to you, it's also fine to have the 3 color products as root products and only have them
   * contain the SKUs, or to forego a hierarchy entirely and just create the SKUs, but creating the root and color products is useful for search and frontend purposes.
   * 
   * An example request of a hierarchy:
   * 
   * ```
   * {
   *   "ID": "special_shirt",
   *   "Name": "Special Shirt",
   *   "TaxCode": "High",
   *   "Variations": {
   *     "Property": "color_code",
   *     "LogicalLevel": "color",
   *     "Products": [
   *       {
   *         "ID": "special_shirt_blue",
   *         "Name": "Special Shirt - Blue",
   *         "VariationValues": [
   *           {
   *             "LanguageID": null,
   *             "Value": "BLUE"
   *           }
   *         ],
   *         "Variations": {
   *           "Property": "size_code",
   *           "LogicalLevel": "size",
   *           "Products": [
   *             {
   *               "ID": "sku_special_shirt_blue_xl",
   *               "VariationValues": [
   *                 {
   *                   "LanguageID": null,
   *                   "Value": "XL"
   *                 }
   *               ]
   *             }
   *           ]
   *         }
   *       }
   *     ]
   *   }
   * }
   * ```
   */
  export interface ImportProducts {
    /**
     * A string that identifies the system that was used to call this service. In combination with a product's ID, this is what uniquely identifies the product in EVA.
     * The SystemID must be the same for every call, if it's different from a previous call then new products will be created.
     */
    SystemID: string;
    /**
     * Determines the behavior of this service.
     */
    Type: ImportProducts.ImportType;
    /**
     * The LogicalLevel that will be assigned to the root level of a product hierarcy. If not specified a default value is used.
     * 
     * See ProductVariation.LogicalLevel for more information.
     * @default root
     */
    RootLogicalLevel?: string;
    /**
     * A string that identifies the category in which the ProductImages will be stored. It's optional, when not provided the SystemID will be used instead.
     */
    ImageBlobCategory?: string;
    /**
     * The list of products to create or update. If a product does not exist it's created and if a product with the same ID and SystemID already exists it is updated.
     */
    Products: ImportProducts.Product[];
    /**
     * By default this service only blocks for the time that it takes to store the requested modifications. After that time, some processing still needs to happen before the product is fully ready and searchable, but this happens in the background.
     * If this parameter is specified as true then this service blocks for the full duration that it takes to complete the full process.
     */
    WaitForProductComposition?: boolean;
    /**
     * When not specified, or explicitly specified as `false`, images will be downloaded while you wait and may cause this service to run for a long time. Defaults to `true`.
     */
    DownloadImagesInBackground?: boolean;
    /**
     * Custom properties used in product content can be defined by specifying their definition in this collection.
     */
    CustomPropertyTypes?: ImportProducts.ProductPropertyConfiguration[];
    /**
     * The layer on which the content will be stored. Defaults to 'ImportProducts-Base'. If you want to store the content on a different layer, you can specify it here. If the content also
     * specifies a language/country this will be combined with the provided layer name to create a layer name like '<name> <language> <country>', so the provided LayerName is not necessarily the absolute
     * value that is used for the layer, only if you leave LanguageID/CountryID as null on the content.
     */
    LayerName?: string;
  }

  export namespace ImportProducts {
    export const enum ProductPropertyDataTypes {
      String = 0,
      Int = 1,
      Double = 2,
      Bool = 3,
      Date = 4
    }

    export const enum ProductPropertyIndexTypes {
      /**
       * The property is not indexed, meaning it's not searchable.
       */
      NotIndexed = 0,
      /**
       * The property is indexed but not analyzed, which means it will only result in a hit if it's an exact match.
       */
      IndexedNotAnalyzed = 1,
      /**
       * The property is indexed and analyzed, meaning the value is broken down to its individual tokens according to the index analyzer.
       */
      IndexedAnalyzed = 2
    }

    export interface ProductPropertyConfiguration {
      /**
       * The ID of the custom property, by convention in snake_case.
       */
      ProductPropertyTypeID?: string;
      /**
       * The ID of the category the property falls into. Defaults to `default`.
       */
      CategoryID?: string;
      /**
       * Defines the data type of the property.
       */
      DataType?: ImportProducts.ProductPropertyDataTypes;
      /**
       * Defines whether and how the content of this property is searchable. Note that this is a flags enum so IndexType can both be IndexedNotAnalyzed and IndexedAnalyzed, meaning the field will be indexed in an analyzed *and* a non-analyzed manner.
       */
      IndexType?: ImportProducts.ProductPropertyIndexTypes;
      /**
       * Determines if the property allows multiple values or if it's just a single value.
       */
      IsArray?: boolean;
      /**
       * If provided, the values of this property will be copied to the provided property on the parent products.
       * This can be useful if you have a `clothing_color` property on the `color` logical level and would like to have an `available_colors` property on the root level that contains all the colors that are available for the product.
       * In that example the value of the CopyToParentProductPropertyTypeID on the `clothing_color` property would be `available_colors` and the value of the CopyToParentProductPropertyTypeID on the `available_colors` property would be null.
       * If there is no property yet with this name, it will be automatically created with the same data type as the source property.
       * 
       * If there already exists a property with this name, the data type must match the data type of the source property and the IsArray property must be true as the parent products will be given multiple values from their children.
       */
      CopyToParentProductPropertyTypeID?: string;
    }

    export interface ProductAssortment {
      AssortmentCode: string;
      ProductStatus: ImportProducts.ProductStatus;
      StartDate?: string;
      EndDate?: string;
      AnnouncementDate?: string;
      PreSaleDate?: string;
      ShipmentDate?: string;
    }

    export interface ProductRequirement {
      Name: string;
      DataType: EVA.Core.ProductRequirementDataTypes;
      OrderType?: EVA.Core.OrderTypes;
      IsArray?: boolean;
      IsRequired?: boolean;
      EnumValues?: { [key: string]: string };
      BackendID?: string;
      Handler?: string;
    }

    export interface ProductVariation {
      /**
       * The property on which the product hierarchy varies. For example 'size' or 'color'.
       */
      Property: string;
      /**
       * The LogicalLevel of a product defines the 'level' on which the product can be thought to sit in the hierarchy.
       * 
       * For example, the various different colors of a shirt can be thought to have LogicalLevel = 'color' and the actual SKU might have LogicalLevel = 'size' or 'sku'.
       * 
       * You are free to use any value, but it's recommended to keep this consistent between all products, or at least between products of the same kind, as it's a useful way to
       * structure a frontend by for example filtering on the color level and only show sizes when navigating to the product detail.
       */
      LogicalLevel: string;
      /**
       * The actual variations of the product on the specified LogicalLevel.
       */
      Products: ImportProducts.Product[];
    }

    export interface ProductVariationValue {
      /**
       * Can be left null if the variation value isn't culture dependent.
       * Entity type: Language
       */
      LanguageID?: string;
      /**
       * Can be left null if the variation value isn't culture dependent.
       * Entity type: Country
       */
      CountryID?: string;
      Value?: string;
    }

    export interface ProductContent {
      /**
       * Entity type: Language
       */
      LanguageID?: string;
      /**
       * Entity type: Country
       */
      CountryID?: string;
      MarketingDescription?: string;
      Name?: string;
      ShortDescription?: string;
      LongDescription?: string;
      /**
       * The publication status determines the visibility of the product. A product generally won't be visible to non-employee users unless it has publication status 'public'.
       */
      PublicationStatuses?: string[];
      Images?: ImportProducts.ProductImage[];
      Tags?: string[];
      UniqueSellingPointTexts?: string[];
      UniqueSellingPointBlobIDs?: string[];
      XDimension: ImportProducts.ProductDimension;
      YDimension: ImportProducts.ProductDimension;
      CustomContent?: { [key: string]: any };
    }

    export interface ProductDimension {
      PropertyName: string;
      Value: string;
    }

    export interface ProductImage {
      /**
       * The unique identifier for the image. Optional, if null then an ID is generated based on the hash of the ImageUrl
       */
      ID?: string;
      /**
       * Where can the image be downloaded? Required unless ImageData is provided.
       */
      ImageUrl?: string;
      /**
       * How the image should be stored. Usually empty.
       */
      LocationType?: string;
      /**
       * The image mime type. Optional, if null then the mime type will be guessed by the ImageUrl
       */
      MimeType?: string;
      /**
       * The human readable name of the image. Optional, if null then the name will be the ID of the image.
       */
      Name?: string;
      /**
       * The raw image data. Only required if ImageUrl is left empty.
       */
      ImageData: string;
      /**
       * The sequence number of the image, can be used to determine the display order of images and will be used to determine the primary image of the product.
       * 
       * Smaller numbers mean a higher priority.
       * 
       * By default this will be null and the sequence of the images will be determined by their ordering in the Images array.
       * 
       * The number provided here does not necessarily translate to the actual sequence number stored in EVA, only the relative order will be used. Given the sequence 1, 2, 4, 7 the actual sequence stored in EVA
       * will be 0, 1, 2, 3.
       */
      Sequence?: number;
      /**
       * If an image is specified as IsPrimaryImage = true then it will be used as the primary image on the product.
       * If there is for some reason multiple images for a product that have IsPrimaryImage set to true then the last image that have this set will become the actual primary image.
       */
      IsPrimaryImage?: boolean;
    }

    export interface ProductStatus {
      /**
       * The product will be unavailable until the pre-order date.
       */
      PreRelease?: boolean;
      /**
       * The product won't be available for endless aisle pickup from shop.
       */
      DeliveryOnly?: boolean;
      /**
       * The product will be unavailable for delivery.
       */
      DisableDelivery?: boolean;
      /**
       * The product won't be available from a shop at all.
       */
      DisablePickup?: boolean;
      /**
       * The product won't be orderable if there is no available stock.
       */
      DisableBackorder?: boolean;
      /**
       * Indicates the product won't be back in store and all current stock is all there is going to be.
       */
      UseUp?: boolean;
      /**
       * Indicates the product isn't sellable.
       */
      NonSellable?: boolean;
    }

    export interface UnitBarcode {
      /**
       * The barcode of the product. Must be unique.
       */
      Barcode: string;
      /**
       * The quantity of the product (in the given unit of measure) that the barcode represents.
       */
      Quantity: number;
      /**
       * The name of the unit of measure to use for this barcode. If not specified, 'Each' will be used. Must be created beforehand.
       */
      UnitOfMeasureName?: string;
    }

    export interface ProductType {
      /**
       * A normal stock-keeping product. This will be the default if not specified.
       */
      Stock?: boolean;
      /**
       * A giftcard product.
       */
      GiftCard?: boolean;
      /**
       * A non-physical product that represents a service of some sort.
       */
      Service?: boolean;
      /**
       * Indicates the product is of a bundle type.
       */
      BundleProduct?: boolean;
      /**
       * Indicates the product is of a subscription type.
       */
      SubscriptionProduct?: boolean;
      /**
       * Indicates if custom pricing on the product is allowed.
       */
      AllowCustomPricing?: boolean;
      /**
       * Indicates if the product is an insurance product.
       */
      Insurance?: boolean;
    }

    export const enum ImportType {
      /**
       * A normal import; creates and updates the product structure and stores content, if present.
       */
      Normal = 0,
      /**
       * Only imports content, does not create or update the products themselves. It's required that the products already exist.
       */
      ContentOnly = 1,
      /**
       * A dry-run, does not make any modifications, only returns a representation of the product structure that would be generated in the response.
       */
      PreviewOnly = 2
    }

    export interface ProductBase {
      /**
       * The unique identifier for the product.
       */
      ID: string;
      /**
       * The culture independent name of the product by which it can be recognized even if it otherwise does not have any content. Required unless Type = ContentOnly.
       */
      Name?: string;
      /**
       * The custom identifier for the product.
       */
      CustomID?: string;
      /**
       * The (optional) brand of the product. Only has to be specified on the root level of a hierarchy.
       */
      Brand?: string;
      /**
       * The (optional) ledger class ID of the product. Only has to be specified on the root level of a hierarchy.
       */
      LedgerClassID?: string;
      /**
       * An (optional) list of barcodes for this product. A barcode should be globally unique and any duplicate barcodes will result in an error.
       */
      Barcodes?: string[];
      /**
       * An (optional) list of barcodes with the associated quantity and unit of measure for this product. A barcode should be globally unique and any duplicate barcodes will result in an error.
       */
      UnitBarcodes?: ImportProducts.UnitBarcode[];
      /**
       * Defines what kind of product it is. If the product is part of a hierarchy, this is only relevant for the SKU level, all other levels will have type Configurable.
       */
      Type?: ImportProducts.ProductType;
      /**
       * Defines the status of a product.
       */
      Status?: ImportProducts.ProductStatus;
      /**
       * The per-language content of the product.
       * 
       * A small set of default properties has been defined, such as Name and MarketingDescription. Additional content can be defined inside `CustomContent`, which is a key-value container
       * where the key is the name of a property and value should be a single scalar value (string, number, boolean or null) or an array of values.
       * 
       * If LanguageID is left null, this will be the fallback content for languages that have no content of their own.
       * For example, you may offer a French website but you only have English product content, if you specify your English content with LanguageID = null
       * then products on the French website will have the English content.
       * 
       * In general, it's a good idea to choose a language that will serve as the default fallback language and to not specify LanguageID for that language's content so it will function as the fallback content.
       */
      Content?: ImportProducts.ProductContent[];
      /**
       * Set to `True` to delete the product.
       */
      IsDeleted?: boolean;
      /**
       * If specified this will add the product to those assortments.
       */
      Assortments?: ImportProducts.ProductAssortment[];
      /**
       * The country of origin for the product. Value must conform to the 2-letter country code as defined by ISO 3166-1.
       */
      CountryOfOriginID?: string;
      /**
       * Optional field that can be used to store the manufacturer's identifier for this product.
       */
      ManufacturerID?: string;
    }

    export interface Product {
      /**
       * Defines the variations hierarchy of the product.
       */
      Variations?: ImportProducts.ProductVariation;
      StockProducts: ImportProducts.ProductBase[];
      /**
       * Optional field to set up the product requirements on a product.
       */
      ProductRequirements?: ImportProducts.ProductRequirement[];
      /**
       * Defines the per-language value of the variation property for this product. For example, if the variation property is `color` then the value could be 'red' or 'blue'.
       * 
       * If the variation value isn't language sensitive then the LanguageID should be left null. If there isn't an item where LanguageID is null, all languages for which this product has content must have
       * a value for the variation property.
       */
      VariationValues?: ImportProducts.ProductVariationValue[];
      /**
       * In case a type GiftCard product is uploaded, its `GiftCardType` or `GiftCardConfigurationID` is mandatory to connect to its provider.
       * Entity type: GiftCardConfiguration
       */
      GiftCardConfigurationID?: number;
      /**
       * In case a type GiftCard product is uploaded, its `GiftCardType` or `GiftCardConfigurationID` is mandatory to connect to its provider.
       */
      GiftCardType?: string;
      /**
       * In case a type GiftCard product is uploaded, this defines if the product is digital, so it will not require a serialnumber during checkout.
       */
      GiftCardIsDigital?: boolean;
      /**
       * In case a type GiftCard product is uploaded, this defines the optional data for configuration.
       */
      GiftCardData?: any;
      /**
       * Optional field to indicate a serialnumber will be required when selling this product.
       */
      RequireSerialNumberForSale?: boolean;
      /**
       * Optional field to indicate what kind of serial number requirements apply to this product.
       * Entity type: SerialNumberConfiguration
       */
      SerialNumberConfigurationID?: number;
      /**
       * Determines whether or not any images set on a parent product will inherit down to its children. This defaults to true.
       * Can be useful to give the root product of a hierarchy an ensemble of the available colors, without inheriting these images to the children.
       */
      ImagesWillBeInheritedByChildren?: boolean;
      /**
       * The TaxCode determines how sales tax applies to this product. This must refer to an existing TaxCode in EVA, if it doesn't exist yet an error is returned.
       * 
       * Required unless Type = ContentOnly.
       * 
       * The string expected here is the Name property of the tax code, so 'High' for TaxCode High.
       * 
       * EVA defines the following default tax codes:
       * 
       * - High
       * - Intermediate
       * - Low
       * - Zero
       * - Exempt
       * 
       * In a hierarchy, the TaxCode only has to be specified for the root level; all products part of the hierarchy will always have the same TaxCode.
       */
      TaxCode?: string;
      /**
       * The CommodityCode is used for customs declarations and product tariffs. Can be used to store the HS code of the product.
       */
      CommodityCode?: string;
      /**
       * The unique identifier for the product.
       */
      ID: string;
      /**
       * The culture independent name of the product by which it can be recognized even if it otherwise does not have any content. Required unless Type = ContentOnly.
       */
      Name?: string;
      /**
       * The custom identifier for the product.
       */
      CustomID?: string;
      /**
       * The (optional) brand of the product. Only has to be specified on the root level of a hierarchy.
       */
      Brand?: string;
      /**
       * The (optional) ledger class ID of the product. Only has to be specified on the root level of a hierarchy.
       */
      LedgerClassID?: string;
      /**
       * An (optional) list of barcodes for this product. A barcode should be globally unique and any duplicate barcodes will result in an error.
       */
      Barcodes?: string[];
      /**
       * An (optional) list of barcodes with the associated quantity and unit of measure for this product. A barcode should be globally unique and any duplicate barcodes will result in an error.
       */
      UnitBarcodes?: ImportProducts.UnitBarcode[];
      /**
       * Defines what kind of product it is. If the product is part of a hierarchy, this is only relevant for the SKU level, all other levels will have type Configurable.
       */
      Type?: ImportProducts.ProductType;
      /**
       * Defines the status of a product.
       */
      Status?: ImportProducts.ProductStatus;
      /**
       * The per-language content of the product.
       * 
       * A small set of default properties has been defined, such as Name and MarketingDescription. Additional content can be defined inside `CustomContent`, which is a key-value container
       * where the key is the name of a property and value should be a single scalar value (string, number, boolean or null) or an array of values.
       * 
       * If LanguageID is left null, this will be the fallback content for languages that have no content of their own.
       * For example, you may offer a French website but you only have English product content, if you specify your English content with LanguageID = null
       * then products on the French website will have the English content.
       * 
       * In general, it's a good idea to choose a language that will serve as the default fallback language and to not specify LanguageID for that language's content so it will function as the fallback content.
       */
      Content?: ImportProducts.ProductContent[];
      /**
       * Set to `True` to delete the product.
       */
      IsDeleted?: boolean;
      /**
       * If specified this will add the product to those assortments.
       */
      Assortments?: ImportProducts.ProductAssortment[];
      /**
       * The country of origin for the product. Value must conform to the 2-letter country code as defined by ISO 3166-1.
       */
      CountryOfOriginID?: string;
      /**
       * Optional field that can be used to store the manufacturer's identifier for this product.
       */
      ManufacturerID?: string;
    }

  }

  export interface ImportProductsResponse {
    /**
     * The EVA IDs of the products were touched by this call.
     * Entity type: Product
     */
    UpdatedProductIDs: number[];
    /**
     * The EVA IDs of the products that were newly created by this call.
     * Entity type: Product
     */
    CreatedProductIDs: number[];
    /**
     * If the Type of the request was PreviewOnly this property will contain the product structure that would be generated.
     */
    PreviewResult: string;
    /**
     * Contains an entry for every product mapping the input string ID to its internal EVA integer ID.
     */
    ProductMap: ProductMapItem[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ProductMapItem {
    BackendID: string;
    /**
     * Entity type: Product
     */
    ID: number;
  }

  /**
   * Create a new product capacity plan, which limits the stock of a product based on the capacity of production.
   */
  export interface CreateProductCapacityPlan {
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID?: number;
    Name?: string;
    Description?: string;
    ProductCapacityTimeFrame?: EVA.Core.ProductCapacityTimeFrame;
    /**
     * Min: 0
     */
    Capacity?: number;
    /**
     * Range: 1-14
     */
    AvailabilityCalculationCutOffInDays?: number;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    ProductSearchFilters?: { [key: string]: EVA.Core.FilterModel };
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    OverwriteExistingProductCapacityPlans?: boolean;
  }

  export interface CreateProductCapacityPlanResponse {
    /**
     * Entity type: ProductCapacityPlan
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update a product capacity plan.
   * When the product capacity plan is changed from static to dynamic, and this is as requested, the service requires the `AllowStaticToDynamicTypeChange` to be set to true.
   * If `AllowStaticToDynamicTypeChange` is false, the service will return an error when the product capacity plan switches from static to dynamic.
   */
  export interface UpdateProductCapacityPlan {
    /**
     * Entity type: ProductCapacityPlan
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID: number;
    Name: string;
    Description?: string;
    ProductCapacityTimeFrame: EVA.Core.ProductCapacityTimeFrame;
    /**
     * Min: 0
     */
    Capacity: number;
    /**
     * Min: 1
     */
    AvailabilityCalculationCutOffInDays?: number;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    ProductSearchFilters?: { [key: string]: EVA.Core.FilterModel };
    AllowStaticToDynamicTypeChange?: boolean;
  }

  /**
   * Deletes a product capacity plan.
   */
  export interface DeleteProductCapacityPlan {
    /**
     * Entity type: ProductCapacityPlan
     */
    ID: number;
  }

  /**
   * Set a product capacity plan exception. The capacity is prioritized as follows;
   * - Exception based on date (time is stripped from the given datetime).
   * - Exception based on day of week.
   * - Default product capacity plan capacity
   */
  export interface SetProductCapacityPlanException {
    /**
     * Entity type: ProductCapacityPlan
     */
    ID: number;
    DayOfWeek?: EVA.Core.DayOfWeek;
    Date?: string;
    /**
     * Min: 0
     */
    Capacity: number;
  }

  /**
   * Deletes a product capacity plan exception
   */
  export interface DeleteProductCapacityPlanException {
    /**
     * Entity type: ProductCapacityPlan
     */
    ID: number;
    DayOfWeek?: EVA.Core.DayOfWeek;
    Date?: string;
  }

  /**
   * Add a product to product capacity plan. This is only allowed on static product capacity plans. A product can not be in more then one static product capacity plan per supplier.
   */
  export interface AddProductsToProductCapacityPlan {
    /**
     * Entity type: ProductCapacityPlan
     */
    ID: number;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    OverwriteExistingProductCapacityPlans: boolean;
  }

  /**
   * Remove a product to product capacity plan. This is only allowed on static product capacity plans.
   */
  export interface RemoveProductsFromProductCapacityPlan {
    /**
     * Entity type: ProductCapacityPlan
     */
    ID: number;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
  }

  export interface ListProductCapacityPlans {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ProductCapacityPlanFilter>;
  }

  export interface ListProductCapacityPlansResponse {
    Result?: EVA.Core.PagedResult<ListProductCapacityPlansResponse.Data>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListProductCapacityPlansResponse {
    export interface Data {
      /**
       * Entity type: ProductCapacityPlan
       */
      ID: number;
      /**
       * Entity type: OrganizationUnit
       */
      SupplierOrganizationUnitID: number;
      SupplierOrganizationUnitName: string;
      Name: string;
      Description?: string;
      ProductCapacityTimeFrame: EVA.Core.ProductCapacityTimeFrame;
      Capacity: number;
      AvailabilityCalculationCutOffInDays?: number;
      IsDynamic: boolean;
    }

  }

  /**
   * Get ProductCapacityPlan by the given ID
   */
  export interface GetProductCapacityPlanByID {
    /**
     * Entity type: ProductCapacityPlan
     */
    ID: number;
  }

  export interface GetProductCapacityPlanByIDResponse {
    /**
     * Entity type: ProductCapacityPlan
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitID: number;
    SupplierOrganizationUnitName: string;
    Name: string;
    Description?: string;
    IsDynamic: boolean;
    ProductCapacityTimeFrame: EVA.Core.ProductCapacityTimeFrame;
    Capacity: number;
    AvailabilityCalculationCutOffInDays?: number;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    ProductSearchFilters: { [key: string]: EVA.Core.FilterModel };
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    Exceptions: GetProductCapacityPlanByIDResponse.ProductCapacityPlanException[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetProductCapacityPlanByIDResponse {
    export interface ProductCapacityPlanException {
      DayOfWeek?: EVA.Core.DayOfWeek;
      Date?: string;
      Capacity: number;
    }

  }

  /**
   * Get ProductCapacityPlans by the given ProductID
   */
  export interface GetProductCapacityPlansByProductID {
    /**
     * Entity type: Product
     */
    ProductID: number;
  }

  export interface GetProductCapacityPlansByProductIDResponse {
    ProductCapacityPlans: GetProductCapacityPlansByProductIDResponse.Plan[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetProductCapacityPlansByProductIDResponse {
    export interface Plan {
      /**
       * Entity type: ProductCapacityPlan
       */
      ID: number;
      /**
       * Entity type: OrganizationUnit
       */
      SupplierOrganizationUnitID: number;
      Name: string;
      Description?: string;
      IsDynamic: boolean;
      ProductCapacityTimeFrame: EVA.Core.ProductCapacityTimeFrame;
      Capacity: number;
      AvailabilityCalculationCutOffInDays?: number;
      IsActive: boolean;
    }

  }

  export interface UploadProductExcel {
    Data: string;
  }

  export interface UploadProductExcelResponse {
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ExportProductBaseExcel {
    Filters?: { [key: string]: EVA.Core.FilterModel };
  }

  export interface GenerateProductExcelSample {
  }

  export interface UploadProductContentExcel {
    LanguageID?: string;
    Data: string;
  }

  export interface UploadProductContentExcelResponse {
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GenerateProductContentExcelSample {
  }

  export interface ExportProductContentExcel {
    Query?: string;
    Filters?: { [key: string]: EVA.Core.FilterModel };
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
  }

  export interface UploadProductBarcodeExcel {
    Data: string;
  }

  export interface UploadProductBarcodeExcelResponse {
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GenerateProductBarcodeExcelSample {
  }

  /**
   * Create a new ProductRelationType.
   */
  export interface CreateProductRelationType {
    /**
     * This is the primary name the relation. For example; if primary name is 'Blocks', the secondary name could be something in the lines of 'Blocked by'.
     */
    PrimaryName: string;
    /**
     * This is the secondary name the relation. For example; if primary name is 'Blocks', the secondary name could be something in the lines of 'Blocked by'.
     */
    SecondaryName?: string;
    BackendID?: string;
    /**
     * The direction of the relation. This can either be;
     * Unidirectional; one-way relation. For example 'parent-child' or 'replaced by'
     * Bidirectional; two-way relation. For example 'maybe your also intrested in' or 'others also bought'
     * Group; collective relation which allows for many products as part of a group. For example 'all products that are blue' or 'all products from summer-2022'. This type does not accept a StockRelationType.
     */
    Direction: EVA.Core.ProductRelationDirection;
    /**
     * Indicates which stock relation type the relation has. In most cases this will be 'None'. The following options are available:
     * None; No stock relation
     * Replacing; When the PrimaryProduct is no longer in stock, the system can automaticly use the RelatedProduct as it's replacement (or vice versa if `Direction` is set to `Bidirectional`).
     */
    StockRelationType: EVA.Core.StockRelationType;
    /**
     * You can create dynamic bi- or uni directional relations by defining a `DynamicRelationProductID` in combination with a `ProductSearchTemplateID` or `ProductSearchFilters`.
     * By setting the `UseDynamicRelationProductAsRelatedProduct` to false (default), the `DynamicRelationProductID` will be considered as the primary product and the result from the `ProductSearchTemplateID` or `ProductSearchFilters` will be considered as related products
     * By setting the `UseDynamicRelationProductAsRelatedProduct` to true , the result from the `ProductSearchTemplateID` or `ProductSearchFilters` will be considered as primary products and the `DynamicRelationProductID` will be considered as the related product
     * Entity type: Product
     */
    DynamicRelationProductID?: number;
    UseDynamicRelationProductAsRelatedProduct?: boolean;
    /**
     * Only available when Direction is set to `Group`.
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    /**
     * Only available when Direction is set to `Group`.
     */
    ProductSearchFilters?: { [key: string]: EVA.Core.FilterModel };
    Relations?: CreateProductRelationType.Relation[];
  }

  export namespace CreateProductRelationType {
    export interface Relation {
      /**
       * Entity type: Product
       */
      PrimaryProductID: number;
      /**
       * Entity type: Product
       */
      RelatedProductID?: number;
      Sequence?: number;
    }

  }

  export interface CreateProductRelationTypeResponse {
    /**
     * Entity type: ProductRelationType
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update the the ProductRelationType.
   */
  export interface UpdateProductRelationType {
    /**
     * Entity type: ProductRelationType
     */
    ID: number;
    BackendID?: string;
    /**
     * This is the primary name the relation. For example; if primary name is 'Blocks', the secondary name could be something in the lines of 'Blocked by'.
     */
    PrimaryName: string;
    /**
     * This is the secondary name the relation. For example; if primary name is 'Blocks', the secondary name could be something in the lines of 'Blocked by'.
     */
    SecondaryName?: string;
    /**
     * Entity type: Product
     */
    DynamicRelationProductID?: number;
    UseDynamicRelationProductAsRelatedProduct?: boolean;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    ProductSearchFilters?: { [key: string]: EVA.Core.FilterModel };
    AllowTypeChange?: boolean;
  }

  /**
   * Deletes the ProductRelationType.
   */
  export interface DeleteProductRelationType {
    /**
     * Entity type: ProductRelationType
     */
    ID: number;
  }

  /**
   * List the ProductRelationTypes.
   */
  export interface ListProductRelationTypes {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ProductRelationTypesFilter>;
  }

  export interface ListProductRelationTypesResponse {
    Result?: EVA.Core.PagedResult<ListProductRelationTypesResponse.Data>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListProductRelationTypesResponse {
    export interface Data {
      /**
       * Entity type: ProductRelationType
       */
      ID: number;
      PrimaryName: string;
      SecondaryName?: string;
      BackendID: string;
      Direction: EVA.Core.ProductRelationDirection;
      StockRelationType: EVA.Core.StockRelationType;
      IsDynamic: boolean;
      /**
       * Entity type: Product
       */
      DynamicRelationProductID?: number;
      UseDynamicRelationProductAsRelatedProduct: boolean;
    }

  }

  /**
   * Get ProductRelationType by ID
   */
  export interface GetProductRelationTypeByID {
    /**
     * Entity type: ProductRelationType
     */
    ID: number;
  }

  export interface GetProductRelationTypeByIDResponse {
    /**
     * Entity type: ProductRelationType
     */
    ID: number;
    PrimaryName: string;
    SecondaryName?: string;
    BackendID: string;
    Direction: EVA.Core.ProductRelationDirection;
    StockRelationType: EVA.Core.StockRelationType;
    IsDynamic: boolean;
    /**
     * Entity type: Product
     */
    DynamicRelationProductID?: number;
    UseDynamicRelationProductAsRelatedProduct: boolean;
    /**
     * Entity type: ProductSearchTemplate
     */
    ProductSearchTemplateID?: number;
    ProductSearchFilters?: { [key: string]: EVA.Core.FilterModel };
    Relations: GetProductRelationTypeByIDResponse.Relation[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetProductRelationTypeByIDResponse {
    export interface Relation {
      /**
       * Entity type: ProductRelation
       */
      ID?: number;
      /**
       * Entity type: Product
       */
      PrimaryProductIDs?: number[];
      /**
       * Entity type: Product
       */
      RelatedProductIDs?: number[];
      Sequence?: number;
    }

  }

  /**
   * List all product relations for the given Product and (optional) ProductRelationType
   */
  export interface ListProductRelations {
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: ProductRelationType
     */
    ProductRelationTypeID?: number;
  }

  export interface ListProductRelationsResponse {
    RelationTypeCollections: ListProductRelationsResponse.RelationTypeCollection[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListProductRelationsResponse {
    export interface RelationTypeCollection {
      /**
       * Entity type: ProductRelationType
       */
      ID: number;
      PrimaryName: string;
      SecondaryName?: string;
      BackendID: string;
      Direction: EVA.Core.ProductRelationDirection;
      StockRelationType: EVA.Core.StockRelationType;
      IsDynamic: boolean;
      /**
       * Entity type: Product
       */
      DynamicRelationProductID?: number;
      UseDynamicRelationProductAsRelatedProduct: boolean;
      Relations: ListProductRelationsResponse.Relation[];
    }

    export interface Relation {
      /**
       * Entity type: ProductRelation
       */
      ID?: number;
      /**
       * Entity type: Product
       */
      PrimaryProductIDs?: number[];
      /**
       * Entity type: Product
       */
      RelatedProductIDs?: number[];
      Sequence?: number;
    }

  }

  /**
   * Create a relation of the given ProductRelationType for the given ProductRelations
   */
  export interface AddProductRelations {
    /**
     * Entity type: ProductRelationType
     */
    ID: number;
    Relations?: AddProductRelations.ProductRelation[];
  }

  export namespace AddProductRelations {
    export interface ProductRelation {
      /**
       * Entity type: Product
       */
      PrimaryProductID: number;
      /**
       * Entity type: Product
       */
      RelatedProductID?: number;
      Sequence?: number;
    }

  }

  /**
   * Update a relation of the given ProductRelationType for the given ProductRelations
   */
  export interface UpdateProductRelations {
    /**
     * Entity type: ProductRelationType
     */
    ID: number;
    Relations?: UpdateProductRelations.ProductRelation[];
  }

  export namespace UpdateProductRelations {
    export interface ProductRelation {
      /**
       * Entity type: Product
       */
      PrimaryProductID: number;
      /**
       * Entity type: Product
       */
      RelatedProductID?: number;
      Sequence?: number;
    }

  }

  /**
   * Remove the given ProductRelations by the ProductRelationID
   */
  export interface RemoveProductRelationsByID {
    /**
     * Entity type: ProductRelation
     */
    IDs: number[];
  }

  /**
   * Remove the given ProductRelations by the ProductRelationID
   */
  export interface RemoveProductRelationsByProductID {
    /**
     * Entity type: Product
     */
    IDs: number[];
    /**
     * Entity type: ProductRelationType
     */
    ProductRelationTypeID?: number;
  }

  /**
   * Search product property types
   */
  export interface SearchProductPropertyTypes {
    Query?: string;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface SearchProductPropertyTypesResponse {
    Result?: EVA.Core.PagedResult<ProductPropertyTypeModel>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List product property types
   */
  export interface ListProductPropertyTypes {
    PageConfig?: EVA.Core.PageConfig<ListProductPropertyTypesFilter>;
  }

  export interface ListProductPropertyTypesFilter {
    /**
     * Fuzzy search for ID of the property
     * Entity type: ProductPropertyType
     */
    ID?: string;
    /**
     * Non-fuzzy search for properties for the given ID's
     * Entity type: ProductPropertyType
     */
    IDs?: string[];
    /**
     * Entity type: ProductPropertyCategory
     */
    CategoryID?: string;
    DataTypeID?: ProductPropertyTypeDataTypes;
    DataType?: ProductPropertyTypeDataTypes;
    Intent?: ProductPropertyTypeIntents;
    SearchType?: ProductPropertyTypeSearchTypes;
    SearchTypeMatchingMethod?: ProductPropertyTypeSearchTypeMatchingMethod;
    IsArray?: boolean;
    IsEnum?: boolean;
    InheritanceType?: ProductPropertyTypeInheritanceTypes;
    Options?: ProductPropertyTypeOptions;
  }

  export const enum ProductPropertyTypeSearchTypeMatchingMethod {
    MatchesAll = 0,
    MatchesAtLeastOne = 1
  }

  export const enum ProductPropertyTypeInheritanceTypes {
    NormalInheritance = 0,
    NoInheritance = 1
  }

  export const enum ProductPropertyTypeOptions {
    None = 0,
    AlphabeticallySortable = 1
  }

  export interface ListProductPropertyTypesResponse {
    Result?: EVA.Core.PagedResult<ListProductPropertyTypesDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListProductPropertyTypesDto {
    /**
     * Entity type: ProductPropertyType
     */
    ID: string;
    DisplayName: string;
    /**
     * Entity type: ProductPropertyCategory
     */
    CategoryID: string;
    CategoryDisplayName: string;
    DataType: ProductPropertyTypeDataTypes;
    Intent: ProductPropertyTypeIntents;
    SearchType: ProductPropertyTypeSearchTypes;
    InheritanceType: ProductPropertyTypeInheritanceTypes;
    Options: ProductPropertyTypeOptions;
  }

  /**
   * Get product property type
   */
  export interface GetProductPropertyTypeByID {
    ID: string;
    /**
     * Entity type: Revision
     */
    RevisionID?: number;
  }

  export interface GetProductPropertyTypeByIDResponse {
    /**
     * Entity type: ProductPropertyType
     */
    ID: string;
    /**
     * Entity type: Catalog
     */
    CatalogID?: number;
    LayersWithContent?: LayerWithContentDto[];
    /**
     * Entity type: ProductPropertyCategory
     */
    CategoryID: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get available enum values for product property type
   */
  export interface GetAvailableEnumValuesForProductPropertyType {
    TypeID?: string;
  }

  export interface GetAvailableEnumValuesForProductPropertyTypeResponse {
    /**
     * Entity type: ProductPropertyType
     */
    Values: { [key: number]: string };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create a new ProductPropertyType
   */
  export interface CreateProductPropertyType {
    TypeID: string;
    CategoryID: string;
    DataType: ProductPropertyTypeDataTypes;
    SearchType: ProductPropertyTypeSearchTypes;
    Options?: ProductPropertyTypeOptions;
    IsArray?: boolean;
    IsEnum?: boolean;
    EditFunctionality?: string;
    CopyToParentProductPropertyTypeID?: string;
  }

  /**
   * Update a ProductPropertyType
   * 
   * The SearchType or Options can be changed
   * 
   * For the Edits there is a specific set of properties that can be set:
   * - display_name
   * - name
   * - unit_of_measure
   */
  export interface EditProductPropertyType {
    /**
     * Entity type: ProductPropertyType
     */
    ID?: string;
    Edits?: ProductPropertyTypeEdit[];
    SearchType?: ProductPropertyTypeSearchTypes;
    Options?: ProductPropertyTypeOptions;
    CopyToParentProductPropertyTypeID?: string;
  }

  export interface ProductPropertyTypeEdit {
    /**
     * Entity type: ContentLayer
     */
    LayerID?: number;
    Content?: { [key: string]: any };
  }

  export interface EditProductPropertyTypeResponse {
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Deletes the given product property type based on its identifier. This is irreversible and will cause products that are composed after this action to no longer have the property.
   */
  export interface DeleteProductPropertyType {
    ID?: string;
  }

  /**
   * Get product property type enum value
   */
  export interface GetProductPropertyTypeEnumValueByID {
    /**
     * Entity type: ProductPropertyTypeEnumValue
     */
    ID: number;
  }

  export interface GetProductPropertyTypeEnumValueByIDResponse {
    /**
     * Entity type: ProductPropertyTypeEnumValue
     */
    ID: number;
    ProductPropertyTypeID: string;
    Identifier: number;
    Value: string;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Create product property type enum value
   */
  export interface CreateProductPropertyTypeEnumValue {
    ProductPropertyTypeID: string;
    Identifier: number;
    Value?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
  }

  export interface CreateProductPropertyTypeEnumValueResponse {
    /**
     * Entity type: ProductPropertyTypeEnumValue
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Update product property type enum value
   */
  export interface UpdateProductPropertyTypeEnumValue {
    /**
     * Entity type: ProductPropertyTypeEnumValue
     */
    ID: number;
    Identifier: number;
    Value?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
  }

  /**
   * Delete product property type enum value
   */
  export interface DeleteProductPropertyTypeEnumValue {
    /**
     * Entity type: ProductPropertyTypeEnumValue
     */
    ID: number;
  }

  /**
   * List product property type enum values
   */
  export interface ListProductPropertyTypeEnumValues {
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListProductPropertyTypeEnumValuesResponse {
    Result?: EVA.Core.PagedResult<ListProductPropertyTypeEnumValuesResponse.ProductPropertyTypeEnumValueDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListProductPropertyTypeEnumValuesResponse {
    export interface ProductPropertyTypeEnumValueDto {
      /**
       * Entity type: ProductPropertyTypeEnumValue
       */
      ID: number;
      ProductPropertyTypeID: string;
      Identifier: number;
      Value: string;
      LanguageID: string;
      CountryID: string;
    }

  }

  export interface CreateProductPropertyCategory {
    CategoryID?: string;
    EditFunctionality?: string;
  }

  export interface CreateProductPropertyCategoryResponse {
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface EditProductPropertyCategory {
    ID?: string;
    Edits?: ProductPropertyCategoryEdit[];
  }

  export interface ProductPropertyCategoryEdit {
    /**
     * Entity type: ContentLayer
     */
    LayerID: number;
    Content: { [key: string]: any };
  }

  export interface EditProductPropertyCategoryResponse {
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface GetProductPropertyCategoryByID {
    ID?: string;
    /**
     * Entity type: Revision
     */
    RevisionID: number;
  }

  export interface GetProductPropertyCategoryByIDResponse {
    ID: string;
    /**
     * Entity type: Catalog
     */
    CatalogID?: number;
    LayersWithContent: LayerWithContentDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListProductPropertyCategories {
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListProductPropertyCategoriesResponse {
    Result?: EVA.Core.PagedResult<ListProductPropertyCategoriesDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListProductPropertyCategoriesDto {
    ID: string;
    DisplayName: string;
  }

  /**
   * Returns the AssortmentContentCultures
   */
  export interface GetAssortmentContentCultures {
  }

  export interface GetAssortmentContentCulturesResponse {
    ContentCultures: GetAssortmentContentCulturesResponse.AssortmentContentCulture[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAssortmentContentCulturesResponse {
    export interface AssortmentContentCulture {
      /**
       * Entity type: Assortment
       */
      AssortmentID: number;
      AssortmentName: string;
      /**
       * Entity type: Culture
       */
      CultureID: string;
      /**
       * Entity type: Language
       */
      LanguageID: string;
      /**
       * Entity type: Country
       */
      CountryID: string;
    }

  }

  /**
   * Creates a new AssortmentContentCulture.
   * If it already exists, nothing will be done.
   */
  export interface CreateAssortmentContentCulture {
    /**
     * Entity type: Assortment
     */
    AssortmentID: number;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
  }

  /**
   * Deletes an existing AssortmentContentCulture. If there are any existing mappings to this ContentCulture, they will also be deleted.
   */
  export interface DeleteAssortmentContentCulture {
    /**
     * Entity type: Assortment
     */
    AssortmentID: number;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
  }

  /**
   * Returns the current ContentCultureMapping.
   */
  export interface ListContentCultureMapping {
    PageConfig?: EVA.Core.PageConfig<ContentCultureMappingFilter>;
  }

  export interface ContentCultureMappingFilter {
    /**
     * Entity type: Language
     */
    SourceLanguageID: string;
    /**
     * Entity type: Country
     */
    SourceCountryID: string;
    /**
     * Entity type: Language
     */
    ContentLanguageID: string;
    /**
     * Entity type: Country
     */
    ContentCountryID: string;
    /**
     * Entity type: Assortment
     */
    ContentAssortmentID?: number;
  }

  export interface ListContentCultureMappingResponse {
    Result?: EVA.Core.PagedResult<ListContentCultureMappingResponse.ContentCultureMappingDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListContentCultureMappingResponse {
    export interface ContentCultureMappingDto {
      /**
       * Entity type: ContentCultureMapping
       */
      ID: number;
      /**
       * Entity type: Assortment
       */
      ContentAssortmentID: number;
      /**
       * Entity type: Language
       */
      SourceLanguageID: string;
      /**
       * Entity type: Country
       */
      SourceCountryID: string;
      /**
       * Entity type: Culture
       */
      ContentCultureID: string;
      /**
       * Entity type: Language
       */
      ContentLanguageID: string;
      /**
       * Entity type: Country
       */
      ContentCountryID: string;
    }

  }

  /**
   * Creates a new ContentCultureMapping for the current application.
   */
  export interface CreateContentCultureMapping {
    /**
     * Entity type: Assortment
     */
    AssortmentID: number;
    SourceLanguageID?: string;
    SourceCountryID?: string;
    ContentLanguageID: string;
    ContentCountryID: string;
  }

  /**
   * Deletes an existing ContentCultureMapping.
   */
  export interface DeleteContentCultureMapping {
    /**
     * Entity type: ContentCultureMapping
     */
    ID: number;
  }

  export interface ListApplicationCultures {
  }

  export interface ListApplicationCulturesResponse {
    Result: ListApplicationContentCulture[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListApplicationContentCulture {
    /**
     * Entity type: Application
     */
    ApplicationID: number;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    Culture: string;
  }

  export interface CreateLayer {
    /**
     * Entity type: Application
     */
    ApplicationID?: number;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    Description?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    Level: number;
    Name?: string;
    ArrayHandling?: ContentLayerArrayHandling;
  }

  export interface CreateLayerResponse {
    Result: CreatedLayer;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface CreatedLayer {
    /**
     * Entity type: ContentLayer
     */
    ID: number;
    Name: string;
    /**
     * Entity type: Application
     */
    ApplicationID?: number;
    Description: string;
    Level: number;
    /**
     * Entity type: Country
     */
    CountryID: string;
    ArrayHandling: ContentLayerArrayHandling;
  }

  export interface GetLayerByID {
    /**
     * Entity type: ContentLayer
     */
    ID: number;
  }

  export interface GetLayerByIDResponse {
    Layer: LayerDto;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface LayerDto {
    /**
     * Entity type: ContentLayer
     */
    ID: number;
    Description: string;
    Level: number;
    /**
     * Entity type: Application
     */
    ApplicationID?: number;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Catalog
     */
    CatalogID?: number;
    Name: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    Type: ContentLayerTypes;
    ArrayHandling: ContentLayerArrayHandling;
  }

  export const enum ContentLayerTypes {
    UserLayer = 0,
    SystemLayer = 1
  }

  export interface ListLayers {
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListLayersResponse {
    Result?: EVA.Core.PagedResult<LayerDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface UpdateLayer {
    /**
     * Entity type: ContentLayer
     */
    ID: number;
    Name?: string;
    Description?: string;
    Level: number;
    ArrayHandling?: ContentLayerArrayHandling;
  }

  /**
   * Creates a search strategy for the provided LanguageID and CountryID (both are optional).
   * 
   * All parts of the `Strategy` field are optional.
   */
  export interface CreateProductSearchStrategy {
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    Name: string;
    Code?: string;
    Strategy: ProductSearchStrategyModel;
    Type: ProductSearchStrategyTypes;
  }

  export interface ProductSearchStrategyModel {
    Condition: ProductSearchStrategyModel.StrategyCondition;
    Scoring: ProductSearchStrategyModel.ScoringStrategy;
    Sorting: ProductSearchStrategyModel.SortingStrategy;
    Query: ProductSearchStrategyModel.QueryStrategy;
    Aggregation: ProductSearchStrategyModel.AggregationStrategy;
  }

  export namespace ProductSearchStrategyModel {
    export interface StrategyCondition {
      Query: ProductSearchStrategyModel.QueryCondition;
      Filters: ProductSearchStrategyModel.FilterCondition[];
    }

    export interface FilterCondition {
      ProductPropertyTypeID: string;
      FilterValue: string;
    }

    export interface QueryCondition {
      Texts: string[];
      Type: ProductSearchStrategyModel.QueryConditionTypes;
    }

    export const enum QueryConditionTypes {
      Equals = 0,
      Contains = 1,
      StartsWith = 2
    }

    export interface AggregationStrategy {
      StockFilterType: ProductSearchStrategyModel.StockFilterTypes;
    }

    export interface ProductPropertyTypeToSearch {
      ID: string;
      Boost?: number;
    }

    export interface QueryStrategy {
      Queries: ProductSearchStrategyModel.MultiMatchQuery[];
      MinimumShouldMatch: string;
      StockFilter: ProductSearchStrategyModel.StockFilterStrategy;
    }

    export interface StockFilterStrategy {
      FilterByStock: boolean;
      Type: ProductSearchStrategyModel.StockFilterTypes;
    }

    export interface MultiMatchQuery {
      Type: ProductSearchStrategyModel.MultiMatchType;
      Slop?: number;
      Fuzziness: ProductSearchStrategyModel.MultiMatchFuzziness;
      Operator: ProductSearchStrategyModel.MatchOperator;
      Boost?: number;
      RequirementType: ProductSearchStrategyModel.QueryRequirementType;
      PropertiesToSearch: ProductSearchStrategyModel.ProductPropertyTypeToSearch[];
      Analyzer: string;
      MinimumShouldMatch: string;
    }

    export interface ScoringStrategy {
      ScoreMode: ProductSearchStrategyModel.ScoreModes;
      BoostMode: ProductSearchStrategyModel.BoostMode;
      ScoringFunctions: ProductSearchStrategyModel.ScoringFunction[];
      MaxBoost?: number;
      MinScore?: number;
      StockScoring: ProductSearchStrategyModel.StockScoringStrategy;
    }

    export interface StockScoringStrategy {
      AdjustScoreByStock: boolean;
      BoostAmount: number;
      Type: ProductSearchStrategyModel.StockFilterTypes;
    }

    export const enum StockFilterTypes {
      CurrentOrganizationUnit = 0,
      Suppliers = 1
    }

    export interface ScoringFunction {
      Type: ProductSearchStrategyModel.ScoringFunctionTypes;
      Options: { [key: string]: any };
      Weight?: number;
    }

    export interface SortingStrategySort {
      Order: ProductSearchStrategyModel.SortingStrategyOrder;
      Script: ProductSearchStrategyModel.SortingStrategySortScript;
      Field: string;
      MissingValue: any;
    }

    export interface SortingStrategySortScript {
      Type: ProductSearchStrategyModel.SortingScriptType;
      Source: string;
      Language: string;
    }

    export interface StockSortingStrategy {
      SortByStock: boolean;
      Type: ProductSearchStrategyModel.StockFilterTypes;
    }

    export interface SortingStrategy {
      Sort: ProductSearchStrategyModel.SortingStrategySort[];
      StockSorting: ProductSearchStrategyModel.StockSortingStrategy;
    }

    export const enum SortingStrategyOrder {
      Ascending = 0,
      Descending = 1
    }

    export const enum SortingScriptType {
      Number = 0,
      String = 1
    }

    export const enum QueryRequirementType {
      Must = 0,
      Should = 1
    }

    export const enum BoostMode {
      Multiply = 0,
      Replace = 1,
      Sum = 2,
      Average = 3,
      Max = 4,
      Min = 5
    }

    export const enum ScoreModes {
      Multiply = 0,
      Sum = 1,
      Average = 2,
      First = 3,
      Max = 4,
      Min = 5
    }

    export const enum ScoringFunctionTypes {
      FieldValueFactor = 0,
      Script = 1
    }

    export const enum MatchOperator {
      And = 0,
      Or = 1
    }

    export const enum MultiMatchType {
      BestFields = 0,
      MostFields = 1,
      CrossFields = 2,
      Phrase = 3,
      PhrasePrefix = 4
    }

    export interface MultiMatchFuzziness {
      EditDistance?: number;
      PrefixLength?: number;
      MaxExpansions?: number;
    }

  }

  export const enum ProductSearchStrategyTypes {
    Full = 0,
    Partial = 1
  }

  export interface CreateProductSearchStrategyResponse {
    /**
     * Entity type: ProductSearchStrategy
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Retrieves a paged list of search strategies, optionally filtered by a CountryID or LanguageID.
   */
  export interface ListProductSearchStrategies {
    PageConfig?: EVA.Core.PageConfig<ListProductSearchStrategiesFilter>;
  }

  export interface ListProductSearchStrategiesFilter {
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
  }

  export interface ListProductSearchStrategiesResponse {
    Result?: EVA.Core.PagedResult<ListProductSearchStrategyItem>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListProductSearchStrategyItem {
    /**
     * Entity type: ProductSearchStrategy
     */
    ID: number;
    /**
     * Entity type: Catalog
     */
    CatalogID?: number;
    /**
     * Entity type: Language
     */
    LanguageID: string;
    /**
     * Entity type: Country
     */
    CountryID: string;
    Name: string;
    Code: string;
    TypeID: number;
    Type: ProductSearchStrategyTypes;
    OrganizationUnitTypeID?: number;
    OrganizationUnitType?: EVA.Core.OrganizationUnitTypes;
    Strategy: ProductSearchStrategyModel;
    SerializedStrategy: string;
  }

  /**
   * Updates a search strategy, replacing the current strategy with the one provided and setting the LanguageID/CountryID
   * to the provided ones (both are optional).
   * 
   * All parts of the `Strategy` field are optional.
   */
  export interface UpdateProductSearchStrategy {
    /**
     * Entity type: ProductSearchStrategy
     */
    ID: number;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    Name?: string;
    Code?: string;
    Strategy: ProductSearchStrategyModel;
  }

  /**
   * Deletes a search strategy by the provided ID.
   */
  export interface DeleteProductSearchStrategy {
    /**
     * Entity type: ProductSearchStrategy
     */
    ID: number;
  }

  /**
   * Gets the default product search strategy, which can then be used as the basis to create a new strategy.
   */
  export interface GetDefaultProductSearchStrategy {
  }

  export interface GetDefaultProductSearchStrategyResponse {
    Strategy: ProductSearchStrategyModel;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Creates a ProductSearchConfiguration for your current Catalog if it doesn't exist, or replaces the existing one.
   * All properties on the configuration are optional.
   */
  export interface CreateOrReplaceProductSearchConfiguration {
    Configuration?: ProductSearchConfigurationModel;
  }

  export interface ProductSearchConfigurationModel {
    Analyzers: ProductSearchConfigurationModel.Analyzer[];
    TokenFilters: ProductSearchConfigurationModel.TokenFilter[];
    CharFilters: ProductSearchConfigurationModel.CharFilter[];
    ProductPropertyTypes: ProductSearchConfigurationModel.ProductPropertyTypeConfiguration[];
    DisableSynonyms: boolean;
    IndexPipelineScript: string;
  }

  export namespace ProductSearchConfigurationModel {
    export interface IHasCulture {
      LanguageID: string;
    }

    export interface Analyzer {
      Name: string;
      LanguageID: string;
      Type: string;
      Tokenizer: string;
      Filters: string[];
      CharFilters: string[];
    }

    export interface TokenFilter {
      Name: string;
      LanguageID: string;
      Type: string;
      Options: { [key: string]: any };
    }

    export interface CharFilter {
      Name: string;
      LanguageID: string;
      Type: string;
      Options: { [key: string]: any };
    }

    export interface ProductPropertyTypeConfiguration {
      Name: string;
      LanguageID: string;
      Analyzer: string;
      SearchAnalyzer: string;
      CopyTo: string;
    }

  }

  /**
   * Retrieves the ProductSearchConfiguration for your current Catalog, or an empty one if it doesn't exist.
   */
  export interface GetProductSearchConfiguration {
  }

  export interface GetProductSearchConfigurationResponse {
    Configuration: ProductSearchConfigurationModel;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface CreateBrand {
    BackendID?: string;
    Name?: string;
  }

  export interface GetBrand {
    /**
     * Entity type: Brand
     */
    ID: number;
  }

  export interface GetBrandResponse {
    Result: BrandDto;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface BrandDto {
    /**
     * Entity type: Brand
     */
    ID: number;
    Name: string;
    BackendID: string;
  }

  export interface UpdateBrand {
    ToUpdate: BrandDto;
  }

  /**
   * Composes the given set of products
   */
  export interface ComposeProducts {
    /**
     * The products to compose, will compose all products if not specified
     * Entity type: Product
     */
    ProductIDs?: number[];
    /**
     * Wait until the composition is finished, otherwise it will be started in the background. Will only work if <100 product IDs are specified.
     */
    WaitForCompletion?: boolean;
    /**
     * Entity type: Language
     */
    LanguageIDs: string[];
    /**
     * WARNING: This will remove all existing indices and create new ones with ONLY the specified products, effectivly removing all other products!
     */
    UseNewIndices?: boolean;
  }

  export interface ComposeResponse {
    CompositionID: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface CancelComposeProducts {
    CompositionID: string;
  }

  export interface GetProductCompositionState {
    CompositionID: string;
  }

  export interface GetProductCompositionStateResponse {
    Status: string;
    TotalProductCount: number;
    TotalComposeCount: number;
    ProductsComposed: number;
    CompositionCount: number;
    DocumentsCopiedToElasticsearch: number;
    DocumentsCopiedToDatabase: number;
    BytesReadFromDatabase: number;
    BytesWrittenToElasticsearch: number;
    BytesWrittenToDatabase: number;
    BytesReadFromDatabasePerSecond: number;
    BytesWrittenToElasticsearchPerSecond: number;
    BytesWrittenToDatabasePerSecond: number;
    CompositionsPerSecond: number;
    ProductsComposedPerSecond: number;
    DocumentsCopiedToElasticsearchPerSecond: number;
    DocumentsCopiedToDatabasePerSecond: number;
    Progress: number;
    RemainingBatchCount: number;
    RemainingCopyBatchCount: number;
    ElapsedTimeInSeconds: number;
    ExpectedTimeRemainingInSeconds?: number;
    ExpectedTotalTimeInSeconds?: number;
    ExpectedCompletionTime?: string;
    CreationTime: string;
    CompletionTime?: string;
    WaitingOnDatabaseTimeInSeconds: number;
    WaitingOnConsumerTimeInSeconds: number;
    WaitingOnProducerTimeInSeconds: number;
    WaitingOnCompositionTimeInSeconds: number;
    WaitingOnSerializationTimeInSeconds: number;
    WaitingOnElasticsearchTimeInSeconds: number;
    WaitingOnDatabaseWriteTimeInSeconds: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Lists ProductContentEdits, optionally filtered by ProductID/RevisionID/LayerID
   */
  export interface ListProductContentEdits {
    InitialPageConfig?: EVA.Core.PageTokenConfig<ListProductContentEditsFilter>;
    PageToken?: string;
  }

  export interface ListProductContentEditsFilter {
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    /**
     * Entity type: Revision
     */
    RevisionID?: number;
    /**
     * Entity type: ContentLayer
     */
    LayerID?: number;
  }

  export interface ListProductContentEditsResponse {
    Results?: ListProductContentEditsItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListProductContentEditsItem {
    /**
     * Entity type: ProductContentEdit
     */
    ID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: ContentLayer
     */
    LayerID: number;
    /**
     * Entity type: Revision
     */
    RevisionID?: number;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    CreationTime: string;
    /**
     * Entity type: User
     */
    LastModifiedByID?: number;
    LastModificationTime?: string;
    RevisionName: string;
    LayerName: string;
    /**
     * Entity type: Language
     */
    LayerLanguageID: string;
    /**
     * Entity type: Country
     */
    LayerCountryID: string;
    LayerLevel: number;
    ProductName: string;
    ProductType: EVA.Core.ProductTypes;
    ProductLogicalLevel: string;
    Content: ProductEditItem;
  }

  export interface ProductEditItem {
    Properties: { [key: string]: ProductEditItem.ProductProperty };
    MediaAdd: ProductEditItem.ProductMedia[];
    MediaRemove: ProductEditItem.ProductMedia[];
  }

  export namespace ProductEditItem {
    export interface ProductMedia {
      ID: string;
      BlobID: string;
      Name: string;
      Type: string;
      Sequence?: number;
      IsPrimaryImage?: boolean;
      Inherit?: boolean;
      MediaType: ProductMediaTypes;
      Url: string;
    }

    export interface ProductProperty {
      Value?: ProductEditItem.PropertyValue;
      AddValues: ProductEditItem.PropertyValue[];
      RemoveValues: ProductEditItem.PropertyValue[];
      IsDeleted?: boolean;
    }

    export interface PropertyValue {
      Value: any;
      Type: PropertyValueType;
    }

  }

  export const enum PropertyValueType {
    None = 0,
    Int = 1,
    String = 2,
    Bool = 3,
    DateTime = 4,
    Float = 5
  }

  export const enum ProductMediaTypes {
    Default = 0,
    Swatch = 1
  }

}declare module EVA.Payment.Adyen {

  export namespace Errors {
    export const enum Adyen {
      /**
       * Received Adyen error: {0:string}
       */
      Error = 'Adyen:Error',
      /**
       * Failed to create payment: {0:string}
       */
      CreatePaymentFailed = 'Adyen:CreatePaymentFailed',
      /**
       * Failed to create refund: {0:string}
       */
      RefundFailed = 'Adyen:RefundFailed',
      /**
       * Failed to create capture
       */
      CaptureFailed = 'Adyen:CaptureFailed'
    }

    export const enum AdyenStoredValue {
      /**
       * A CardNumber is required to activate a giftcard
       */
      MissingCardNumber = 'AdyenStoredValue:MissingCardNumber',
      /**
       * Invalid gift card - card not found
       */
      GiftCardNotFound = 'AdyenStoredValue:GiftCardNotFound',
      /**
       * Invalid gift card - product not found
       */
      MissingProduct = 'AdyenStoredValue:MissingProduct',
      /**
       * Invalid gift card - missing PIN/SSC
       */
      MissingPinSsc = 'AdyenStoredValue:MissingPinSsc',
      /**
       * A CardNumber should have a length of {validLength:number} or {validLength2:number}, current length is {invalidLength:number}
       */
      InvalidCardNumberLength = 'AdyenStoredValue:InvalidCardNumberLength'
    }

  }


  /**
   * Validate the Adyen management api configuration.
   * 
   * Returns a list of messages that contains information about the configuration.
   */
  export interface AdyenValidateManagementConfiguration {
  }

  export interface AdyenValidateManagementConfigurationResponse {
    IsValid: boolean;
    Messages: AdyenValidateManagementConfigurationResponse.ValidationMessage[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace AdyenValidateManagementConfigurationResponse {
    export interface ValidationMessage {
      Error: boolean;
      Message: string;
    }

  }

  /**
   * Create a donation with the Adyen Giving program. This service can be called when the CreatePayment returned DonationAvailable.
   * 
   * The PaymentTransactionID and Amount are required. Amount is in the same currency as the PaymentTransaction.
   * 
   * Optionally a specific DonationAccount can be specified, this will fallback to the configured DonationAccount.
   */
  export interface AdyenDonate {
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID?: number;
    Amount?: number;
    DonationAccount?: string;
  }

  export interface AdyenDonateResponse {
    Success: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Submits details for an Adyen payment created using `CreatePayment`. This step is only needed when no final state has been reached on the
   * `CreatePayment` request (for example for 3D Secure, or when getting redirected back directly from a payment method using an app switch).
   * 
   * The exact details, which need to be sent to this endpoint, are always specified in the `Properties.Data` parameter in the response of the
   * associated `CreatePayment` request.
   */
  export interface AdyenPaymentDetails {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID: number;
    Details: { [key: string]: string };
    PaymentData?: string;
    ThreeDSAuthenticationOnly?: boolean;
  }

  export interface AdyenPaymentDetailsResponse {
    RedirectUrl?: string;
    QrCode?: string;
    Data?: { [key: string]: any };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Retrieve all gateways supported by the current configuration of Adyen, matched with the existing payment types in EVA. `ID` is it's unique
   * identifier, `Name` is something that you can show the customer.
   * 
   * It is required to supply an `OrderID` or, the `CurrencyID` and `Amount`.
   * When no amount is given, the open amount of the order we be used.
   * It is recommended to specify the `Channel`:
   * - Web: 1
   * - iOS: 2
   * - Android: 3
   * 
   * Recommended way of calling this service is with only an `OrderID` and `Channel`.
   * 
   * * If present, the `Details` list will show a list of properties that this gateway supports. Every detail is identied with the `Key`, and to support
   * typed inputs, the `Type` is also given. If the `Type` is `select`, one of the items inside the `Items` list needs to be chosen. Here, again, the
   * `ID` is it's unique identifier, and the `Name` is something you can show the customer.
   * * If present, the `Brands` list will show a list of supported brands within this payment method, e.g. to list creditcards (mc, visa, amex, ...).
   * 
   * When creating the payment, use the `ID` of the gateway as `GatewayID`. Fill the payment properties `Details` with the properties specific to the
   * gateway, as indicated by this response's `Details` list.
   */
  export interface ListAdyenCheckoutGateways {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
    Amount?: number;
    Channel?: AdyenChannel;
  }

  export const enum AdyenChannel {
    Web = 1,
    iOS = 2,
    Android = 3
  }

  export interface ListAdyenCheckoutGatewaysResponse {
    Gateways: ListAdyenCheckoutGatewaysResponse.Gateway[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListAdyenCheckoutGatewaysResponse {
    export interface Gateway {
      ID: string;
      /**
       * Entity type: PaymentType
       */
      PaymentTypeID: number;
      Name: string;
      /**
       * Requires at least v68 of the adyen integration
       */
      Issuers?: ListAdyenCheckoutGatewaysResponse.Item[];
      Brands: string[];
    }

    export interface Detail {
      ID: string;
      Type: string;
      Items: ListAdyenCheckoutGatewaysResponse.Item[];
    }

    export interface Item {
      ID: string;
      Name: string;
    }

  }

}declare module EVA.Payment.Core {

  export namespace Errors {
    export const enum LoyaltyPayment {
      /**
       * A Customer is required to do a Loyalty payment
       */
      CustomerRequired = 'LoyaltyPayment:CustomerRequired',
      /**
       * Invalid loyalty program selected
       */
      InvalidLoyaltyProgram = 'LoyaltyPayment:InvalidLoyaltyProgram',
      /**
       * Failed to execute the LoyaltyPayment in the handler
       */
      PaymentFailed = 'LoyaltyPayment:PaymentFailed'
    }

    export const enum APIGiftCard {
      /**
       * Redemption of card {0:string} failed
       */
      RedemptionFailed = 'APIGiftCard:RedemptionFailed',
      /**
       * A CardNumber is required to activate a giftcard
       */
      MissingCardNumber = 'APIGiftCard:MissingCardNumber',
      /**
       * Card with number {0:string} was not found.
       */
      CardNotFound = 'APIGiftCard:CardNotFound',
      /**
       * Configured endpoint is invalid.
       */
      EndpointInvalid = 'APIGiftCard:EndpointInvalid',
      /**
       * The card has currency {cardCurrency:string}, but the requested currency is {transactionCurrency:string}.
       */
      CurrencyMismatch = 'APIGiftCard:CurrencyMismatch'
    }

    export const enum EVAPay {
      /**
       * The given data if for a different Order.
       */
      InvalidOrder = 'EVAPay:InvalidOrder',
      /**
       * The given token is not valid.
       */
      InvalidToken = 'EVAPay:InvalidToken',
      /**
       * Customer is required.
       */
      CustomerRequired = 'EVAPay:CustomerRequired',
      /**
       * Invalid amount.
       */
      InvalidAmount = 'EVAPay:InvalidAmount',
      /**
       * EmailAddress is required.
       */
      EmailAddressRequired = 'EVAPay:EmailAddressRequired',
      /**
       * BaseUrl is required and should either be configured (Setting) or supplied as parameter.
       */
      BaseUrlRequired = 'EVAPay:BaseUrlRequired',
      /**
       * No PIN configured.
       */
      NoPinConfigured = 'EVAPay:NoPinConfigured',
      /**
       * Service only supports calls from users authenticated with an EVAPay token.
       */
      InvalidAuthenticationToken = 'EVAPay:InvalidAuthenticationToken'
    }

    export const enum CashPayment {
      /**
       * There is no open financial period for the current organizationunit.
       */
      NoOpenFinancePeriod = 'CashPayment:NoOpenFinancePeriod',
      /**
       * Invalid amounts provided for a CashPayment.
       */
      InvalidAmount = 'CashPayment:InvalidAmount',
      /**
       * The amount given can never be equal to or less than 0.
       */
      InvalidAmountGiven = 'CashPayment:InvalidAmountGiven',
      /**
       * The amount to refund can never be equal to or less than 0.
       */
      InvalidRefundAmount = 'CashPayment:InvalidRefundAmount',
      /**
       * Amount to be paid can't be greater than the open amount on the order.
       */
      OverPaymentNotAllowed = 'CashPayment:OverPaymentNotAllowed',
      /**
       * Cash payment limit has been reached for this currency type.
       */
      PaidAmountAboveCashHandlerLimit = 'CashPayment:PaidAmountAboveCashHandlerLimit',
      /**
       * Cash payment limit has been reached.
       */
      PaidAmountAboveCashLimit = 'CashPayment:PaidAmountAboveCashLimit'
    }

    export const enum CashDrawer {
      /**
       * Opening cash drawers requires Remark field to be set.
       */
      OpeningCashDrawerRequiresRemark = 'CashDrawer:OpeningCashDrawerRequiresRemark',
      /**
       * Opening a cash drawer with a PaymentTransaction requires a recent, confirmed cash payment.
       */
      InvalidPaymentTransactionProvided = 'CashDrawer:InvalidPaymentTransactionProvided'
    }

    export const enum BankTransfer {
      /**
       * AccountHolderName is required.
       */
      AccountHolderNameRequired = 'BankTransfer:AccountHolderNameRequired',
      /**
       * IBAN is required.
       */
      IBANRequired = 'BankTransfer:IBANRequired',
      /**
       * IBAN is not valid: {0:string}
       */
      IBANInvalid = 'BankTransfer:IBANInvalid'
    }

  }


  /**
   * Returns the available UserCardTypes
   */
  export interface GetUserCardTypes {
  }

  export interface GetUserCardTypesResponse {
    Types: EVA.Core.UserCardTypeDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Lists all user cards, with their number, type and linked user (full) name.
   * Using the `PageConfig`, you can filter on `Barcode`, `TypeID`, `FullName` and/or `UserName`.
   */
  export interface ListUserCards {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListUserCardsFilter>;
  }

  export interface ListUserCardsResponse {
    Result?: EVA.Core.PagedResult<ListUserCardDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListUserCardDto {
    Barcode: string;
    /**
     * Entity type: UserCard
     */
    ID: number;
    Type: EVA.Core.UserCardTypeDto;
    UserFullName: string;
  }

  /**
   * Returns all the UserCard for the current or requested User.
   * The currency is used to convert UserCards without a currency to their monetary value. Defaults to the session Currency.
   */
  export interface GetUserCardsForUser {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
  }

  export interface GetUserCardsForUserResponse {
    UserCards: EVA.Core.UserCardDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get the UserCard including the current balance
   */
  export interface GetUserCardDetails {
    /**
     * Entity type: UserCard
     */
    UserCardID?: number;
    CardNumber?: string;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
  }

  export interface GetUserCardDetailsResponse {
    UserCard: EVA.Core.UserCardDto;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get the currenct balance of an UserCard
   */
  export interface GetUserCardBalance {
    /**
     * Entity type: UserCard
     */
    UserCardID: number;
    /**
     * Entity type: Currency
     */
    CurrencyID?: string;
  }

  export interface GetUserCardBalanceResponse {
    CurrentBalance: EVA.Core.UserCardBalance;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List the mutations for a UserCard. Customers can only view the mutations of their own usercards.
   */
  export interface ListUserCardMutations {
    /**
     * Entity type: UserCard
     */
    UserCardID: number;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListUserCardMutationsResponse {
    Result?: EVA.Core.PagedResult<ListUserCardMutationsDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListUserCardMutationsDto {
    Amount: number;
    CreationTime: string;
    Description: string;
    /**
     * Entity type: Order
     */
    OrderID?: number;
    Status: EVA.Core.UserCardMutationStatuses;
    OrderDisplayID?: string;
  }

  /**
   * Create a new UserCard
   * 
   * The type is required, it can optionally be attached to an User.
   * When the CurrencyID is not supplied the currency of the current session will be used.
   */
  export interface CreateUserCard {
    /**
     * Entity type: User
     */
    UserID?: number;
    /**
     * Required for UserCards that hold normal Currencies
     * Entity type: Currency
     */
    CurrencyID?: string;
    /**
     * Entity type: UserCardType
     */
    UserCardTypeID: number;
    Description?: string;
  }

  export interface CreateUserCardResponse {
    /**
     * Entity type: UserCard
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Mutate the balance on an UserCard with the given amount.
   */
  export interface CreateUserCardMutation {
    /**
     * Entity type: UserCard
     */
    UserCardID: number;
    Amount: number;
    Description?: string;
  }

  /**
   * Abort a current pin paymenttransaction
   */
  export interface AbortTransaction {
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID?: number;
    /**
     * Entity type: Station
     */
    StationID?: number;
  }

  export interface AbortTransactionResponse {
    ResultStatus: PinTransactionResultStatus;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export const enum PinTransactionResultStatus {
    None = 0,
    TimeoutFromPinDevice = 1,
    TransactionStillInProgressForPayment = 2,
    Success = 3,
    Aborted = 4,
    Failure = 5,
    DeviceUnavailable = 6,
    PrintLastTicket = 7,
    TimedOut = 8,
    TransactionAlreadyInProgressForUser = 9,
    UserMustScanStationToAbort = 10,
    PaymentValidationError = 11,
    InProgress = 12,
    ClientFailure = 13,
    SelectPaymentMethod = 14,
    MustRevalidate = 16,
    ConnectToTerminal = 17
  }

  /**
   * Returns all `PinHandlers` available to use on `PaymentType.Options`
   */
  export interface GetAvailablePinHandlers {
  }

  export interface GetAvailablePinHandlersResponse {
    Handlers: GetAvailablePinHandlersResponse.PinHandler[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAvailablePinHandlersResponse {
    export interface PinHandler {
      Name: string;
    }

  }

  /**
   * Idle the terminal display and make it show the standby screen - this screen shows the configured branded logo as it is usually shown when no other process is going on.
   */
  export interface IdlePinTerminal {
  }

  export interface PrintLastReceiptCallback {
    /**
     * Entity type: Station
     */
    StationID?: number;
    ReceiptLines: string[];
  }

  export interface PrintPinReceipt {
    ECRID?: string;
    OrderReference: string;
    ReceiptLines: string[];
    TransactionSucceeded?: boolean;
    SignatureLines: SignatureLine[];
    ReceiptType: string;
  }

  export namespace PrintPinReceipt {
    export interface ReceiptTypes {
    }

  }

  export interface SignatureLine {
    X1: number;
    Y1: number;
    X2: number;
    Y2: number;
  }

  /**
   * Start the pin transaction
   * 
   * This service needs to be called after creating a pin payment. It will block until the transaction is completed.
   * To cancel this process the AbortTransaction service can be called.
   */
  export interface StartTransaction {
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID?: number;
    /**
     * Entity type: Station
     */
    StationID?: number;
  }

  export interface StartTransactionResponse {
    ResultStatus: PinTransactionResultStatus;
    ResultStatusString: string;
    OpenAmount: number;
    CardCircuit: string;
    CountryID: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Store the Tap2Pay receipt.
   */
  export interface StoreTap2PayReceipt {
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID: number;
    ReceiptOutputText: OutputReceiptText[];
  }

  export interface OutputReceiptText {
    Text?: string;
    EndOfLineFlag?: boolean;
  }

  /**
   * Retrieve order information based on an EVAPay generated token (that you authenticated with).
   */
  export interface EVAPayGetInfo {
    ProductProperties?: string[];
    IncludeAllPayments?: boolean;
    ShowOnlyShippableLines?: boolean;
  }

  export interface EVAPayGetInfoResponse {
    Amounts: EVA.Core.OpenOrderAmounts;
    ReturnUrl?: string;
    RequestedAmount?: number;
    TotpToken?: string;
    TotpData?: string;
    IsPaid: boolean;
    PaymentRequired: boolean;
    Result: EVA.Core.OrderDto;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Open a CashDrawer on the given station
   * 
   * Without a PaymentTransactionID, this service requires additional OpenCashDrawer functionality and you can then specify a ReasonID why you are opening it.
   */
  export interface OpenCashDrawer {
    /**
     * Entity type: Station
     */
    StationID?: number;
    Remark?: string;
    /**
     * When the opening of the drawer is non-payment related, it's possible to specify a predefined ReasonID for opening the drawer.
     * Entity type: OpenCashDrawerReason
     */
    ReasonID?: number;
    /**
     * Entity type: PaymentTransaction
     */
    PaymentTransactionID?: number;
  }

  export interface OpenCashDrawerResponse {
    Result: EVA.Core.OpenCashDrawerResults;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

}declare module EVA.Payment.Mollie {

  /**
   * When you would like to control payment type and issuer selection yourself, you can use `ListMollieGateways` to retrieve a list of supported payment types ("gateways") from Mollie. Currently they
   * support iDEAL, Bitcoin, bank transfer, credit card and a couple more, all configurable through Mollie. This response will include icons and descriptions in the supplied locale, and in case of iDEAL
   * will include a list of "issuers" like ING, Rabobank, etcetera.
   * 
   * Then when creating a payment, include a `GatewayID` and this payment type is automatically chosen. Additionally include `Issuer` and this too is automatically selected.
   * 
   * Configure `Mollie:Api:BaseUrl` (although it doesn't seem you want to deviate from the default) and specify a `Mollie:Api:Token`.
   * 
   * EVA will require the selected payment type configured in the "MOLLIE_`GatewayID`" format, for instance "MOLLIE_BITCOIN" and "MOLLIE_IDEAL", and the "MOLLIE" payment type is no longer required.
   */
  export interface ListMollieGateways {
  }

  export interface ListMollieGatewaysResponse {
    Gateways: Method[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface Method {
    ID: string;
    Description: string;
    Amount: Amount;
    Image: Image;
    Issuers: Issuer[];
  }

  export interface Amount {
    Minimum: number;
    Maximum: number;
  }

  export interface Image {
    Normal: string;
    Bigger: string;
  }

  export interface Issuer {
    ID: string;
    Name: string;
    Image: Image;
  }

}declare module EVA.Payment.MultiSafepay {

  export interface GetMultiSafepayGateways {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetMultiSafepayGatewaysResponse {
    Gateways: { [key: string]: string };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

}declare module EVA.Payment.Stripe {

  export namespace Errors {
    export const enum Stripe {
      /**
       * Missing BackendID on payment {0:number}
       */
      MissingBackendID = 'Stripe:MissingBackendID',
      /**
       * Failed make payment: '{0:string}'
       */
      PaymentFailed = 'Stripe:PaymentFailed',
      /**
       * ApiKey is not yet configured
       */
      MissingApiKey = 'Stripe:MissingApiKey',
      /**
       * Failed to setup webhooks: {0:string}
       */
      WebhooksFailed = 'Stripe:WebhooksFailed'
    }

  }


  /**
   * Validates current config for Stripe
   */
  export interface StripeValidateConfiguration {
  }

}declare module EVA.Privacy {

  export namespace Errors {
    export const enum PrivacyRemovalRequest {
      /**
       * Privacy removal already requested.
       */
      AlreadyRequested = 'PrivacyRemovalRequest:AlreadyRequested',
      /**
       * Cannot request privacy removal for this user type.
       */
      InvalidUserType = 'PrivacyRemovalRequest:InvalidUserType',
      /**
       * Can no longer request cancellation of this privacy removal request.
       */
      CannotBeCancelled = 'PrivacyRemovalRequest:CannotBeCancelled',
      /**
       * Only the user themselves can cancel the privacy removal request.
       */
      SelfCancelOnly = 'PrivacyRemovalRequest:SelfCancelOnly',
      /**
       * The maximum time the processing of a privacy removal request can be delayed is 24 hours.
       */
      InvalidDelay = 'PrivacyRemovalRequest:InvalidDelay'
    }

    export const enum RemovalRequestProcessor {
      /**
       * Some invoices are missing for removal request {0:number}, requesting generation.
       */
      InvoicesMissingForRemovalRequest = 'RemovalRequestProcessor:InvoicesMissingForRemovalRequest'
    }

  }


  export interface GetPrivacyDataRequestByID {
    /**
     * Entity type: DataRequest
     */
    ID: number;
  }

  export interface GetPrivacyDataRequestByIDResponse {
    /**
     * Entity type: DataRequest
     */
    ID: number;
    /**
     * Entity type: User
     */
    UserID: number;
    UserFullName: string;
    Status: DataRequestStatus;
    GenerationTime?: string;
    /**
     * Entity type: Blob
     */
    BlobID?: string;
    Url: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export const enum DataRequestStatus {
    Requested = 0,
    Processing = 1,
    Ready = 2,
    Expired = 3
  }

  export interface CreatePrivacyDataRequest {
    /**
     * Entity type: User
     */
    UserID?: number;
  }

  export interface CreatePrivacyDataRequestResponse {
    /**
     * Entity type: DataRequest
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface DeletePrivacyDataRequest {
    /**
     * Entity type: DataRequest
     */
    ID: number;
  }

  export interface ListPrivacyDataRequests {
    /**
     * Entity type: User
     */
    UserID?: number;
    PageConfig?: EVA.Core.PageConfig<{ [key:string]: string }>;
  }

  export interface ListPrivacyDataRequestsResponse {
    Result?: EVA.Core.PagedResult<ListPrivacyDataRequestsResponse.PrivacyDataRequest>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPrivacyDataRequestsResponse {
    export interface PrivacyDataRequest {
      /**
       * Entity type: DataRequest
       */
      ID: number;
      /**
       * Entity type: User
       */
      UserID: number;
      UserFullName: string;
      Status: DataRequestStatus;
      GenerationTime?: string;
      /**
       * Entity type: Blob
       */
      BlobID?: string;
      Url: string;
    }

  }

  export interface GetPrivacyOrderDataRemovals {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface GetPrivacyOrderDataRemovalsResponse {
    Results: GetPrivacyOrderDataRemovalsResponse.Model[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetPrivacyOrderDataRemovalsResponse {
    export interface Model {
      /**
       * Entity type: Order
       */
      OrderID: number;
      /**
       * Entity type: OrderLine
       */
      OrderLineID?: number;
      Type: string;
    }

  }

  export interface CreatePrivacyOrderDataRemovalRequest {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    Type?: string;
  }

  /**
   * Get a privacy removal request by ID
   */
  export interface GetPrivacyRemovalRequestByID {
    /**
     * Entity type: RemovalRequest
     */
    ID: number;
  }

  export interface GetPrivacyRemovalRequestByIDResponse {
    /**
     * Entity type: RemovalRequest
     */
    ID: number;
    /**
     * Entity type: User
     */
    UserID: number;
    UserFullName: string;
    Status: RemovalRequestStatus;
    RemovalTime?: string;
    Hash: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export const enum RemovalRequestStatus {
    Requested = 0,
    Processing = 1,
    Done = 2,
    Failed = 3,
    Cancelled = 4
  }

  /**
   * Create and schedule a privacy removal request.
   */
  export interface CreatePrivacyRemovalRequest {
    /**
     * Entity type: User
     */
    UserID: number;
    /**
     * The delay before the removal request is processed. During this period the user themselves can cancel the request.
     */
    ProcessDelay?: string;
  }

  export interface CreatePrivacyRemovalRequestResponse {
    /**
     * Entity type: RemovalRequest
     */
    ID: number;
    Hash: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * List privacy removal requests.
   */
  export interface ListPrivacyRemovalRequests {
    PageConfig?: EVA.Core.PageConfig<ListPrivacyRemovalRequestsFilter>;
  }

  export interface ListPrivacyRemovalRequestsFilter {
    /**
     * Entity type: User
     */
    UserIDs?: number[];
    /**
     * Entity type: RemovalRequest
     */
    IDs?: number[];
    Hashes?: string[];
    Status?: RemovalRequestStatus;
    CreationDateRange?: ListPrivacyRemovalRequestsFilter.DateRange;
  }

  export namespace ListPrivacyRemovalRequestsFilter {
    export interface DateRange {
      StartDate?: string;
      EndDate?: string;
    }

  }

  export interface ListPrivacyRemovalRequestsResponse {
    Result?: EVA.Core.PagedResult<ListPrivacyRemovalRequestsResponse.PrivacyRemovalRequest>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListPrivacyRemovalRequestsResponse {
    export interface PrivacyRemovalRequest {
      /**
       * Entity type: RemovalRequest
       */
      ID: number;
      /**
       * Entity type: User
       */
      UserID: number;
      UserFullName: string;
      Status: RemovalRequestStatus;
      RemovalTime?: string;
      Hash: string;
    }

  }

  /**
   * Service where failed privacy removal requests can be reschuled for processing.
   */
  export interface ScheduleRemovalRequests {
    /**
     * Entity type: RemovalRequest
     */
    IDs?: number[];
  }

  /**
   * Async service to re-process a failed privacy removal request.
   */
  export interface ExecuteRemovalRequest {
    /**
     * Entity type: RemovalRequest
     */
    ID: number;
  }

  /**
   * Cancels a pending removal request. Can only be called by the user of the removal request themselves.
   */
  export interface CancelRemovalRequest {
    /**
     * Entity type: RemovalRequest
     */
    ID: number;
  }

}declare module EVA.Replenishment {

  export namespace Errors {
    export const enum ReplenishmentProposals {
      /**
       * This proposal is already running and cannot be retried at this moment.
       */
      AlreadyRunning = 'ReplenishmentProposals:AlreadyRunning'
    }

    export const enum DownloadReplenishmentProductsExcel {
      /**
       * You can't download more than 1000000 records through this service.
       */
      TooManyRecords = 'DownloadReplenishmentProductsExcel:TooManyRecords',
      /**
       * Replenishment product with ID {0:string} does not exist.
       */
      UnknownReplenishmentProduct = 'DownloadReplenishmentProductsExcel:UnknownReplenishmentProduct',
      /**
       * Missing product identifier for row {0:number}.
       */
      MissingProductIdentifier = 'DownloadReplenishmentProductsExcel:MissingProductIdentifier'
    }

    export const enum ReplenishmentProducts {
      /**
       * There was a duplicate record for OrganizationUnit/Product/StockLabel {0:string}/{1:string}/{2:string} within one time frame.
       */
      DuplicateRecord = 'ReplenishmentProducts:DuplicateRecord',
      /**
       * The MaximumQuantity {0:string} must be greater than or equal to the MinimumQuantity {1:string}.
       */
      InvalidQuantityRange = 'ReplenishmentProducts:InvalidQuantityRange'
    }

  }


  /**
   * Creates a new `ReplenishmentProposal`.
   * 
   * The new proposal is picked up and processed asynchronously and could take a while after creation to complete generating its results, depending on the
   * amount of sources, targets, products and the algorithm used. Check the `Status` property in the `GetReplenishmentProposal` response to see if it's
   * completed.
   * 
   * To allow selecting the output types for the generated proposal, the property `OutputTypes` can be set. It is a flags enum of the type
   * `ReplenishmentOutputTypes`. If the `OutputTypes` is not set, it will fall back to the setting `Replenishment:Outputs`.
   */
  export interface CreateReplenishmentProposal {
    /**
     * Required when `SourceOrganizationUnitSetID` is omitted
     * Entity type: OrganizationUnit
     */
    SourceOrganizationUnitIDs?: number[];
    /**
     * Required when `SourceOrganizationUnitIDs` is omitted
     * Entity type: OrganizationUnitSet
     */
    SourceOrganizationUnitSetID?: number;
    /**
     * Required when `TargetOrganizationUnitSetID` is omitted
     * Entity type: OrganizationUnit
     */
    TargetOrganizationUnitIDs?: number[];
    /**
     * Required when `TargetOrganizationUnitIDs` is omitted
     * Entity type: OrganizationUnitSet
     */
    TargetOrganizationUnitSetID?: number;
    /**
     * Optional list of stock labels to generate replenishment proposal for
     */
    StockLabels?: CreateReplenishmentProposal.StockLabelDto[];
    /**
     * Optional parameter to override the standard output types for created replenishment proposals
     */
    OutputTypes?: ReplenishmentOutputTypes;
  }

  export namespace CreateReplenishmentProposal {
    export interface StockLabelDto {
      /**
       * Ordering of the labels, to determine priority in scarcity
       */
      SequenceID: number;
      /**
       * Entity type: StockLabel
       */
      StockLabelID: number;
    }

  }

  export const enum ReplenishmentOutputTypes {
    None = 0,
    AutoOrder = 1,
    AutoOrderAutoConfirm = 2,
    Debug = 4,
    Info = 8,
    Order = 16
  }

  export interface CreateReplenishmentProposalResponse {
    /**
     * Entity type: ReplenishmentProposal
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get a `ReplenishmentProposal`.
   * 
   * * To get the possible sources of this proposal, use the 'GetReplenishmentProposalSources`.
   * * To get the targets of this proposal, use the 'GetReplenishmentProposalTargets`.
   * * To get the stock labels of this proposal, use the 'GetReplenishmentProposalStockLabels`.
   * * To get the results of this proposal, use the 'GetReplenishmentProposalResults`.
   */
  export interface GetReplenishmentProposal {
    /**
     * Entity type: ReplenishmentProposal
     */
    ID: number;
  }

  export interface GetReplenishmentProposalResponse {
    Result: ReplenishmentProposalDto;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ReplenishmentProposalDto {
    /**
     * Entity type: ReplenishmentProposal
     */
    ID: number;
    Status: ReplenishmentProposalStatus;
    Error: string;
    CreationTime: string;
    Blobs: ReplenishmentProposalBlobDto[];
  }

  export const enum ReplenishmentProposalStatus {
    New = 0,
    Processing = 1,
    Processed = 2,
    Error = 9
  }

  export interface ReplenishmentProposalBlobDto {
    TypeID: string;
    /**
     * Entity type: Blob
     */
    BlobID: string;
    Url: string;
  }

  /**
   * Get all Sources for a `ReplenishmentProposal`, identified by its `ID`. Supports filter option for `OrganizationUnitIDs`.
   */
  export interface GetReplenishmentProposalSources {
    /**
     * Entity type: ReplenishmentProposal
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
  }

  export interface GetReplenishmentProposalSourcesResponse {
    Result: EVA.Core.OrganizationUnitDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get all Stock Labels for a `ReplenishmentProposal`, identified by its `ID`.
   */
  export interface GetReplenishmentProposalStockLabels {
    /**
     * Entity type: ReplenishmentProposal
     */
    ID: number;
  }

  export interface GetReplenishmentProposalStockLabelsResponse {
    Result: GetReplenishmentProposalStockLabelsResponse.StockLabelDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetReplenishmentProposalStockLabelsResponse {
    export interface StockLabelDto {
      /**
       * Entity type: StockLabel
       */
      StockLabelID: number;
      SequenceID: number;
    }

  }

  /**
   * Get all Targets for a `ReplenishmentProposal`, identified by its `ID`. Supports filter option for `OrganizationUnitIDs`.
   */
  export interface GetReplenishmentProposalTargets {
    /**
     * Entity type: ReplenishmentProposal
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
  }

  export interface GetReplenishmentProposalTargetsResponse {
    Result: EVA.Core.OrganizationUnitDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Lists all Results for a `ReplenishmentProposal`, identified by its `ID`.
   * 
   * Through the `PageConfig`'s `Filter` parameter, you have the following filter options available:
   * 
   * * `SourceIDs` and/or `TargetIDs` as `OrganizationUnit`.`ID`'s
   * * `ProductIDs` as `Product`.`ID`s
   * * `CustomID` as `Product`.`CustomID`
   * * `BrandName` as `Product`.`Brand`.`Name`
   */
  export interface ListReplenishmentProposalResults {
    /**
     * Entity type: ReplenishmentProposal
     */
    ID: number;
    PageConfig?: EVA.Core.PageConfig<ListReplenishmentProposalResultFilters>;
  }

  export interface ListReplenishmentProposalResultFilters {
    /**
     * Entity type: OrganizationUnit
     */
    SourceIDs: number[];
    /**
     * Entity type: OrganizationUnit
     */
    TargetIDs: number[];
    /**
     * Entity type: Product
     */
    ProductIDs: number[];
    CustomID?: string;
    BrandName?: string;
  }

  export interface ListReplenishmentProposalResultsResponse {
    Result?: EVA.Core.PagedResult<ReplenishmentProposalResultListDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ReplenishmentProposalResultListDto {
    /**
     * Entity type: ReplenishmentProposalResult
     */
    ID: number;
    /**
     * Entity type: ReplenishmentProposal
     */
    ReplenishmentProposalID: number;
    /**
     * Entity type: OrganizationUnit
     */
    SourceOrganizationUnitID: number;
    /**
     * Entity type: OrganizationUnit
     */
    TargetOrganizationUnitID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    Quantity: number;
    SourceOrganizationUnit: EVA.Core.OrganizationUnitDto;
    TargetOrganizationUnit: EVA.Core.OrganizationUnitDto;
    Product: EVA.Core.ProductDto;
    ProductName: string;
    UnitCost?: number;
    TotalCost?: number;
    /**
     * Entity type: Currency
     */
    CurrencyID: string;
  }

  /**
   * List all `ReplenishmentProposal`'s.
   * 
   * Through the `PageConfig`'s `Filter` parameter, you have the following filter options available:
   * 
   * * `ID` for that specific `ReplenishmentProposal` you want
   * * `SourceIDs` and/or `TargetIDs` as `OrganizationUnit`.`ID`'s
   * * `CreatedAfter` and/or `CreatedBefore`
   * * `CreatedByName` (:underage: expensive filter, supports both `FirstName` and `LastName` filtering)
   */
  export interface ListReplenishmentProposals {
    PageConfig?: EVA.Core.PageConfig<ListReplenishmentProposalFilters>;
  }

  export interface ListReplenishmentProposalFilters {
    /**
     * Entity type: ReplenishmentProposal
     */
    ID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    SourceIDs: number[];
    /**
     * Entity type: OrganizationUnit
     */
    TargetIDs: number[];
    CreatedAfter?: string;
    CreatedBefore?: string;
    CreatedByName?: string;
  }

  export interface ListReplenishmentProposalsResponse {
    Result?: EVA.Core.PagedResult<ReplenishmentProposalListDto>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ReplenishmentProposalListDto {
    /**
     * Entity type: ReplenishmentProposal
     */
    ID: number;
    StatusID: number;
    /**
     * Entity type: User
     */
    CreatedByID: number;
    CreationTime: string;
    CreatedBy: EVA.Core.UserDto;
  }

  /**
   * Downloads an Excel for `UploadReplenishmentProductsExcel` service, filled with all currently existing records.
   * 
   * Specify either OrganizationUnitIDs or OrganizationUnitSetID. OrganizationUnitSetID takes precedence over OrganizationUnitIDs.
   * 
   * You can't download information for more than 1.000.000 product/organizationunit combinations.
   */
  export interface DownloadReplenishmentProductsExcel {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: OrganizationUnitSet
     */
    OrganizationUnitSetID?: number;
    /**
     * @default false
     */
    ShowInactive?: boolean;
    /**
     * Only show products that match this filter.
     */
    Filters?: { [key: string]: EVA.Core.FilterModel };
    /**
     * Will add empty rows for product/organizationunit combinations that do not exist yet.
     */
    AddPlaceHolderRows?: boolean;
  }

  /**
   * Uploads an Excel retrieved from `DownloadReplenishmentProductsExcel`.
   * 
   * Records with `ID` will be modified, records without `ID` will be added. Omitted records will not be modified.
   * 
   * If you add a record that already exists, but is not in the excel due to some filtering (ou or products), it will also be updated.
   */
  export interface UploadReplenishmentProductsExcel {
    Data: string;
  }

  /**
   * Creates a new ReplenishmentProduct.
   */
  export interface CreateReplenishmentProduct {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID: number;
    MinimumQuantity: number;
    MaximumQuantity: number;
    /**
     * Date, no time. Inclusive.
     */
    StartDate?: string;
    /**
     * Date, no time. Inclusive.
     */
    EndDate?: string;
  }

  export interface CreateReplenishmentProductResponse {
    /**
     * Entity type: ReplenishmentProduct
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Edits an existing ReplenishmentProduct.
   */
  export interface EditReplenishmentProduct {
    /**
     * Entity type: ReplenishmentProduct
     */
    ID: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
    /**
     * Entity type: Product
     */
    ProductID: number;
    /**
     * Entity type: StockLabel
     */
    StockLabelID: number;
    MinimumQuantity: number;
    MaximumQuantity: number;
    /**
     * Date, no time. Inclusive.
     */
    StartDate?: string;
    /**
     * Date, no time. Inclusive.
     */
    EndDate?: string;
  }

  /**
   * Deletes an existing ReplenishmentProduct.
   */
  export interface DeleteReplenishmentProduct {
    /**
     * Entity type: ReplenishmentProduct
     */
    ID: number;
  }

  /**
   * List the ReplenishmentProducts, optionally with a `PageConfig` with a `Filter`.
   */
  export interface ListReplenishmentProducts {
    PageConfig?: EVA.Core.PageConfig<ListReplenishmentProductsFilters>;
  }

  export interface ListReplenishmentProductsFilters {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitIDs?: number[];
    /**
     * Entity type: Product
     */
    ProductID?: number;
    /**
     * Entity type: Product
     */
    ProductIDs?: number[];
    /**
     * Entity type: StockLabel
     */
    StockLabelID?: number;
    /**
     * @default false
     */
    ShowInactive?: boolean;
  }

  export interface ListReplenishmentProductsResponse {
    /**
     * Additional properties that are returned with each product. It is guaranteed these are present for all products, but it might be an empty string.
     */
    AdditionalProperties: string[];
    Result?: EVA.Core.PagedResult<ListReplenishmentProductsResponse.ReplenishmentProduct>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListReplenishmentProductsResponse {
    export interface ReplenishmentProduct {
      /**
       * Entity type: ReplenishmentProduct
       */
      ID: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      OrganizationUnitBackendID?: string;
      /**
       * Entity type: Product
       */
      ProductID: number;
      ProductBackendID?: string;
      /**
       * Entity type: StockLabel
       */
      StockLabelID: number;
      MinimumQuantity: number;
      MaximumQuantity: number;
      /**
       * Date, no time. Inclusive.
       */
      StartDate?: string;
      /**
       * Date, no time. Inclusive.
       */
      EndDate?: string;
      /**
       * Additional properties for the product
       */
      AdditionalProperties: { [key: string]: string };
    }

  }

  /**
   * Imports a simple set of ReplenishmentProducts, creating new records and updating existing records.
   * 
   * Does not support `StartDate` and `EndDate`, and as such will error when existing records have these set.
   */
  export interface ImportReplenishmentProducts {
    Products: ImportReplenishmentProducts.ReplenishmentProduct[];
  }

  export namespace ImportReplenishmentProducts {
    export interface ReplenishmentProduct {
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      /**
       * Entity type: Product
       */
      ProductID: number;
      /**
       * Entity type: StockLabel
       */
      StockLabelID: number;
      MinimumQuantity: number;
      MaximumQuantity: number;
    }

  }

  /**
   * Retry generating a new `ReplenishmentProposal`.
   */
  export interface RetryReplenishmentProposal {
    /**
     * Entity type: ReplenishmentProposal
     */
    ID: number;
    /**
     * Optional parameter to override the standard output types for created replenishment proposals
     */
    OutputTypes?: ReplenishmentOutputTypes;
  }

}declare module EVA.Rituals {

  export namespace Errors {
    export const enum Rituals {
      /**
       * Emailing is not enabled.
       */
      ExportMailsToGoogleNotEnabled = 'Rituals:ExportMailsToGoogleNotEnabled',
      /**
       * User {0:number} is an employee account, it can't be loyalty member.
       */
      EmployeesCantBeLoyaltyMember = 'Rituals:EmployeesCantBeLoyaltyMember'
    }

    export const enum StockNotification {
      /**
       * Cannot find Consumercode for product {0:number}.
       */
      ProductNotFound = 'StockNotification:ProductNotFound'
    }

    export const enum RitualsEventWarehouseOrderExporter {
      /**
       * Setting `Rituals:EventWarehouse:WarehouseID` not configured.
       */
      WarehouseNotConfigured = 'RitualsEventWarehouseOrderExporter:WarehouseNotConfigured',
      /**
       * No lines to export.
       */
      NoLinesToExport = 'RitualsEventWarehouseOrderExporter:NoLinesToExport',
      /**
       * Failure parsing setting `Rituals:EventWarehouse:ShippingMethodMapper`.
       */
      ShippingMethodMappingFailure = 'RitualsEventWarehouseOrderExporter:ShippingMethodMappingFailure',
      /**
       * No shipping method.
       */
      NoShippingMethod = 'RitualsEventWarehouseOrderExporter:NoShippingMethod'
    }

    export const enum RitualsWarehouseDeterminator {
      /**
       * Could not determine country from ({0:string})
       */
      CouldNotDetermineCountry = 'RitualsWarehouseDeterminator:CouldNotDetermineCountry',
      /**
       * Could not determine warehouse for country ({0:string})
       */
      CouldNotDetermineWarehouseForCountry = 'RitualsWarehouseDeterminator:CouldNotDetermineWarehouseForCountry'
    }

    export const enum RitualsShipFromStoreEVAPay {
      /**
       * No positive open amount
       */
      NoPositiveOpenAmount = 'RitualsShipFromStoreEVAPay:NoPositiveOpenAmount',
      /**
       * EVAPay not loaded
       */
      NotLoaded = 'RitualsShipFromStoreEVAPay:NotLoaded',
      /**
       * EVAPay not configured
       */
      NotConfigured = 'RitualsShipFromStoreEVAPay:NotConfigured',
      /**
       * Order has no customer attached
       */
      NoCustomer = 'RitualsShipFromStoreEVAPay:NoCustomer'
    }

    export const enum LiFungOrderProcessor {
      /**
       * Shipping method {0:string} could not be found.
       */
      ShippingMethodNotFound = 'LiFungOrderProcessor:ShippingMethodNotFound',
      /**
       * Tracking number is empty.
       */
      TrackingNumberEmpty = 'LiFungOrderProcessor:TrackingNumberEmpty',
      /**
       * Payment type {0:string} could not be found.
       */
      PaymentTypeNotFound = 'LiFungOrderProcessor:PaymentTypeNotFound',
      /**
       * Open amount {0:number} is expected to be 0.
       */
      OpenAmountNotZero = 'LiFungOrderProcessor:OpenAmountNotZero',
      /**
       * Bundle product {0:string} is not valid.
       */
      InvalidBundleProduct = 'LiFungOrderProcessor:InvalidBundleProduct'
    }

    export const enum CreateDemandwareOrders {
      /**
       * Cannot determine pickup store because the store number is unavailable
       */
      CannotDeterminePickupStore = 'CreateDemandwareOrders:CannotDeterminePickupStore',
      /**
       * Was unable to find a pickup store for store number {0:string}
       */
      PickupStoreNotFound = 'CreateDemandwareOrders:PickupStoreNotFound',
      /**
       * Was unable to determine origin of the order
       */
      CannotDetermineOrderOrigin = 'CreateDemandwareOrders:CannotDetermineOrderOrigin',
      /**
       * The open amount on the order {demandwareOrderNumber:string} is supposed to be zero, but it was {openAmount:number}
       */
      OpenAmountNotZero = 'CreateDemandwareOrders:OpenAmountNotZero',
      /**
       * Could not set the pickup store to {0:string}.
       */
      CouldNotSetPickupStore = 'CreateDemandwareOrders:CouldNotSetPickupStore',
      /**
       * Could not find the shipping method {0:string}.
       */
      UnknownShippingMethod = 'CreateDemandwareOrders:UnknownShippingMethod',
      /**
       * Could not find shipping address.
       */
      UnknownShippingAddress = 'CreateDemandwareOrders:UnknownShippingAddress'
    }

    export const enum AX {
      /**
       * Missing `BackendID` for CashExpenseType {0:number} and no default was specified.
       */
      MissingExpenseTypeMapping = 'AX:MissingExpenseTypeMapping'
    }

    export const enum Arvato {
      /**
       * Failed to fetch the required data from Arvato
       */
      FailedToFetchOrganization = 'Arvato:FailedToFetchOrganization',
      /**
       * Unknown EAN {0:string}
       */
      UnknownBarcode = 'Arvato:UnknownBarcode',
      /**
       * Unknown product in shipment for EAN {0:string}
       */
      UnknownProductInShipment = 'Arvato:UnknownProductInShipment'
    }

    export const enum ArvatoShipOrder {
      /**
       * Line {orderLineID:number} in order {orderID:number} requires a serial number, but it could not be found.
       */
      SerialNumberRequired = 'ArvatoShipOrder:SerialNumberRequired'
    }

    export const enum SOS {
      /**
       * Supplied BillingAddress and ShippingAddress cannot both be empty
       */
      AddressEmpty = 'SOS:AddressEmpty',
      /**
       * Order has no RitualsCartData set
       */
      NoCartDataSet = 'SOS:NoCartDataSet',
      /**
       * Invalid order
       */
      InvalidOrder = 'SOS:InvalidOrder',
      /**
       * Invalid order data
       */
      InvalidOrderData = 'SOS:InvalidOrderData'
    }

    export const enum Treazure {
      /**
       * Unable to authenticate to treazure.
       */
      UnableToAuthenticate = 'Treazure:UnableToAuthenticate',
      /**
       * An error occured trying to resolve the coupon.
       */
      ErrorResolvingCoupon = 'Treazure:ErrorResolvingCoupon',
      /**
       * Coupon is inactive
       */
      InactiveCoupon = 'Treazure:InactiveCoupon',
      /**
       * Coupon is expired
       */
      ExpiredCoupon = 'Treazure:ExpiredCoupon',
      /**
       * Coupon is expired
       */
      UnableToRedeemCoupon = 'Treazure:UnableToRedeemCoupon'
    }

  }


  /**
   * Print the certificate and bottle labels for Talisman products
   * 
   * The OrderID is required, by default all documents will be printed, except when the optional OrderLineID is specified. Then only the documents for that Talisman are printed.
   * 
   * It is required to specify if the certificat, the bottle label, or both should be printed. This is done by setting `PrintCertificate` and/or `PrintBottleLabel`.
   * 
   * The Station that has the required printers should be specified in the `StationID` property.
   */
  export interface RitualsPrintTalismanDocuments {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineID?: number;
    PrintCertificate?: boolean;
    PrintBottleLabel?: boolean;
    /**
     * Entity type: Station
     */
    StationID?: number;
  }

  /**
   * Retrieves SOS customer data from specified order, as indicated with an `OrderID`, set through `RitualsSetCartData`.
   */
  export interface RitualsGetCartData {
    /**
     * Entity type: Order
     */
    OrderID: number;
  }

  export interface RitualsGetCartDataResponse {
    Data: SOSOrderData;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface SOSOrderData {
    ClientID: string;
    PlatformID: string;
    PlatformType: PlatformTypes;
    BackendPlatformID: string;
    PaymentReminderSent: boolean;
    Data: { [key: string]: any };
  }

  export const enum PlatformTypes {
    Facebook = 0,
    WhatsApp = 1,
    Manual = 2,
    External = 3
  }

  /**
   * Retrieves currently known customer data, identified by a `Token` as generated by the `RitualsSendAddressFormLinkFromCart`/`RitualsSendPaazlLinkFromCart` service.
   */
  export interface RitualsGetCustomerData {
    Token?: string;
  }

  export interface RitualsGetCustomerDataResponse {
    FirstName: string;
    LastName: string;
    EmailAddress: string;
    PhoneNumber: string;
    Gender: string;
    BillingAddress: EVA.Core.AddressDataDto;
    ShippingAddress: EVA.Core.AddressDataDto;
    CountryID: string;
    LanguageID: string;
    Data: SOSOrderData;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Sends a link to a contact form to attach a SOS customer.
   * 
   * The contact form is specified through the `Url` and will be appended with a `token` GET parameter to authorize the recipient to modify the attached
   * customer for the order. Specify the order using an `OrderID`, and attach a text to this link using the `Text` parameter.
   */
  export interface RitualsSendAddressFormLinkFromCart {
    /**
     * Identifies the Order.
     * Entity type: Order
     */
    OrderID: number;
    Text: string;
    Url: string;
  }

  export interface SOSUrlResponse {
    Success: boolean;
    ErrorMessage: string;
    Message: string;
    Url: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Attaches a customer to an order identified by a `Token`, as generated by the `RitualsSendAddressFormLinkFromCart`/`RitualsSendPaazlLinkFromCart` service.
   */
  export interface RitualsAttachCustomerToOrder {
    Token: string;
    FirstName?: string;
    LastName?: string;
    EmailAddress?: string;
    PhoneNumber?: string;
    Gender?: string;
    /**
     * Entity type: Language
     */
    LanguageID?: string;
    /**
     * Entity type: Country
     */
    CountryID?: string;
    /**
     * Required when `ShippingAddress` is empty.
     */
    BillingAddress?: EVA.Core.AddressDataDto;
    /**
     * Required when `BillingAddress` is empty.
     */
    ShippingAddress?: EVA.Core.AddressDataDto;
    GreetingCard?: string;
    VatNumber?: string;
  }

  /**
   * Sends a carousel of products in the current cart, identified by `OrderID`. Specify `OrderLineIDs` to indicate the lines to
   * send, or leave undefined to send all products.
   * 
   * Requires SOS customer data to be set to the order (through `RitualsSetCartData`).
   */
  export interface RitualsSendCarouselFromCart {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: OrderLine
     */
    OrderLineIDs?: number[];
  }

  /**
   * Sends a link to a Paazl form to attach a SOS customer.
   * 
   * The Paazl form is specified through the `Url` and will be appended with a `token` GET parameter to authorize the recipient to modify the attached
   * customer for the order. Specify the order using `OrderID`, and attach a text to this link using the `Text` parameter.
   */
  export interface RitualsSendPaazlLinkFromCart {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Text?: string;
    Url?: string;
  }

  /**
   * Rituals wrapper around the `GetDeliveryOrderData` service, to support identification and authentication through a `Token`, as generated by the `RitualsSendAddressFormLinkFromCart`/`RitualsSendPaazlLinkFromCart` service.
   */
  export interface RitualsGetDeliveryOrderData {
    Token?: string;
  }

  /**
   * Rituals wrapper around the `PaazlGetShippingOptionsForOrder` service, to support identification and authentication through a `Token`, as generated by the `RitualsSendAddressFormLinkFromCart`/`RitualsSendPaazlLinkFromCart` service.
   */
  export interface RitualsPaazlGetShippingOptionsForOrder {
    Token?: string;
    ExtendedDeliveryDateDetails?: boolean;
  }

  /**
   * Rituals wrapper around the `PaazlUpdateShippingOptionsForOrder` service, to support identification and authentication through a `Token`, as generated by the `RitualsSendAddressFormLinkFromCart`/`RitualsSendPaazlLinkFromCart` service.
   */
  export interface RitualsPaazlUpdateShippingOptionsForOrder {
    Token?: string;
    ShippingOption?: EVA.Carrier.Paazl.PaazlShippingOption;
  }

  /**
   * Sends a payment link from the current cart, identified by `OrderID`. Requires SOS customer data to be set to the order (through `RitualsSetCartData`).
   * 
   * * With the `Url` parameter specified, that exact link will be sent.
   * 
   * This service will also queue a reminder message after X minutes, configured using the setting `Rituals:SOS:PaymentReminderMinutes`.
   */
  export interface RitualsSendPaymentLinkFromCart {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Text: string;
    Url: string;
  }

  /**
   * Sends a receipt of the current cart, identified by `OrderID`, optionally including specified `Text`.
   * 
   * Requires SOS customer data to be set to the order (through `RitualsSetCartData`).
   */
  export interface RitualsSendReceiptFromCart {
    /**
     * Entity type: Order
     */
    OrderID: number;
    IsSummary?: boolean;
    Text?: string;
  }

  /**
   * Attaches SOS customer data to specified order, as indicated with `OrderID`.
   * 
   * The Data object supports the following properties:
   * 
   * * `ClientID`, to store the unique identifier for the customer on a platform
   * * `PlatformID`, to store the unique identifier of the platform channel
   * * `PlatformType`, to the which type this platform is (currently 0 = Facebook (Messenger), 1 = WhatsApp)
   * * `PaymentReminderSent`, a boolean flag indicating if a reminder was sent already (to prevent multiple, EVA will manage this for you)
   * * `Data`, a free dictionary for any other data you may wanna store
   */
  export interface RitualsSetCartData {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Data?: SOSOrderData;
  }

  export interface RitualsCreateCustomerReturn {
    /**
     * Entity type: Order
     */
    OrderID: number;
    CustomerIdentifier: CustomerIdentifier;
    /**
     * Entity type: Order
     */
    TargetOrderID?: number;
    Lines: RitualsCreateCustomerReturn.LineModel[];
  }

  export namespace RitualsCreateCustomerReturn {
    export interface LineModel {
      /**
       * Entity type: OrderLine
       */
      ID: number;
      QuantityToReturn: number;
      Remark?: string;
      /**
       * Entity type: ReturnReason
       */
      ReturnReasonID?: number;
    }

  }

  export interface CustomerIdentifier {
    /**
     * Email address of the customer' order. Used for extra validation that the order really belongs to the customer.
     */
    EmailAddress?: string;
    /**
     * ZipCode of the shipping address of the customer' order. Used for extra validation that the order really belongs to the customer.
     */
    ZipCode?: string;
    /**
     * LastName of the customer. Used for extra validation that the order really belongs to the customer.
     */
    LastName?: string;
  }

  export interface RitualsCreateCustomerReturnResponse {
    /**
     * OrderID of the created return order
     * Entity type: Order
     */
    OrderID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Downloads a STEP file from the configured instance, optionally filtering out a specific product by `BackendID` (in case of file type 0).
   * 
   * The following STEP file types are supported;
   * 
   * - Products = 0
   * - ProductTypes = 1
   * - Ingredients = 2
   * - AncientRituals = 3
   * - Classifications = 4
   * - Stores = 5
   */
  export interface RitualsDownloadStepDefinition {
    FileTypeID?: RitualsDownloadStepDefinition.FileType;
    BackendID?: string;
  }

  export namespace RitualsDownloadStepDefinition {
    export const enum FileType {
      Products = 0,
      ProductTypes = 1,
      Ingredients = 2,
      AncientRituals = 3,
      Classifications = 4,
      Stores = 5
    }

  }

  export interface RitualsGetBlobsForReturn {
    /**
     * Entity type: Order
     */
    OrderID: number;
    CustomerIdentifier: CustomerIdentifier;
  }

  export interface RitualsGetBlobsForReturnResponse {
    Result: RitualsGetBlobsForReturnResponse.Model[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace RitualsGetBlobsForReturnResponse {
    export interface Model {
      Name: string;
      MimeType: string;
      BlobID: string;
      Url: string;
    }

  }

  /**
   * Get the stock counters for products that are non-stock but SECRETLY ARE STOCK ANYWAYS - MUHAHAHA!!!11
   * 
   * :warning: For debugging and support purposes only.
   */
  export interface RitualsGetNonStockProductStockCounters {
    /**
     * The warehouse to get the counters for.
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID: number;
  }

  export interface RitualsGetNonStockProductStockCountersResponse {
    Result: { [key: number]: number };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface RitualsGetOrderForReturn {
    /**
     * Can either be an order number that we got from Demandware (e.g. GL123123123) or an ID that matches an order in EVA.
     */
    OrderID: string;
    CustomerIdentifier: CustomerIdentifier;
  }

  export interface RitualsGetOrderForReturnResponse {
    Result: RitualsGetOrderForReturnResponse.OrderModel;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace RitualsGetOrderForReturnResponse {
    export interface OrderModel {
      /**
       * Entity type: Order
       */
      ID: number;
      Lines: RitualsGetOrderForReturnResponse.OrderLineModel[];
      /**
       * Entity type: User
       */
      CustomerID: number;
      CreationTime: string;
      InvoiceNumbers: string[];
      ReturnSets: RitualsGetOrderForReturnResponse.OrderLinesReturnSet[];
    }

    export interface OrderLinesReturnSet {
      /**
       * Entity type: OrderLine
       */
      OrderLineIDs: number[];
      /**
       * Entity type: OrderLine
       */
      RequiredOrderLineIDsToReturn: number[];
    }

    export interface OrderLineModel {
      ReturnableQuantity: number;
      IsReturnable: boolean;
      /**
       * Entity type: OrderLine
       */
      ID: number;
      Type: EVA.Core.OrderLineTypes;
      Description: string;
      /**
       * Entity type: OrderLine
       */
      ParentID?: number;
      /**
       * Entity type: Product
       */
      ProductID?: number;
      ProductVariation: { [key: string]: string };
      QuantityCancelled: number;
      QuantityOrdered: number;
      QuantityShipped: number;
      UnitPrice: number;
      UnitPriceInTax: number;
      TaxRate: number;
      TotalAmount: number;
      TotalAmountInTax: number;
      CurrencyID: string;
    }

  }

  /**
   * Service for retrieving data needed for RGC export
   */
  export interface GetRGCData {
    /**
     * Entity type: Order
     */
    ID: number;
  }

  export interface GetRGCResponse {
    OrderLineInfos: GetRGCResponse.OrderLineInfo[];
    ShipmentInfos: GetRGCResponse.ShipmentInfo[];
    GreetingCardText: string;
    /**
     * Entity type: Order
     */
    OriginatingOrderID?: number;
    GiftWrappingQuantity: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetRGCResponse {
    export interface OrderLineInfo {
      OptionID: string;
      CampaignID: string;
      CancellationReason: string;
      DiscountCouponCode: string;
      ProductGrundPrice: number;
      ProductImageUrl: string;
      ProductSetID: string;
      /**
       * Entity type: OrderLine
       */
      OrderLineID: number;
    }

    export interface ShipmentInfo {
      NotificationEmailAddress: string;
      NotificationPhoneNumber: string;
      /**
       * Entity type: Shipment
       */
      ShipmentID?: number;
    }

  }

  /**
   * Get the Rituals user data. When logged in as employee, specify the `UserID` parameter. As customer you'll always get your own user data.
   */
  export interface RitualsGetUserDataForUser {
    /**
     * Entity type: User
     */
    UserID?: number;
  }

  export interface RitualsGetUserDataForUserResponse {
    ContactID?: string;
    LoyaltyID?: string;
    LoyaltyEnabled: boolean;
    CanRedeemWelcomeGift: boolean;
    IsEmployee: boolean;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Generate station device barcode images on a background blob. Defaults to square size 300px and an offset of 50px.
   */
  export interface RitualsImportStationsBarcodes {
    /**
     * Entity type: Station
     */
    StationIDs?: number[];
    /**
     * Entity type: Blob
     */
    BackgroundBlobID: string;
    BarcodeSize?: number;
    BarcodeOffset?: number;
  }

  /**
   * List the store that are available for pickup in the area.
   * 
   * It is required to set the Latitude and Longitude in the PageConfig filter.
   * Next to that it is required to supply an `OrderID`, or a list of `Products`.
   * 
   * The page size `Limit` has a maximum value of `100` for this service.
   */
  export interface RitualsListAvailablePickupStores {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    Products?: RitualsListAvailablePickupStores.Product[];
    IncludeOrganizationUnitsWithoutStock?: boolean;
    IncludeRelatedStockReplacingProducts?: boolean;
    UpcomingOpeningHoursType?: RitualsListAvailablePickupStores.UpcomingOpeningHoursTypes;
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListByProximityFilter>;
  }

  export namespace RitualsListAvailablePickupStores {
    export const enum UpcomingOpeningHoursTypes {
      NextSevenDays = 0,
      CurrentWeek = 1
    }

    export interface Product {
      Consumercode: string;
      Quantity: number;
    }

  }

  export interface RitualsListAvailablePickupStoresResponse {
    Result?: EVA.Core.PagedResult<RitualsListAvailablePickupStoresResponse.Model>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace RitualsListAvailablePickupStoresResponse {
    export interface Model {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      BackendID: string;
      Name: string;
      Address: EVA.Core.AddressDto;
      Latitude: number;
      Longitude: number;
      EmailAddress: string;
      PhoneNumber: string;
      EstimatedPickupTime?: string;
      TimeZone: string;
      MerchantID: string;
      OpeningHours: RitualsListAvailablePickupStoresResponse.OpeningHour[];
      DistanceInKm: number;
      DistanceInMiles: number;
      UpcomingOpeningHours: EVA.Core.WeekOpeningsDto[];
      RegularOpeningHours: EVA.Core.RegularOpeningHours[];
    }

    export interface OpeningHour {
      DayOfWeek: string;
      StartTime: string;
      EndTime: string;
      Date?: string;
    }

  }

  /**
   * Request to remove all user related data for GDPR
   * 
   * Provide an EVA userid, or a GoogleContactID
   */
  export interface RitualsRequestPrivacyRemoval {
    /**
     * Entity type: User
     */
    UserID?: number;
    GoogleContactID?: string;
  }

  export interface RitualsScanLoyaltyCard {
    LoyaltyID: string;
  }

  export interface RitualsScanLoyaltyCardResponse {
    User: EVA.Core.UserDto;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Get the pre-set test cases
   */
  export interface RitualsAXMappingGetTestCases {
  }

  export interface RitualsAXMappingGetTestCasesResponse {
    TestCases: RitualsAXMappingTestCase[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface RitualsAXMappingTestCase {
    /**
     * Entity type: Order
     */
    OrderID: number;
    Description?: string;
    StoreID?: string;
    ShipperID?: string;
    TerminalID?: string;
    CustAccount?: string;
  }

  /**
   * Set the pre-set test cases
   */
  export interface RitualsAXMappingSetTestCases {
    TestCases: RitualsAXMappingTestCase[];
  }

  /**
   * Get the pre-set test cases (in Excel format)
   */
  export interface RitualsAXMappingGetTestCasesExcel {
  }

  /**
   * Set the pre-set test cases (in Excel format)
   */
  export interface RitualsAXMappingUploadTestCasesExcel {
    Data: string;
  }

  /**
   * Trigger the tests, using either the given list of test cases, or else the pre-set test cases
   */
  export interface RitualsAXMappingTest {
    TestCases?: RitualsAXMappingTestCase[];
  }

  export interface RitualsAXMappingTestResponse {
    Success: boolean;
    Results: RitualsAXMappingTestResult[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface RitualsAXMappingTestResult {
    Success: boolean;
    TestCase: RitualsAXMappingTestCase;
    Outcome: RitualsAXMappingTestCase;
  }

  /**
   * Updates the Rituals loyalty setting. When logged in as employee, specify the `UserID` parameter. As customer you'll always manage your own user setting.
   */
  export interface RitualsUpdateLoyalty {
    /**
     * Entity type: User
     */
    UserID?: number;
    Enabled: boolean;
  }

  export interface RitualsUpdateReturnOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    ExpectedPickupDate?: string;
    OrganizationUnitBackendID?: string;
    Lines: RitualsUpdateReturnOrder.Line[];
  }

  export namespace RitualsUpdateReturnOrder {
    export interface Line {
      CustomID: string;
      Quantity: number;
    }

  }

  /**
   * Backfills data for Rituals Google Cloud, by collecting data and sending it to you by mail.
   * 
   * The following types of data are supported:
   * 
   * * `SalesOrders` = 0
   * * `PurchaseOrders` = 1
   * * `Interbranch` = 2
   * * `CycleCounts` = 3
   * 
   * The service accepts these properties:
   * 
   * * `Type`: The type of data you want to collect (see above)
   * * `From` and `To`: The (inclusive) lower- and upper bound of data's `CreationTime` to backfill
   * * `Limit`: The maximum amount of orders overall to backfill (optional, when left empty, all data is collected)
   * * `Batch`: The maximum amount of orders to include in a single download file (optional, when left empty, all data will come in a single download)
   * * `Expire`: The amount of hours the download links are valid for (optional, defaults to 24 hours)
   * * `Preview`: Default false, but when set to true, no messages will be queued and no emails will be sent
   * 
   * As confirmation, this service will return the amount of data objects it will process, and the email address they will be sent to once complete.
   * 
   * :bath: This process may take a while!
   */
  export interface GoogleBackfill {
    Type: GoogleBackfillTypes;
    From: string;
    To: string;
    Limit?: number;
    Batch?: number;
    Expire?: number;
    Preview?: boolean;
  }

  export const enum GoogleBackfillTypes {
    SalesOrders = 0,
    PurchaseOrderCreated = 1,
    Interbranch = 2,
    CycleCounts = 3,
    PurchaseOrderShipped = 4,
    PurchaseOrderReceived = 5
  }

  export interface GoogleBackfillResponse {
    EmailAddress: string;
    Count: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * A specific implementation for `AddProductToOrder` for GiftCards. Adds a new order line for a digital GiftCard to specified order, where
   * `OrderID` identifies the current order for the customer and `Amount` is the desired amount to create a GiftCard for.
   * 
   * Optionally supply a `UpdateUrl` pointing to the website you want the buyer of the GiftCard to land to see/manage the order.
   * 
   * Additionally, the `Data` property need to be supplied;
   * 
   * * `From` and `To` are the names of the sender and recipient of this gift, respectively
   * * `Text` is an additional text to be included on the GiftCard and presented to the recipient (optional)
   * * `Theme` is an object describing the theme, style or 'ritual' desired for this GiftCard;
   *  * `ID` is a string identifying this theme
   *  * `Name` is it's name, for display
   *  * `Description` and `LongDescription` to describe the theme
   *  * `BackgroundColor` and `ForegroundColor` allow setting colors to the giftcard
   *  * `ImageUrl`, `ImageWidth` and `ImageHeight` describe the image used
   */
  export interface RitualsAddGiftCardToOrder {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Range: 1E-06-1000000
     */
    Amount: number;
    Data: EVA.Core.GiftCardData;
    UpdateUrl?: string;
    CloudinaryImageID?: string;
    CloudinaryImageMimeType?: string;
    CloudinaryVideoID?: string;
    CloudinaryVideoMimeType?: string;
  }

  /**
   * Generates a Apple Passbook compatible .pkpass file which is stored in Blob storage
   */
  export interface RitualsGeneratePassbookPass {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    AccessToken?: string;
    GiftCardID?: string;
  }

  /**
   * Apply the EmployeeDiscount to an Order. This service is called after a QR is scanned.
   */
  export interface RitualsApplyEmployeeDiscount {
    /**
     * Entity type: Order
     */
    OrderID: number;
    /**
     * Entity type: User
     */
    EmployeeID?: number;
  }

  /**
   * Get the info for the EmployeeDiscount.
   */
  export interface RitualsGetEmployeeDiscount {
    /**
     * Entity type: User
     */
    UserID?: number;
  }

  export interface RitualsGetEmployeeDiscountResponse {
    DiscountUsed: number;
    DiscountAvailable: number;
    DiscountTotal: number;
    QrCodeData: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface CreateDemandwareOrders {
    Orders?: DemandwareOrders;
  }

  export interface DemandwareOrders {
    Order: Order[];
  }

  export interface Order {
    Orderdate: string;
    Createdby: string;
    Originalorderno: string;
    Currency: string;
    Customerlocale: string;
    Taxation: string;
    Invoiceno: string;
    Customer: Customer;
    Status: Status;
    Currentorderno: string;
    Productlineitems: Productlineitems;
    Shippinglineitems: Shippinglineitems;
    Shipments: Shipments;
    Totals: Totals;
    Payments: Payments;
    Notes: Notes;
    Customattributes: Customattributes;
    Orderno: string;
    EInvoiceRecipientEmail: string;
    EInvoiceRecipientCode: string;
    EInvoicePublicProjectCode: string;
    EInvoiceTenderIdentificationCode: string;
  }

  export interface Customer {
    CustomerNo: string;
    Customername: string;
    Customeremail: string;
    Billingaddress: Billingaddress;
  }

  export interface Billingaddress {
    Salutation: string;
    Firstname: string;
    Secondname: string;
    Lastname: string;
    Companyname: string;
    Address1: string;
    Address2: string;
    City: string;
    Postalcode: string;
    Statecode: string;
    Countrycode: string;
    Phone: string;
    Customattributes: Customattributes;
  }

  export interface Customattributes {
    Customattribute: Customattribute[];
  }

  export interface Customattribute {
    Attributeid: string;
    Text: string;
  }

  export interface Status {
    Orderstatus: string;
    Shippingstatus: string;
    Confirmationstatus: string;
    Paymentstatus: string;
  }

  export interface Productlineitems {
    Productlineitem: Productlineitem[];
  }

  export interface Productlineitem {
    Netprice: string;
    Tax: string;
    Grossprice: string;
    Baseprice: string;
    Lineitemtext: string;
    Taxbasis: string;
    Position: string;
    ProductID: string;
    Productname: string;
    Quantity: Quantity;
    Taxrate: string;
    Shipmentid: string;
    Options: OptionLineItems;
    BundledProductLines: BundledProductLineItems;
    Gift: string;
    GiftMessage: string;
    Customattributes: Customattributes;
    Priceadjustments: Priceadjustments;
  }

  export interface Quantity {
    Unit: string;
    Text: string;
  }

  export interface OptionLineItems {
    Items: OptionLineItem[];
  }

  export interface OptionLineItem {
    Netprice: string;
    Tax: string;
    Grossprice: string;
    Baseprice: string;
    Lineitemtext: string;
    Taxbasis: string;
    OptionId: string;
    ValueId: string;
    ProductID: string;
    RelatedProductID: string;
    Customattributes: Customattributes;
  }

  export interface BundledProductLineItems {
    BundledProductLine: BundledProductLineItem[];
  }

  export interface BundledProductLineItem {
    Netprice: string;
    Tax: string;
    Grossprice: string;
    Baseprice: string;
    Lineitemtext: string;
    Taxbasis: string;
    Position: string;
    ProductID: string;
    Productname: string;
    Quantity: Quantity;
    Taxrate: string;
    Shipmentid: string;
    Options: OptionLineItems;
    BundledProductLines: BundledProductLineItems;
    Gift: string;
    GiftMessage: string;
    Customattributes: Customattributes;
    Priceadjustments: Priceadjustments;
  }

  export interface Priceadjustments {
    Priceadjustment: Priceadjustment[];
  }

  export interface Priceadjustment {
    Netprice: string;
    Tax: string;
    Grossprice: string;
    Baseprice: string;
    Lineitemtext: string;
    Taxbasis: string;
    Promotionid: string;
    Campaignid: string;
    Couponid: string;
    Customattributes: Customattributes;
  }

  export interface Shippinglineitems {
    Shippinglineitem: Shippinglineitem[];
  }

  export interface Shippinglineitem {
    Netprice: string;
    Tax: string;
    Grossprice: string;
    Baseprice: string;
    Lineitemtext: string;
    Taxbasis: string;
    Itemid: string;
    Shipmentid: string;
    Taxrate: string;
    Priceadjustments: Priceadjustments;
  }

  export interface Shipments {
    Shipment: Shipment[];
  }

  export interface Shipment {
    Status: Status;
    Shippingmethod: string;
    Shippingaddress: Shippingaddress;
    Gift: string;
    GiftMessage: string;
    Totals: Totals;
    Shipmentid: string;
  }

  export interface Shippingaddress {
    Salutation: string;
    Firstname: string;
    Secondname: string;
    Lastname: string;
    Companyname: string;
    Address1: string;
    Address2: string;
    City: string;
    Postalcode: string;
    Statecode: string;
    Countrycode: string;
    Phone: string;
    Customattributes: Customattributes;
  }

  export interface Totals {
    Merchandizetotal: Merchandizetotal;
    Adjustedmerchandizetotal: Adjustedmerchandizetotal;
    Shippingtotal: Shippingtotal;
    Adjustedshippingtotal: Adjustedshippingtotal;
    Shipmenttotal: Shipmenttotal;
    Ordertotal: Ordertotal;
  }

  export interface Merchandizetotal {
    Netprice: string;
    Tax: string;
    Grossprice: string;
    Priceadjustments: Priceadjustments;
  }

  export interface Adjustedmerchandizetotal {
    Netprice: string;
    Tax: string;
    Grossprice: string;
  }

  export interface Shippingtotal {
    Netprice: string;
    Tax: string;
    Grossprice: string;
    Priceadjustments: Priceadjustments;
  }

  export interface Adjustedshippingtotal {
    Netprice: string;
    Tax: string;
    Grossprice: string;
  }

  export interface Shipmenttotal {
    Netprice: string;
    Tax: string;
    Grossprice: string;
  }

  export interface Ordertotal {
    Netprice: string;
    Tax: string;
    Grossprice: string;
  }

  export interface Payments {
    Payment: Payment[];
  }

  export interface Payment {
    Custommethod: Custommethod;
    Amount: string;
    Processorid: string;
    Transactionid: string;
  }

  export interface Custommethod {
    Methodname: string;
  }

  export interface Notes {
    Note: Note[];
  }

  export interface Note {
    Subject: string;
    Text: string;
  }

  export interface CreateDemandwareOrdersResponse {
    OrderSets: CreateDemandwareOrdersResponse.OrderSetsModel;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace CreateDemandwareOrdersResponse {
    export interface OrderSetModel {
      /**
       * Entity type: Order
       */
      EVAOrderID: number;
      DemandwareOrderNo: string;
    }

    export interface OrderSetsModel {
      OrderSet: CreateDemandwareOrdersResponse.OrderSetModel[];
    }

  }

  export interface ArvatoCreatePurchaseOrderReceipt {
    BackendOrderID?: string;
    PurchaseOrderLines?: ArvatoCreatePurchaseOrderReceiptLine[];
  }

  export interface ArvatoCreatePurchaseOrderReceiptLine {
    BackendPurchaseOrderLineID: string;
    Receipts: ArvatoCreatePurchaseOrderReceiptLineReceipt[];
  }

  export interface ArvatoCreatePurchaseOrderReceiptLineReceipt {
    QuantityReceived: number;
    StockLocationID: string;
  }

  export interface ArvatoCreateShipmentStatus {
    Items: ArvatoCreateShipmentStatus.Item[];
  }

  export namespace ArvatoCreateShipmentStatus {
    export interface Item {
      /**
       * EVA `Order.ID`, allowing grace for an 'E' or 'ET' prefix. Required when `ShipmentID` is empty.
       */
      OrderID?: string;
      /**
       * EVA `Shipment.BackendID`. Required when `OrderID` is empty.
       */
      ShipmentID?: string;
      CurrentStatus: ArvatoCreateShipmentStatus.Status;
    }

    export interface Status {
      Date: string;
      CarrierCode: string;
      Description: string;
    }

  }

  export interface ArvatoCreateStockMutation {
    WarehouseID?: string;
    DestinationWarehouseID?: string;
    Mutations?: ArvatoStockMutation[];
  }

  export interface ArvatoStockMutation {
    EAN: string;
    Quantity: number;
    Type: string;
    SourceStorageLocation: string;
    DestinationStorageLocation: string;
  }

  export interface ArvatoShipmentReceiptConfirmation {
    WarehouseID?: string;
    BackendID?: string;
    Lines: ArvatoShipmentReceiptConfirmation.Line[];
  }

  export namespace ArvatoShipmentReceiptConfirmation {
    export interface Line {
      QuantityReceived: number;
      EAN: string;
    }

  }

  export interface ArvatoShipOrder {
    ShippingConfirmations?: ArvatoShipOrder.ArvatoShipOrderConfirmation[];
  }

  export namespace ArvatoShipOrder {
    export interface ArvatoShipOrderConfirmation {
      /**
       * Entity type: Order
       */
      EvaOrderID: number;
      Packages: ArvatoShipOrderConfirmation.ArvatoShipOrderPackage[];
      FinalShipment?: boolean;
      WarehouseID: string;
    }

    export namespace ArvatoShipOrderConfirmation {
      export interface ArvatoShipOrderPackage {
        BackendID: string;
        TrackingCode: string;
        TrackingUrl: string;
        CarrierCode: string;
        OrderLines: ArvatoShipOrderConfirmation.ArvatoShipOrderPackageOrderLine[];
      }

      export interface ArvatoShipOrderPackageOrderLine {
        /**
         * Entity type: OrderLine
         */
        EvaOrderLineID?: number;
        QuantityShipped?: number;
        SerialNumber?: string;
      }

    }

  }

  /**
   * Invoked by Arvato to notify EVA about shipment updates of the order.
   */
  export interface ArvatoUpdateOrder {
    /**
     * Entity type: Order
     */
    EvaOrderID: number;
    OrderLines?: ArvatoUpdateOrderLine[];
  }

  export interface ArvatoUpdateOrderLine {
    /**
     * Entity type: OrderLine
     */
    EvaOrderLineID: number;
    IsCancelled: boolean;
    IsPicked: boolean;
    IsPacked: boolean;
    Reason: string;
    ReasonID: string;
  }

  export interface ArvatoUpdateStock {
    WarehouseID?: string;
    Stock?: ArvatoUpdateStockLine[];
  }

  export interface ArvatoUpdateStockLine {
    EAN: string;
    QuantityAvailable: number;
  }

}declare module EVA.Symphony {

  export namespace Errors {
    export const enum OrderFulfillment {
      /**
       * It was not possible to split OrderLine {0:number} to complete the partial cancellation of the OrderLine's fulfillment
       */
      SplitOrderLineFailed = 'OrderFulfillment:SplitOrderLineFailed',
      /**
       * It's not currently allowed to partially cancel an OrderLine fulfillment, this is controlled by the setting `OrderFulfillment:AllowPartialCancellation`.
       */
      PartialCancellationNotAllowed = 'OrderFulfillment:PartialCancellationNotAllowed'
    }

    export const enum Symphony {
      /**
       * The sheet could not be saved due to compile errors: {0:string}
       */
      CannotSaveSheetDueToCompileErrors = 'Symphony:CannotSaveSheetDueToCompileErrors',
      /**
       * Sheet {id:number} cannot be compiled, errors: {errors:string}
       */
      SheetNotCompiling = 'Symphony:SheetNotCompiling'
    }

  }


  export interface BuildSheet {
    AST: { [key: string]: any };
    Sheet: string;
  }

  export interface BuildSheetResult {
    CodeSnippet: string;
    Sheet: string;
    HasErrors: boolean;
    Errors: ParseSheetError[];
    CompletionSuggestions: CompletionSuggestion[];
    AST: { [key: string]: any };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ParseSheetError {
    Type: EVA.Core.ParsingErrorType;
    Message: string;
    SourceLine: string;
    SourceLineNumber: number;
    SourceColumn: number;
  }

  export interface CompletionSuggestion {
    Label: string;
    Code: string;
    Type: CompletionSuggestionType;
    Documentation: string;
  }

  export const enum CompletionSuggestionType {
    Variable = 0,
    Keyword = 1,
    Enum = 2
  }

  /**
   * Creates a new sheet. Will return an error if the provided sheet cannot be parsed sucessfully.
   */
  export interface CreateSheet {
    Sheet: string;
    IsActive?: boolean;
  }

  export interface CreateSheetResponse {
    /**
     * Entity type: Script
     */
    ID: number;
    HasErrors: boolean;
    Errors: ParseSheetError[];
    CompletionSuggestions: CompletionSuggestion[];
    AST: { [key: string]: any };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Deletes a sheet.
   */
  export interface DeleteSheet {
    /**
     * Entity type: Script
     */
    ID: number;
  }

  /**
   * Retrieves the completion options for the provided node that is part of the provided AST.
   * 
   * If no AST is provided this service will return the completion options that a new sheet would have.
   * 
   * The completion options consist of three possible values:
   * 
   * - Alternatives: with which nodes can the requested node be replaced?
   * - NextStatements: if the node is a statement, which statements can come after it?
   * - SelfCompletion: if a node contains child nodes, what are the possible node types for those children?
   */
  export interface GetNodeCompletionOptions {
    AST?: { [key: string]: any };
    NodeID?: number;
  }

  export interface GetNodeCompletionOptionsResponse {
    Result: NodeCompletionResult;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface NodeCompletionResult {
    Alternatives: NodeCompletionResult.ICompletionNode[];
    NextStatements: NodeCompletionResult.ICompletionNode[];
    SelfCompletion: any;
  }

  export namespace NodeCompletionResult {
    export interface ICompletionNode {
      NodeType: EVA.Core.NodeTypes;
    }

  }

  /**
   * Returns the available documentation at the provided position (column/line number) in the sheet.
   */
  export interface GetSheetDocumentation {
    /**
     * The sheet that you would like to have documentation for
     */
    Sheet: string;
    /**
     * The 1-based column number of the position in the sheet that you would like documentation for.
     * Min: 1
     */
    Column: number;
    /**
     * The 1-based line number of the position in the sheet that you would like documentation for.
     * Min: 1
     */
    Line: number;
  }

  export interface GetSheetDocumentationResponse {
    /**
     * The documentation for the requested position. Will be null if there is no available documentation.
     */
    Documentation?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Returns a list of revisions for a specific sheet.
   */
  export interface ListSheetHistory {
    /**
     * ID of the sheet
     * Entity type: Sheet
     */
    ID: number;
    InitialPageConfig?: EVA.Core.PageTokenConfig<ListSheetHistoryFilter>;
    PageToken?: string;
  }

  export interface ListSheetHistoryFilter {
  }

  export interface ListSheetHistoryResponse {
    Results?: ListSheetHistoryItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListSheetHistoryItem {
    /**
     * Entity type: Script
     */
    ID: number;
    Revision: number;
    Name: string;
    Source: string;
    /**
     * Entity type: User
     */
    UserID: number;
    UserFullName: string;
    Date: string;
    IsActive?: boolean;
  }

  /**
   * Returns a list of sheets, optionally filtered.
   */
  export interface ListSheets {
    InitialPageConfig?: EVA.Core.PageTokenConfig<ListSheetsFilter>;
    PageToken?: string;
  }

  export interface ListSheetsFilter {
    /**
     * Entity type: Sheet
     */
    ID?: number;
    Name: string;
    Source: string;
    IsActive?: boolean;
  }

  export interface ListSheetsResponse {
    Results?: ListSheetItem[];
    PreviousPageToken?: string;
    NextPageToken?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface ListSheetItem {
    /**
     * Entity type: Script
     */
    ID: number;
    Name: string;
    Source: string;
    Revision: number;
    /**
     * Entity type: User
     */
    UserID: number;
    UserFullName: string;
    Date: string;
    IsActive?: boolean;
  }

  /**
   * Attempts to parse the provided sheet, returning whether or not it was successful, any errors and possibly autocomplete suggestions.
   */
  export interface ParseSheet {
    Sheet: string;
  }

  export interface ParseSheetResponse {
    HasErrors: boolean;
    Errors: ParseSheetError[];
    CompletionSuggestions: CompletionSuggestion[];
    AST: { [key: string]: any };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Provides the ability to do a what-if to see how the provided OrderID would be fulfilled.
   * 
   * This will use the existing sheets with the ability to specify additional new sheets (by not specifying an ID)
   * or modify an existing sheet (by providing the ID of an existing sheet).
   */
  export interface PreviewOrderFulfillment {
    /**
     * Entity type: Order
     */
    OrderID?: number;
    Order?: PreviewOrderFulfillment.OrderModel;
    Stock?: PreviewOrderFulfillment.StockModel;
    CurrentTimeOverride?: string;
    /**
     * Entity type: OrganizationUnit
     */
    SupplierOrganizationUnitIDs?: number[];
    /**
     * Entity type: Script
     */
    ScriptIDs?: number[];
    /**
     * Entity type: ProductPropertyType
     */
    IncludedFields?: string[];
    /**
     * If you specify sheets they will either be used as an additional sheet to consider when calculating order fulfillment, or as a replacement for an existing sheet based on whether the ID of the sheet is provided or not.
     * 
     * Specifying additional sheets can be used as a 'what-if' tool; what would happen to this order if I change this sheet to do this, etc.
     */
    Sheets?: PreviewOrderFulfillment.SheetToPreview[];
    /**
     * If specified as true the fulfillment preview will base its result on fulfillments that have already been created for the order. For example if the order has already been exported to a certain supplier
     * then the preview service will take that into account and not consider that supplier to be a fulfillment option anymore. If specified as false (the default) the service considers the order to be a clean slate
     * for which all options are still open.
     */
    UseCurrentFulfillments?: boolean;
  }

  export namespace PreviewOrderFulfillment {
    export interface StockModel {
      OverrideIsDelta: boolean;
      StockOverrides: PreviewOrderFulfillment.StockOverride[];
    }

    export interface StockOverride {
      /**
       * Entity type: Product
       */
      ProductID: number;
      /**
       * Entity type: OrganizationUnit
       */
      OrganizationUnitID: number;
      QuantityAvailable: number;
    }

    export interface OrderModel {
      /**
       * Entity type: OrganizationUnit
       */
      SoldFromOrganizationUnitID?: number;
      Lines: PreviewOrderFulfillment.OrderLineModel[];
      /**
       * Entity type: Address
       */
      ShippingAddressID?: number;
      /**
       * Entity type: Address
       */
      BillingAddressID?: number;
      /**
       * Entity type: User
       */
      CustomerID?: number;
    }

    export interface OrderLineModel {
      /**
       * Entity type: Product
       */
      ProductID: number;
      UnitPrice?: number;
      QuantityOrdered?: number;
      CommitmentStatus: EVA.Core.OrderLineCommitmentStatus;
      /**
       * Entity type: OrganizationUnit
       */
      FulfillmentOrganizationUnitID?: number;
    }

    export interface SheetToPreview {
      /**
       * Entity type: Script
       */
      ID?: number;
      Source: string;
    }

  }

  export interface PreviewOrderFulfillmentResponse {
    Fulfillments: PreviewOrderFulfillmentResponse.Fulfillment[];
    OrderLines: PreviewOrderFulfillmentResponse.OrderLineResult[];
    ValidSuppliers: PreviewOrderFulfillmentResponse.ValidSupplier[];
    Rejections: PreviewOrderFulfillmentResponse.OrganizationUnitFulfllmentRejection[];
    HasErrors: boolean;
    Errors: ParseSheetError[];
    CompletionSuggestions: CompletionSuggestion[];
    AST: { [key: string]: any };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace PreviewOrderFulfillmentResponse {
    export interface Fulfillment {
      Shipments: PreviewOrderFulfillmentResponse.Shipment[];
      Score: number;
      ScoreExplanation: FulfillmentScoreExplanation;
    }

    export interface Shipment {
      FulfillmentAction: string;
      Sheet: PreviewOrderFulfillmentResponse.Sheet;
      Supplier: PreviewOrderFulfillmentResponse.OrganizationUnit;
      OrderLines: PreviewOrderFulfillmentResponse.OrderLine[];
      Score?: number;
      Data: { [key: string]: any };
      ScoreExplanation: FulfillmentScoreExplanation;
    }

    export interface Sheet {
      /**
       * Entity type: Sheet
       */
      ID?: number;
      Name: string;
    }

    export interface OrganizationUnit {
      /**
       * Entity type: OrganizationUnit
       */
      ID: number;
      Name: string;
      BackendID: string;
    }

    export interface OrderLine {
      /**
       * Entity type: OrderLine
       */
      ID: number;
      Score: number;
      Quantity: number;
      ScoreExplanations: ScoreExplanation[];
    }

    export interface OrderLineResult {
      /**
       * Entity type: OrderLine
       */
      ID: number;
      TotalQuantityToShip: number;
      GroupID?: string;
      PotentialSuppliers: OrderLineResult.PotentialSupplier[];
      Product: any;
    }

    export namespace OrderLineResult {
      export interface PotentialSupplier {
        /**
         * Entity type: OrganizationUnit
         */
        OrganizationUnitID: number;
        Score: number;
        Sheet: string;
      }

    }

    export interface ValidSupplier {
      /**
       * Entity type: OrganizationUnit
       */
      SupplierID: number;
      SupplierName: string;
      FulfillmentMethod: string;
      Score: number;
      ScoreExplanations: ValidSupplier.ScoreExplanation[];
      /**
       * Entity type: OrderLine
       */
      FulfillableOrderLineIDs: number[];
    }

    export namespace ValidSupplier {
      export interface ScoreExplanation {
        /**
         * Entity type: OrderLine
         */
        OrderLineID: number;
        Score: number;
        Description: string;
        Expression: string;
        Variables: { [key: string]: any };
      }

    }

    export interface OrganizationUnitFulfllmentRejection {
      /**
       * Entity type: OrganizationUnit
       */
      SupplierOrganizationUnitID?: number;
      SupplierOrganizationUnitName?: string;
      FulfillmentMethods: OrganizationUnitFulfllmentRejection.FulfillmentMethod[];
    }

    export namespace OrganizationUnitFulfllmentRejection {
      export interface FulfillmentMethod {
        Name: string;
        Reasons: OrganizationUnitFulfllmentRejection.RejectionReason[];
      }

      export interface RejectionReason {
        Reason: string;
        Description: string;
        /**
         * Entity type: Product
         */
        ProductIDs: number[];
        /**
         * Entity type: OrderLine
         */
        OrderLineIDs: number[];
      }

    }

  }

  export interface ScoreExplanation {
    Description: string;
    Expression: string;
    PreviousScore: number;
    NewScore: number;
    DeltaScore: number;
    Variables: { [key: string]: any };
  }

  export interface FulfillmentScoreExplanation {
    Description: string;
    ScoreExplanations: ScoreExplanation[];
  }

  /**
   * Updates an existing sheet. Will return an error if the provided sheet cannot be parsed sucessfully.
   */
  export interface UpdateSheet {
    /**
     * Entity type: Sheet
     */
    ID: number;
    Sheet: string;
    IsActive?: boolean;
  }

}declare module EVA.Sync {

  /**
   * Compares synchronization file with current environment.
   */
  export interface CompareSynchronization {
    BlobUrl?: string;
    IncludeIdentical?: boolean;
  }

  export interface CompareSynchronizationResponse {
    Files?: CompareSynchronizationResponse.CompareSynchronizationFile[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace CompareSynchronizationResponse {
    export interface CompareSynchronizationFile {
      Name?: string;
      Data?: CompareSynchronizationResponse.CompareSynchronizationFileData[];
    }

    export interface CompareSynchronizationFileData {
      ID?: string;
      Description?: string;
      ObjectInfo?: { [key: string]: any };
      IsIdentical?: boolean;
      Values?: CompareSynchronizationResponse.CompareSynchronizationFileDataValue[];
    }

    export interface CompareSynchronizationFileDataValue {
      Type?: string;
      NewValue?: string;
      CurrentValue?: string;
      CanCompare?: boolean;
      CanSync?: boolean;
    }

  }

  /**
   * Creates a synchronization file. Compare with CompareSynchronization and upload with UploadSynchronization
   */
  export interface CreateSynchronization {
    Managers?: CreateSynchronization.CreateSynchronizationManager[];
  }

  export namespace CreateSynchronization {
    export interface CreateSynchronizationManager {
      Name?: string;
    }

  }

  export interface CreateSynchronizationResponse {
    BlobUrl?: string;
    ExpireDate?: string;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  /**
   * Returns available synchronization managers.
   */
  export interface GetAvailableSynchronizationManagers {
  }

  export interface GetAvailableSynchronizationManagersResponse {
    Managers?: GetAvailableSynchronizationManagersResponse.Manager[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetAvailableSynchronizationManagersResponse {
    export interface Manager {
      Name?: string;
    }

  }

  /**
   * Import data stored in provided synchronization file. Provide a list of data IDs that should be imported.
   */
  export interface UploadSynchronization {
    BlobUrl?: string;
    Import?: UploadSynchronization.FileDataToImport[];
  }

  export namespace UploadSynchronization {
    export interface FileDataToImport {
      ID?: string;
      Values?: FileDataToImport.FileDataToImportValue[];
    }

    export namespace FileDataToImport {
      export interface FileDataToImportValue {
        Type?: string;
        Value?: string;
      }

    }

  }

  export interface UploadSynchronizationResponse {
    NumProcessed?: number;
    Processed?: UploadSynchronizationResponse.UploadSynchronizationResult[];
    Errors?: string[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace UploadSynchronizationResponse {
    export interface UploadSynchronizationResult {
      Type?: string;
      ID?: string;
      IsSuccess?: boolean;
      ErrorDescription?: string;
      IsNew?: boolean;
    }

  }

}declare module EVA.Waldo {

  export interface CreateOrderStatus {
    Description: string;
    BackendID?: string;
    Script: string;
    ScriptLanguage: string;
    Sequence: number;
    Once?: boolean;
  }

  export interface CreateOrderStatusResponse {
    /**
     * Entity type: OrderDefinition
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface UpdateOrderStatus {
    /**
     * Entity type: OrderDefinition
     */
    ID: number;
    Description: string;
    BackendID?: string;
    Script: string;
    ScriptLanguage: string;
    Sequence: number;
    Once?: boolean;
  }

  export interface DeleteOrderStatus {
    /**
     * Entity type: OrderDefinition
     */
    ID: number;
  }

  export interface GetOrderStatus {
    /**
     * Entity type: OrderDefinition
     */
    ID: number;
  }

  export interface GetOrderStatusResponse {
    Description: string;
    BackendID: string;
    Script: string;
    ScriptLanguage: string;
    Sequence: number;
    Once: boolean;
    Translations: GetOrderStatusResponse.TranslationModel[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetOrderStatusResponse {
    export interface TranslationModel {
      LanguageID: string;
      CountryID: string;
      Title: string;
      Subtitle: string;
    }

  }

  export interface ListOrderStatuses {
    PageConfig?: EVA.Core.PageConfig<OrderDefinitionFilter>;
  }

  export interface OrderDefinitionFilter {
    BackendID?: string;
    Description?: string;
    IncludeDeleted?: boolean;
  }

  export interface ListOrderStatusesResponse {
    Result?: EVA.Core.PagedResult<ListOrderStatusesResponse.Model>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListOrderStatusesResponse {
    export interface Model {
      /**
       * Entity type: OrderDefinition
       */
      ID: number;
      Description: string;
      BackendID?: string;
      Script: string;
      ScriptLanguage: string;
      Sequence: number;
      Once: boolean;
    }

  }

  export interface CreateOrUpdateOrderStatusTranslation {
    /**
     * Entity type: OrderDefinition
     */
    StatusID: number;
    LanguageID?: string;
    CountryID?: string;
    Title: string;
    Subtitle?: string;
  }

  export interface DeleteOrderStatusTranslation {
    /**
     * Entity type: OrderDefinition
     */
    StatusID: number;
    LanguageID?: string;
    CountryID?: string;
  }

  export interface CreateOrderType {
    Description: string;
    BackendID?: string;
    Script: string;
    ScriptLanguage: string;
    Sequence: number;
    Once?: boolean;
  }

  export interface CreateOrderTypeResponse {
    /**
     * Entity type: OrderDefinition
     */
    ID: number;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export interface UpdateOrderType {
    /**
     * Entity type: OrderDefinition
     */
    ID: number;
    Description: string;
    BackendID?: string;
    Script: string;
    ScriptLanguage: string;
    Sequence: number;
    Once?: boolean;
  }

  export interface DeleteOrderType {
    /**
     * Entity type: OrderDefinition
     */
    ID: number;
  }

  export interface GetOrderType {
    /**
     * Entity type: OrderDefinition
     */
    ID: number;
  }

  export interface GetOrderTypeResponse {
    Description: string;
    BackendID: string;
    Script: string;
    ScriptLanguage: string;
    Sequence: number;
    Once: boolean;
    Translations: GetOrderTypeResponse.TranslationModel[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetOrderTypeResponse {
    export interface TranslationModel {
      LanguageID: string;
      CountryID: string;
      Title: string;
      Subtitle: string;
    }

  }

  export interface ListOrderTypes {
    PageConfig?: EVA.Core.PageConfig<OrderDefinitionFilter>;
  }

  export interface ListOrderTypesResponse {
    Result?: EVA.Core.PagedResult<ListOrderTypesResponse.Model>;
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace ListOrderTypesResponse {
    export interface Model {
      /**
       * Entity type: OrderDefinition
       */
      ID: number;
      Description: string;
      BackendID?: string;
      Script: string;
      ScriptLanguage: string;
      Sequence: number;
      Once: boolean;
    }

  }

  export interface CreateOrUpdateOrderTypeTranslation {
    /**
     * Entity type: OrderDefinition
     */
    DefinitionID: number;
    LanguageID?: string;
    CountryID?: string;
    Title: string;
    Subtitle?: string;
  }

  export interface DeleteOrderTypeTranslation {
    /**
     * Entity type: OrderDefinition
     */
    DefinitionID: number;
    LanguageID?: string;
    CountryID?: string;
  }

  /**
   * Get the last orderstatus for a set of Orders
   */
  export interface GetOrderStatusForOrders {
    /**
     * Entity type: Order
     */
    OrderIDs?: number[];
  }

  export interface GetOrderStatusForOrdersResponse {
    /**
     * Entity type: Order
     */
    Results: { [key: number]: GetOrderStatusForOrdersResponse.Model };
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetOrderStatusForOrdersResponse {
    export interface Model {
      Description: string;
      BackendID: string;
      Title: string;
      Subtitle: string;
      CreationTime: string;
      Sequence: number;
      Data: { [key: string]: any };
    }

  }

  /**
   * @deprecated Use `GetOrderCustomStatusLedger`
   */
  export interface GetOrderStatusHistory {
    /**
     * Entity type: Order
     */
    OrderID?: number;
  }

  export interface GetOrderStatusHistoryResponse {
    Results: GetOrderStatusHistoryResponse.Model[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

  export namespace GetOrderStatusHistoryResponse {
    export interface Model {
      Description: string;
      BackendID: string;
      Title: string;
      Subtitle: string;
      CreationTime: string;
      Sequence: number;
      Data: { [key: string]: any };
    }

  }

}declare module EVA.Workforce {

  /**
   * Returns a list of employees with an active Role in the given organization unit
   */
  export interface ListEmployeesForOrganizationUnit {
    /**
     * Entity type: OrganizationUnit
     */
    OrganizationUnitID?: number;
    /**
     * Entity type: Role
     */
    RoleIDs?: number[];
  }

  export interface ListEmployeesForOrganizationUnitResponse {
    Users: EVA.Core.UserDto[];
    Error?: EVA.Core.ServiceError;
    Metadata?: EVA.Core.ResponseMessageMetadata;
  }

}