@springtree/eva-core/EVA.Core.d.ts

The EVA core typings

declare module EVA.Core {

  export namespace Errors {
    export namespace UserRequirements {
      export const Required = 'UserRequirements:Required';
    }

    export namespace Subscriptions {
      export const EmailAddressRequired = 'Subscriptions:EmailAddressRequired';
    }

    export namespace StockResources {
      export const NoResourcesProvided = 'StockResources:NoResourcesProvided';
      export const MissingResource = 'StockResources:MissingResource';
      export const UnknownStockResourceType = 'StockResources:UnknownStockResourceType';
      export const ResourceProductMismatch = 'StockResources:ResourceProductMismatch';
    }

    export namespace GiftWrapping {
      export const NoGreetingCardProduct = 'GiftWrapping:NoGreetingCardProduct';
    }

    export namespace ReceiveShipment {
      export const ShipmentClosed = 'ReceiveShipment:ShipmentClosed';
    }

    export namespace ProductBundles {
      export const InvalidProductSelection = 'ProductBundles:InvalidProductSelection';
      export const CannotChangeProductID = 'ProductBundles:CannotChangeProductID';
      export const DuplicateProductBundleLines = 'ProductBundles:DuplicateProductBundleLines';
      export const BundleProductRequired = 'ProductBundles:BundleProductRequired';
      export const OptionsRequired = 'ProductBundles:OptionsRequired';
      export const DefaultProductRequiredForMultipleOptions = 'ProductBundles:DefaultProductRequired';
      export const UnknownProduct = 'ProductBundles:UnknownProduct';
      export const DefaultProductRequiredForConfigurable = 'ProductBundles:DefaultProductRequiredForConfigurable';
      export const InvalidDefaultProduct = 'ProductBundles:InvalidDefaultProduct';
      export const ProductBundleIDOrBundleProductIDRequired = 'ProductBundles:ProductBundleIDOrBundleProductIDRequired';
    }

    export namespace CreatePayment {
      export const TaxCalculationFailed = 'CreatePayment:TaxCalculationFailed';
    }

    export namespace OrganizationUnit {
      export const MissingParentID = 'OrganizationUnit:MissingParentID';
      export const MissingName = 'OrganizationUnit:MissingName';
    }

    export namespace ModifyQuantityOrdered {
      export const CannotModifyQuantityOrdered = 'ModifyQuantityOrdered:CannotModifyQuantityOrdered';
    }

    export namespace OrderOrganizationUnits {
      export const InvalidOrganizationUnit = 'OrderOrganizationUnits:InvalidOrganizationUnit';
      export const InvalidApplication = 'OrderOrganizationUnits:InvalidApplication';
      export const InvalidOrganizationUnitType = 'OrderOrganizationUnits:InvalidOrganizationUnitType';
    }

    export namespace StockReservation {
      export const CannotReserveMoreThanOrdered = 'StockReservation:CannotReserveMoreThanOrdered';
    }

    export namespace Finance {
      export const NoOpenPeriod = 'Finance:NoOpenPeriod';
      export const PeriodIsAlreadyOpen = 'Finance:PeriodIsAlreadyOpen';
      export const PeriodUnavailable = 'Finance:PeriodUnavailable';
      export const NoPeriodToClose = 'Finance:NoPeriodToClose';
      export const PeriodIsHandledByAnotherUser = 'Finance:PeriodIsHandledByAnotherUser';
      export const PeriodClosingCashDifference = 'Finance:PeriodClosingCashDifference';
      export const OpenUserTasks = 'Finance:OpenUserTasks';
      export const ClockedInUsers = 'Finance:ClockedInUsers';
      export const SealbagNumberRequired = 'Finance:SealbagNumberRequired';
      export const AmountExceedsStationCashLimit = 'Finance:AmountExceedsStationCashLimit';
      export const AmountExceedsSafeCashLimit = 'Finance:AmountExceedsSafeCashLimit';
      export const MissingTaxRate = 'Finance:MissingTaxRate';
      export const OpenCashJournal = 'Finance:OpenCashJournal';
    }

    export namespace FinancialPeriodClosingImpediments {
      export const ActiveUserTasks = 'FinancialPeriodClosingImpediments:ActiveUserTasks';
      export const OpenCashJournals = 'FinancialPeriodClosingImpediments:OpenCashJournals';
    }

    export namespace FinancialPeriods {
      export const MissingFinancialPeriod = 'FinancialPeriods:NoFinancialPeriod';
    }

    export namespace OpenFinancialPeriod {
      export const PeriodAlreadyOpened = 'OpenFinancialPeriod:PeriodAlreadyOpened';
    }

    export namespace CloseFinancialPeriod {
      export const NotOpen = 'CloseFinancialPeriod:PeriodNotOpen';
    }

    export namespace CashServices {
      export const InvalidTotalAmount = 'CashServices:InvalidTotalAmount';
    }

    export namespace Cash {
      export const TooMuchPrecision = 'Cash:TooMuchPrecision';
    }

    export namespace CashCorrections {
      export const RemarkIsRequired = 'CashCorrections:RemarkIsRequired';
    }

    export namespace OpenCashJournal {
      export const FinancialPeriodNotOpened = 'OpenCashJournal:FinancialPeriodNotOpened';
      export const AlreadyOpen = 'OpenCashJournal:AlreadyOpened';
      export const UnexplainedOpeningDeviation = 'OpenCashJournal:UnexplainedOpeningDeviation';
    }

    export namespace CloseCashJournal {
      export const ExceedsCashLimit = 'CloseCashJournal:ExceedsCashLimit';
      export const UnexplainedClosingDeviation = 'CloseCashJournal:UnexplainedClosingDeviation';
    }

    export namespace CashJournal {
      export const InvalidOrganizationUnit = 'CashJournal:InvalidOrganizationUnit';
      export const InvalidDevice = 'CashJournal:InvalidDevice';
      export const NoOpenCashJournal = 'CashJournal:NoOpenCashJournal';
    }

    export namespace MoveCash {
      export const InvalidDevices = 'MoveCash:InvalidDevice';
      export const InvalidAmount = 'MoveCash:InvalidAmount';
    }

    export namespace Printing {
      export const PrinterNotFound = 'Printing:PrinterNotFound';
      export const MissingHost = 'Printing:MissingHostName';
      export const MissingNetworkName = 'Printing:MissingNetworkName';
      export const FailureConvertingPDF2PCL = 'Printing:FailureConvertingPDF2PCL';
      export const PrintingFailed = 'Printing:PrintFailure';
      export const ProxyPrintingFailed = 'Printing:PrintFailure';
    }

    export namespace Stations {
      export const StationRequired = 'Stations:StationRequired';
      export const InvalidStation = 'Stations:InvalidStation';
    }

    export namespace Users {
      export const CanOnlyGeneratePINForEmployee = 'Users:CanOnlyGeneratePINForEmployee';
      export const DuplicateIdentificationPIN = 'Users:DuplicateIdentificationPIN';
      export const EmailAddressInUse = 'Users:EmailAddressInUse';
      export const NicknameInUse = 'Users:NicknameInUse';
      export const PasswordRequired = 'Users:PasswordRequired';
      export const InvalidEmailAddress = 'Users:InvalidEmailAddress';
      export const UserNotFoundByEmailAddress = 'Users:UserNotFoundByEmailAddress';
      export const PasswordResetTokenInvalid = 'Users:PasswordResetTokenInvalid';
      export const PasswordResetTokenAlreadyUsed = 'Users:PasswordResetTokenAlreadyUsed';
      export const PasswordPolicyViolation = 'Users:PasswordPolicyViolation';
    }

    export namespace Security {
      export const Unauthorized = 'Security:Unauthorized';
    }

    export namespace CycleCount {
      export const SelectProduct = 'CycleCount:SelectProduct';
      export const SelectOrganizationUnit = 'CycleCount:SelectOrganizationUnit';
      export const InvalidCycleCountProduct = 'CycleCount:InvalidCycleCountProduct';
      export const InvalidCycleCountOrganization = 'CycleCount:InvalidCycleCountOrganization';
      export const TooManyResults = 'CycleCount:TooManyResults';
    }

    export namespace Login {
      export const UsernameRequired = 'Login:UsernameRequired';
      export const CustomAuthenticationFailed = 'Login:CustomAuthenticationFailed';
      export const InvalidClientVersion = 'Login:InvalidClientVersion';
      export const ApplicationIDRequired = 'Login:ApplicationIDRequired';
    }

    export namespace OrderLine {
      export const CannotModifyQuantity = 'OrderLine:CannotModifyQuantity';
      export const InvalidSplitQuantity = 'OrderLine:InvalidSplitQuantity';
      export const AlreadyShipped = 'OrderLine:AlreadyShipped';
      export const ProductRequiredToMutatePrice = 'OrderLine:ProductRequiredToMutatePrice';
      export const ProductRequiresCustomPricingToMutatePrice = 'OrderLine:ProductRequiresCustomPricingToMutatePrice';
    }

    export namespace Shipment {
      export const CannotFullyReceiveCompletedOrder = 'Shipment:CannotFullyReceiveCompletedOrder';
      export const ShipmentAlreadyExists = 'Shipment:ShipmentAlreadyExists';
      export const CanOnlyShipPurchaseOrders = 'Shipment:CanOnlyShipPurchaseOrders';
      export const OrderWithFullDetailsRequired = 'Shipment:OrderWithFullDetailsRequired';
      export const ShipFromOrganizationUnitMismatch = 'Shipment:ShipFromOrganizationUnitMismatch';
    }

    export namespace WishList {
      export const CannotConvertInterbranchOrder = 'WishList:CannotConvertInterbranchOrder';
      export const CannotConvertRMAOrder = 'WishList:CannotConvertRMAOrder';
    }

    export namespace Payment {
      export const OrderRequired = 'Payment:OrderRequired';
      export const ScanStationBeforeInitiatingPayment = 'Payment:ScanStationBeforeInitiatingPayment';
      export const TransactionAlreadyConfirmed = 'Payment:TransactionAlreadyConfirmed';
    }

    export namespace Invoices {
      export const InvoiceCannotBeModified = 'Invoices:CannotBeModified';
    }

    export namespace Discount {
      export const InvalidConditionForAction = 'Discount:InvalidConditionForAction';
    }

    export namespace Products {
      export const DuplicateProduct = 'Products:DuplicateBackendID';
    }

    export namespace TaxRates {
      export const NotFoundForTaxCode = 'TaxRates:NotFoundForTaxCode';
    }

    export namespace CustomerOrderReturns {
      export const CannotCreateReturnsOnOrganizationUnit = 'CustomerOrderReturns:CannotCreateReturnsOnOrganizationUnit';
      export const OriginalOrderMustBeSalesOrder = 'CustomerOrderReturns:OriginalOrderMustBeSalesOrder';
    }

    export namespace Discounts {
      export const MalformedDiscountAction = 'Discounts:MalformedDiscountAction';
      export const InvalidDiscountCondition = 'Discounts:InvalidDiscountCondition';
      export const InvalidActionCondition = 'Discounts:InvalidActionCondition';
      export const DescriptionRequired = 'Discounts:DescriptionRequired';
      export const CurrencyRequired = 'Discounts:CurrencyRequired';
      export const ActionRequired = 'Discounts:ActionRequired';
      export const OrganizationUnitSetRequired = 'Discounts:OrganizationUnitSetRequired';
      export const LayerRequired = 'Discounts:LayerRequired';
      export const InvalidDateRange = 'Discounts:InvalidDateRange';
      export const DateTimeInvalidDaysValid = 'Discounts:DateTimeInvalidDaysValid';
      export const DateTimeInvalidDates = 'Discounts:DateTimeInvalidDates';
      export const OrderAmountInvalidMaximumAmount = 'Discounts:OrderAmountInvalidMaximumAmount';
      export const OrderAmountMissingAmounts = 'Discounts:OrderAmountMissingAmounts';
      export const OrderCharacteristicInvalidCharacteristics = 'Discounts:OrderCharacteristicInvalidCharacteristics';
      export const OrderHistoryInvalidDates = 'Discounts:OrderHistoryInvalidDates';
      export const OrganizationUnitIDsMissing = 'Discounts:OrganizationUnitIDsMissing';
      export const OrganizationUnitTypeMissing = 'Discounts:OrganizationUnitTypeMissing';
      export const InvalidMaximumOrderQuantity = 'Discounts:InvalidMaximumOrderQuantity';
      export const InvalidProductID = 'Discounts:InvalidProductID';
      export const InvalidProductSet = 'Discounts:InvalidProductSet';
      export const UserInvalidData = 'Discounts:UserInvalidData';
      export const UserRoleRequired = 'Discounts:UserRoleRequired';
      export const UserRoleInvalid = 'Discounts:UserRoleInvalid';
      export const UserTypeMissing = 'Discounts:UserTypeMissing';
      export const InvalidAmount = 'Discounts:InvalidAmount';
      export const InvalidMaxAmount = 'Discounts:InvalidMaxAmount';
      export const InvalidFixedAmount = 'Discounts:InvalidFixedAmount';
      export const InvalidBuyX = 'Discounts:InvalidBuyX';
      export const BuyXPayYNoActionCondition = 'Discounts:BuyXPayYNoActionCondition';
      export const InvalidFixedPriceAmount = 'Discounts:InvalidFixedPriceAmount';
      export const FixedPriceRequiresProductCondition = 'Discounts:FixedPriceRequiresProductCondition';
      export const FixedPriceProductConditionInvalidMinimumOrderQuantity = 'Discounts:FixedPriceProductConditionInvalidMinimumOrderQuantity';
      export const InvalidInsuranceMultiplier = 'Discounts:InvalidInsuranceMultiplier';
      export const InvalidPercentage = 'Discounts:InvalidPercentage';
      export const InvalidMaxPercentage = 'Discounts:InvalidMaxPercentage';
      export const InvalidFixedPercentage = 'Discounts:InvalidFixedPercentage';
      export const InvalidTierPercentage = 'Discounts:InvalidTierPercentage';
      export const InvalidTierQuantity = 'Discounts:InvalidTierQuantity';
      export const DuplicateTier = 'Discounts:DuplicateTier';
      export const PickProductNoTiers = 'Discounts:PickProductNoTiers';
      export const PickProductDuplicateTier = 'Discounts:PickProductDuplicateTier';
      export const PickProductMissingProducts = 'Discounts:PickProductMissingProducts';
      export const PickProductInvalidDefaultProductID = 'Discounts:PickProductInvalidDefaultProductID';
      export const PickProductInvalidConditionType = 'Discounts:PickProductInvalidConditionType';
      export const PickProductWrongOrderAmountCondition = 'Discounts:PickProductWrongOrderAmountCondition';
      export const ProductNotFound = 'Discounts:ProductNotFound';
      export const ProductInvalidType = 'Discounts:ProductInvalidType';
      export const ProductInvalidQuantity = 'Discounts:ProductInvalidQuantity';
      export const ProductInvalidUnitPrice = 'Discounts:ProductInvalidUnitPrice';
    }

    export namespace ReprintThermalPrintResult {
      export const InvalidBlob = 'ReprintThermalPrintResult:InvalidBlob';
    }

    export namespace ThermalPrinter {
      export const DeviceFailure = 'ThermalPrinter:DeviceFailure';
      export const TemplateNotFound = 'ThermalPrinter:TemplateNotFound';
      export const TemplateNotFoundOrDisabled = 'ThermalPrinter:TemplateNotFoundOrDisabled';
      export const NoPaper = 'ThermalPrinter:NoPaper';
      export const CoverOpen = 'ThermalPrinter:CoverOpen';
      export const Offline = 'ThermalPrinter:Offline';
    }

    export namespace Communications {
      export const TemplateNotFoundOrDisabled = 'Communications:TemplateNotFoundOrDisabled';
    }

    export namespace NF525 {
      export const CocNumberRequired = 'NF525:CocNumberRequired';
      export const BranchNumberRequired = 'NF525:BranchNumberRequired';
      export const VatNumberRequired = 'NF525:VatNumberRequired';
    }

    export namespace Orders {
      export const OrderDoesNotHaveRequiredType = 'Orders:OrderHasInvalidType';
    }

    export namespace UserTasks {
      export namespace Deactivate {
        export const UserTaskAlreadyCompleted = 'UserTasks:Deactivate:UserTaskAlreadyCompleted';
        export const Inactive = 'UserTasks:Deactivate:';
      }

      export namespace Start {
        export const UserTaskAlreadyCompleted = 'UserTasks:Start:UserTaskAlreadyCompleted';
        export const UserTaskInactive = 'UserTasks:Start:UserTaskNotActive';
        export const UserTaskRequiresFunctionality = 'UserTasks:Start:UserTaskRequiresFunctionality';
      }

      export namespace Complete {
        export const UserTaskAlreadyCompleted = 'UserTasks:Complete:UserTaskAlreadyCompleted';
        export const UserTaskInactive = 'UserTasks:Complete:UserTaskNotActive';
        export const UserTaskNotAttached = 'UserTasks:Complete:UserTaskNotAttached';
        export const UserNotAttachedToUserTask = 'UserTasks:Complete:UserNotAttachedToUserTask';
      }

    }

    export namespace PhoneBook {
      export const CannotDeletePrimaryPhoneNumber = 'PhoneBook:CannotDeletePrimaryPhoneNumber';
    }

    export namespace StockAllocations {
      export const OrganizationUnitRequired = 'StockAllocations:OrganizationUnitRequired';
      export const InvalidOrganizationUnit = 'StockAllocations:InvalidOrganizationUnit';
    }

    export namespace RenderThermalPrintResult {
      export const InvalidMimeType = 'RenderThermalPrintResult:InvalidMimeType';
    }

    export namespace DeleteCashDeposit {
      export const CashJournalAlreadyClosed = 'DeleteCashDeposit:CashJournalClosed';
      export const PeriodAlreadyClosed = 'DeleteCashDeposit:FinancialPeriodClosed';
    }

    export namespace DeleteCashExpense {
      export const CashJournalAlreadyClosed = 'DeleteCashExpense:CashJournalClosed';
      export const PeriodAlreadyClosed = 'DeleteCashExpense:FinancialPeriodClosed';
    }

  }


  export interface EmptyResponseMessage {
    Error: ServiceError;
  }

  export interface ServiceError {
    Message: string;
    Type: string;
    Code: string;
    RequestID: string;
  }

  export interface FilterModel {
    Values: any[];
    From: string;
    To: string;
    Negation: boolean;
    ExactMatch: boolean;
    IncludeMissing: boolean;
  }

  export interface PageConfig<T = { [key: string]: string }> {
    Filter: T;
    Start: number;
    Limit: number;
    SortProperty: string;
    SortDirection: SortDirection;
  }

  export const enum SortDirection {
    Ascending = 0,
    Descending = 1,
    NotSorted = 2
  }

  export interface PagedResult<TModel> {
    PageConfig: PageConfig;
    Page: TModel[];
    Offset: number;
    Limit: number;
    Total: number;
    SortProperty: string;
    SortDirection: SortDirection;
    Filters: { [key: string]: string };
    NumberOfPages: number;
    CurrentPage: number;
  }

  export interface EnumDto {
    ID: number;
    Name: string;
    Description: string;
  }

  export const enum ProductTypes {
    None = 0,
    Stock = 1,
    Marketing = 4,
    GiftCard = 8,
    Service = 16,
    GreetingCard = 32,
    CustomPricing = 64,
    External = 128,
    OrderCosts = 256,
    SystemGenerated = 512,
    ProductSet = 1024,
    BundleProduct = 2048,
    VirtualProduct = 4096,
    Configurable = 16384,
    SupplierProduct = 32768,
    Template = 65536
  }

  export interface IProductSearchItem {
    ID: number;
    BackendID: string;
    CustomID: string;
    DisplayValue: string;
    BrandName: string;
    Name: string;
    LogicalLevel: string;
    ConfigurableProperties: string[];
    Type: ProductTypes;
    Status?: ProductStatus;
    Unstackable: boolean;
    MaxQuantityPerOrder: number;
    Barcodes: string[];
    PublicationStatuses: string[];
    PrimaryImage: IProductSearchItemPrimaryImage;
    Media: IProductSearchItemProductMedia;
    Parents: number[];
    ParentHierarchy: number[];
    LogicalLevelHierarchy: ProductSearchItemLogicalLevelHierarchyEntry[];
    ProductRequirements: ProductSearchItemProductRequirementMetadata[];
    DisplayPrice?: number;
    OriginalPrice?: number;
    CurrencyID: string;
    TaxExemptionCode: string;
    TaxExemptionReason: string;
    ShortDescription: string;
    LongDescription: string;
  }

  export const enum ProductStatus {
    None = 0,
    PreRelease = 1,
    DeliveryOnly = 4,
    DisableDelivery = 8,
    DisablePickup = 16,
    DisableBackorder = 32,
    UseUp = 34
  }

  export interface IProductSearchItemPrimaryImage {
    Name: string;
    Type: string;
    Blob: string;
  }

  export interface IProductSearchItemProductMedia {
    PrimaryImage: IProductSearchItemPrimaryImage;
    Media: IProductSearchItemMediaEntry[];
    Gallery: string[];
    ImageCount: number;
  }

  export interface IProductSearchItemMediaEntry {
    Name: string;
    Type: string;
    Blob: string;
    ID: string;
    Sequence: number;
  }

  export interface ProductSearchItemLogicalLevelHierarchyEntry {
    ProductID: number;
    Name: string;
  }

  export interface ProductSearchItemProductRequirementMetadata {
    ID: number;
    Name: string;
    DataType: string;
    Data: { [key: string]: any };
    IsArray: boolean;
    IsRequired: boolean;
  }

  export interface StockResourceTypeDto {
    Name: string;
    IsUnique: boolean;
  }

  export const enum TemplateOutputChannel {
    Print = 1,
    Download = 2,
    Email = 4,
    Receipt = 8
  }

  export const enum DaysOfWeek {
    None = 0,
    Monday = 1,
    Tuesday = 2,
    Wednesday = 4,
    Thursday = 8,
    Friday = 16,
    Saturday = 32,
    Sunday = 64,
    All = 127
  }

  export interface UserTaskTypeDto {
    Configuration: string;
    ExpectedTimeToComplete?: string;
    DefaultPriority: number;
    ID: number;
    Name: string;
    Description: string;
  }

  export interface UserDto {
    ID: number;
    BackendRelationID: string;
    EmailAddress: string;
    Initials: string;
    FirstName: string;
    LastName: string;
    FullName: string;
    DateOfBirth?: string;
    PlaceOfBirth: string;
    Gender: string;
    ShippingAddressID: number;
    ShippingAddress: AddressDto;
    BillingAddressID: number;
    BillingAddress: AddressDto;
    Type: UserTypes;
    LanguageID: string;
    IsDeleted: boolean;
    Nickname: string;
    Company: CompanyDto;
    BankAccount: string;
    IsDebtor: boolean;
    SubscriptionType: SubscriptionTypes;
    PhoneNumber: string;
    GravatarHash: string;
    Data: { [key: string]: string };
    TimeZone: string;
    FiscalID: string;
    SocialSecurityNumber: string;
  }

  export interface AddressDto {
    ID: number;
    AddressedTo: string;
    Street: string;
    HouseNumber: string;
    Address1: string;
    Address2: string;
    City: string;
    ZipCode: string;
    Region: string;
    CountryID: string;
    Latitude?: number;
    Longitude?: number;
  }

  export const enum UserTypes {
    None = 0,
    Employee = 1,
    Customer = 2,
    Anonymous = 4,
    Business = 8,
    System = 17,
    Migrated = 32,
    Debtor = 64,
    LimitedTrust = 256,
    Tester = 512,
    RemovedByRequest = 1024
  }

  export interface CompanyDto {
    Name: string;
    RegistrationNumber: string;
    RegistrationCity: string;
    RegistrationCountryID: string;
    VatNumber: string;
    LegalFormID: number;
    VisitorsAddress: AddressDto;
    DeliveryAddress: AddressDto;
    ReturnsAddress: AddressDto;
    InvoiceAddress: AddressDto;
    InvoiceEmailAddress: string;
    EstablishedDate?: string;
    ContactEmailAddress: string;
    ContactPhoneNumber: string;
    AccountHolderName: string;
    IBAN: string;
    BIC: string;
    LogoID?: string;
  }

  export const enum SubscriptionTypes {
    None = 0,
    Newsletter = 1,
    Sms = 2
  }

  export interface OrganizationUnitDto {
    ID: number;
    BackendID: string;
    ParentID: number;
    VisibleByApplicationID: number;
    Name: string;
    Description: string;
    AddressID: number;
    Address: AddressDto;
    EmailAddress: string;
    PhoneNumber: string;
    Type: OrganizationUnitTypes;
    Status: OrganizationUnitStatus;
    OpeningHours: OpeningHoursDto[];
    Latitude?: number;
    Longitude?: number;
    CountryID: string;
  }

  export const enum OrganizationUnitTypes {
    None = 0,
    Shop = 1,
    WebShop = 2,
    Container = 4,
    Pickup = 8,
    Warehouse = 16,
    Country = 36,
    Franchise = 64,
    EVA = 128,
    TestOrganizationUnit = 256,
    DisableLogin = 512,
    Supplier = 1024,
    Consignment = 3072,
    B2b = 4096,
    Region = 8196
  }

  export const enum OrganizationUnitStatus {
    Default = 0,
    Open = 1,
    Closed = 2,
    OpeningSoon = 4,
    TemporarilyClosed = 8,
    Sale = 16,
    Hidden = 32
  }

  export interface OpeningHoursDto {
    ID: number;
    OrganizationUnitID: number;
    DayOfWeek?: DayOfWeek;
    ClosedForReceipts: boolean;
    StartTime?: string;
    EndTime?: string;
    Date?: string;
    Description: string;
    IsSpecial: boolean;
    IsClosed: boolean;
  }

  export const enum DayOfWeek {
    Sunday = 0,
    Monday = 1,
    Tuesday = 2,
    Wednesday = 3,
    Thursday = 4,
    Friday = 5,
    Saturday = 6
  }

  export interface FinancialPeriodDto {
    ID: number;
    OpeningTime?: string;
    ClosingTime?: string;
    Status: FinancialPeriodStatus;
    OrganizationUnitID: number;
    UserID: number;
    CurrencyID: string;
    CostPriceCurrencyID: string;
  }

  export const enum FinancialPeriodStatus {
    Open = 0,
    Closing = 1,
    Closed = 2,
    Processed = 3,
    Pending = -1
  }

  export interface UserTaskDto {
    ID: number;
    UserID: number;
    User: UserDto;
    UserFullname: string;
    OrganizationUnitID: number;
    OrganizationUnit: OrganizationUnitDto;
    FinancialPeriodID: number;
    FinancialPeriod: FinancialPeriodDto;
    Type: UserTaskTypeDto;
    Priority: number;
    IsCompleted: boolean;
    IsActive: boolean;
    CreationTime?: string;
    Deadline?: string;
    ExpectedTimeToComplete?: string;
    StartTime?: string;
    CompletionTime?: string;
    Description: string;
  }

  export interface OrderDto {
    ID: number;
    BackendID: string;
    Type: OrderTypes;
    CustomerID: number;
    Customer: UserDto;
    CreatedByID: number;
    CreatedBy: UserDto;
    CreationTime?: string;
    Payments: PaymentTransactionDto[];
    ShippingAddressID: number;
    BillingAddressID: number;
    ShippingAddress: AddressDto;
    BillingAddress: AddressDto;
    Lines: OrderLineDto[];
    OfferExpirationDate?: string;
    TotalAmountInTax?: number;
    TotalAmountInvoiced?: number;
    /**
     * Obsolete
     */
    ForeignTotalAmountInTax?: number;
    TaxTable: TaxAmount[];
    IsCompleted: boolean;
    IsShipped: boolean;
    IsPaid: boolean;
    IsInvoiced: boolean;
    IsPlaced: boolean;
    Status: OrderStatus;
    HoldStatusID: number;
    Remark: string;
    CustomerOrderID: string;
    CustomerReference: string;
    TotalItems: number;
    /**
     * @deprecated This field is deprecated and should no longer be used.
     */
    Messages: DiscountInvalidReasons[];
    NeedsExtendedCustomerInformation: boolean;
    InvoiceDate?: string;
    HasDelivery: boolean;
    IdentificationID: number;
    SessionID: string;
    Characteristics: OrderCharacteristics;
    OriginatingOrganizationUnitID: number;
    /**
     * Obsolete: Use OriginatingOrganizationUnitID
     */
    OrganizationUnitID: number;
    PickupOrganizationUnitID: number;
    /**
     * @deprecated Use SoldFromOrganizationUnitID
     */
    SalesOrganizationUnitID: number;
    SoldFromOrganizationUnitID: number;
    ShipFromOrganizationUnitID: number;
    SoldToOrganizationUnitID: number;
    ShipToOrganizationUnitID: number;
    CurrencyID: string;
    CustomStatusID: number;
    PreferredPriceDisplayMode: OrderPreferredPriceDisplayMode;
    IsTaxExempt: boolean;
    FiscalID: string;
    VatNumber: string;
    UserAgentApplication: string;
    UserAgentVersion: string;
    AllowPartialFulfillment: boolean;
    PlacementDate?: string;
  }

  export const enum OrderTypes {
    Sales = 0,
    Purchase = 1,
    WishList = 2
  }

  export interface PaymentTransactionDto {
    ID: number;
    BackendID: string;
    OrderID: number;
    GroupID?: string;
    PaymentDetails: string;
    ErrorDetails: string;
    PaymentDate?: string;
    Amount?: number;
    Status: PaymentStatuses;
    IsConfirmed: boolean;
    IsSuccess: boolean;
    PendingOrConfirmed: boolean;
    StatusID: number;
    PaidAmount?: number;
    PaymentName: string;
    Change?: number;
    TypeID: number;
    Type: PaymentTypeDto;
    CurrencyID: string;
    ExchangeRate?: number;
    ForeignAmount?: number;
    ForeignPaidAmount?: number;
    Description: string;
  }

  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 interface OrderLineDto {
    ID: number;
    OrderID: number;
    ParentID: number;
    Type: OrderLineTypes;
    StockLabel: number;
    ResourceID: number;
    Description: string;
    AdditionalDescription: string;
    QuantityOrdered: number;
    QuantityOpen: number;
    QuantityCommitted: number;
    CommitmentStatus: OrderLineCommitmentStatus;
    QuantityShipped: number;
    QuantityReserved: number;
    QuantityBackordered: number;
    QuantityReturned: number;
    QuantityCancelled: number;
    QuantityInvoiced: number;
    ProductID: number;
    Product: ProductDto;
    UnitPrice?: number;
    TaxRate?: number;
    ShowTaxInfo: boolean;
    SerialNumber: string;
    InsuranceItemID: number;
    UnitPriceInTax?: number;
    /**
     * @deprecated This field is deprecated and should no longer be used.
     */
    UnitPriceInTaxTotal?: number;
    IsCancelled: boolean;
    TotalQuantityToShip: number;
    /**
     * @deprecated This field is deprecated and should no longer be used.
     */
    ExtendedAmountInTax?: number;
    /**
     * @deprecated This field is deprecated and should no longer be used.
     */
    ExtendedAmount?: number;
    TotalAmountInTax?: number;
    TotalAmount?: number;
    DisplayPriceInTax?: number;
    DisplayPrice?: number;
    CanModifyPrice: boolean;
    ModificationAllowed: boolean;
    Remark: string;
    Reference: string;
    LineActionType: LineActionTypes;
    ReturnedOrderLineID: number;
    ExportStatusID: number;
    ContractNumber: string;
    IsCompleted: boolean;
    IsShipped: boolean;
    IsInvoiced: boolean;
    ExpectedAvailabilityDate?: string;
    RequestedDate?: string;
    CreationTime?: string;
    LastModificationTime?: string;
    DiscountID: number;
    DiscountCouponID: number;
    DiscountAmount?: number;
    DiscountPercentage: number;
    DiscountBackendID: string;
    ShippingMethodID: number;
    ShippingMethod: ShippingMethodDto;
    ExternalModificationStatus: ExternalModificationStatuses;
    CustomOrderLineType: string;
    RelatedOrderLineID: number;
    CurrencyID: string;
    /**
     * Obsolete
     */
    ExchangeRate?: number;
    /**
     * Obsolete
     */
    ForeignUnitPrice?: number;
    /**
     * Obsolete
     */
    ForeignUnitPriceInTax?: number;
    /**
     * Obsolete
     */
    ForeignTotalAmount?: number;
    /**
     * Obsolete
     */
    ForeignTotalAmountInTax?: number;
    ProductVariation: { [key: string]: string };
    ProductBundleLineID: number;
    TaxExemptionCode: string;
    TaxExemptionReason: string;
    FulfillmentStatus?: OrderLineFulfillmentStatus;
  }

  export const enum OrderLineTypes {
    NormalProduct = 0,
    Discount = 1,
    ExtraCosts = 2,
    Contract = 3,
    SubscriptionContract = 4,
    ShippingCosts = 5,
    ReturnCosts = 6,
    PriceCorrection = 7,
    Service = 8
  }

  export const enum OrderLineCommitmentStatus {
    Uncommitted = 0,
    SoftCommit = 1,
    HardCommit = 2,
    ManualCommit = 5,
    ForcedCommit = 10
  }

  export interface ProductDto {
    ID: number;
    BackendID: string;
    CustomID: string;
    BrandID: number;
    BrandName: string;
    PrimitiveName: string;
    Type: ProductTypes;
    CatalogID: number;
    LedgerClassID: string;
    OrganizationUnitID: number;
    Properties: IProductSearchItem;
  }

  export const enum LineActionTypes {
    None = 0,
    ReserveLine = 1,
    OrderLine = 2,
    ShipLine = 3,
    Delivery = 4
  }

  export interface ShippingMethodDto {
    ID: number;
    CarrierID: number;
    Carrier: CarrierDto;
    Name: string;
    Description: string;
    Code: string;
    ExtraCosts?: number;
    Priority: number;
    PaymentHandledByCarrier: boolean;
  }

  export interface CarrierDto {
    ID: number;
    Name: string;
    Code: string;
  }

  export const enum ExternalModificationStatuses {
    None = 0,
    CancellationRequested = 1,
    QuantityChangeRequested = 2,
    CancellationRequestDenied = 4,
    CancellationRequestApproved = 8,
    QuantityChangeRequestDenied = 16,
    QuantityChangeRequestApproved = 32
  }

  export const enum OrderLineFulfillmentStatus {
    Unknown = 0,
    Blocked = 5,
    CannotFulfill = 10,
    CannotFulfillOnTime = 12,
    CanFulfill = 15
  }

  export interface TaxAmount {
    Rate?: number;
    Amount?: number;
    /**
     * Obsolete
     */
    ForeignAmount?: number;
    Base?: number;
  }

  export const enum OrderStatus {
    Cart = 0,
    Order = 1
  }

  export const enum DiscountInvalidReasons {
    None = 0,
    NotExist = 1,
    NotValidYet = 2,
    Expired = 3,
    HasAlreadyBeenUsed = 4,
    CouponCodeAlreadyAdded = 5,
    ManualValueIsInvalid = 6,
    InvalidOrderType = 7
  }

  export const enum OrderCharacteristics {
    None = 0,
    IsPickup = 1,
    CreatedByEmployee = 2,
    IsInterbranch = 4,
    IsB2B = 8,
    Duplicated = 16,
    Autocompleted = 32,
    CreatedFromWishList = 64,
    ReturnToSupplier = 128
  }

  export const enum OrderPreferredPriceDisplayMode {
    InTax = 0,
    ExTax = 1
  }

  export const enum ShipmentReceiveMethods {
    Manual = 0,
    Automatic = 1
  }

  export interface ReceiveShipmentWorkSet {
    ShipmentID: number;
    BackendID: string;
    ShippedToOrganizationUnitID: number;
    ReceiveMethod: ShipmentReceiveMethods;
    Lines: ReceiveShipmentWorkSetLine[];
    Orders: GetShipmentDetailsOrder[];
    /**
     * @deprecated This field is deprecated and should no longer be used.
     */
    DeliveryNoteNumber: string;
  }

  export interface ReceiveShipmentWorkSetLine {
    ProductID: number;
    ProductPrimitiveName: string;
    ProductCustomID: string;
    QuantityOrdered: number;
    QuantityAlreadyReceived: number;
    QuantityShipped: number;
    Receipts: ReceiveShipmentWorkSetLineReceipt[];
    RequiredResourceTypes: StockResourceTypeDto[];
    Packages: ReceiveShipmentWorkSetLinePackage[];
  }

  export interface ReceiveShipmentWorkSetLineReceipt {
    QuantityReceived: number;
    Resource: ReceiveShipmentWorkSetLineResource;
  }

  export interface ReceiveShipmentWorkSetLineResource {
    ResourceID: number;
    Resources: { [key: string]: string };
  }

  export interface ReceiveShipmentWorkSetLinePackage {
    UnitOfMeasure: string;
    Barcode: string;
    Quantity: number;
    QuantityBarcode: number;
    QuantityTotal: number;
  }

  export interface GetShipmentDetailsOrder {
    OrderID: number;
    BackendID: string;
    CustomerReference: string;
  }

  export const enum MessageTemplateDestinations {
    Mail = 1,
    Sms = 2,
    Pdf = 4,
    Thermal = 8,
    Notification = 16
  }

  export interface ResourceResponseMessage {
    Url: string;
    Error: ServiceError;
  }

  export interface SimpleShoppingCartResponse {
    OrderID: number;
    Error: ServiceError;
  }

  export interface AggregationFilterModel {
    MaxAggregationTerms: number;
    TermsAggregation: boolean;
    StatsAggregation: boolean;
    AggregationOptions: { [key: string]: AggregationFilterModel };
    Values: any[];
    From: string;
    To: string;
    Negation: boolean;
    ExactMatch: boolean;
    IncludeMissing: boolean;
  }

  /**
   * 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;
    IncludedFields?: string[];
    UserTypeOverride: UserTypes;
  }

  export interface SortFieldDescriptor {
    FieldName: string;
    Direction: SortDirection;
  }

  export interface SearchProductsResponse {
    Products: IProductSearchItem[];
    AggregationState: string;
    Aggregations: { [key: string]: any };
    AggregationOptions: { [key: string]: AggregationFilterModel };
    Page: number;
    PageSize: number;
    Total: number;
    Sort: SortFieldDescriptor[];
    Error: ServiceError;
  }

  export const enum FunctionalityScope {
    None = 0,
    Create = 1,
    Edit = 2,
    Delete = 4,
    View = 8,
    Manage = 31
  }

  export const enum FinancialEventTypes {
    Sales = 10,
    SalesTax = 11,
    SalesDiscounts = 12,
    Purchase = 20,
    PurchaseTax = 21,
    PurchasePriceVariance = 22,
    CostOfGoods = 30,
    Payment = 40,
    PaymentEndRounding = 41,
    CashAdjustment = 50,
    StockMutation = 60,
    StockMutationAutomaticCorrection = 61,
    StockSold = 62,
    StockReceived = 63
  }

  export interface AddressDataDto {
    AddressedTo: string;
    Street: string;
    HouseNumber: string;
    Address1: string;
    Address2: string;
    City: string;
    ZipCode: string;
    Region: string;
    CountryID: string;
    Latitude?: number;
    Longitude?: number;
  }

  export interface GetDeliveryOrderDataResponse {
    DeliveryOrderData: DeliveryOrderData;
    Error: ServiceError;
  }

  export interface DeliveryOrderData {
    DefaultShippingMethodID: number;
    ShippingType: string;
    ShippingPrice?: number;
    DeliveryService: string;
    PickUpPointID: string;
    PickUpPointName: string;
    AdditionalPickUpPointInformation: string;
    ExpectedDeliveryDate?: string;
    DeliveryTimeFrom?: string;
    DeliveryTimeTo?: string;
  }

  export const enum OpenCashDrawerResults {
    Failure = 0,
    Opened = 1,
    AlreadyOpen = 2,
    OpenedAndClosed = 3
  }

  export const enum MessageTemplateTypes {
    Template = 1,
    Partial = 2,
    Layout = 3
  }

  export interface PaperProperties {
    WaitForNetworkIdle: boolean;
    Size: PaperSize;
    Format?: PaperFormats;
    Orientation?: PaperOrientations;
    Margin: PaperMargin;
    ThermalPrinterTemplateType?: ThermalPrinterTemplateTypes;
  }

  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 interface PaperMargin {
    Top: number;
    Left: number;
    Bottom: number;
    Right: number;
  }

  export const enum ThermalPrinterTemplateTypes {
    Xml = 0,
    Html = 1
  }

  export const enum ConnectionType {
    Direct = 0,
    Proxy = 1
  }

  export interface CreateResponse {
    /**
     * @deprecated This field is deprecated and should no longer be used.
     */
    Success: boolean;
    ID: number;
    Error: ServiceError;
  }

  export const enum OrganizationUnitSetTypes {
    System = 0,
    Custom = 1,
    AdHoc = 2
  }

  export const enum OrganizationUnitSetOperatorTypes {
    Add = 0,
    Remove = 1
  }

  export interface ListGeneralLedgersFilter {
    OrganizationUnitID: number;
    AccountID: number;
    IsProcessed: boolean;
    FinancialPeriodID: number;
    OrderID: number;
    InvoiceID: number;
    CreationTime?: string;
    FromDate?: string;
    ToDate?: string;
    ObjectAccount: string;
  }

  export const enum BadgeTypes {
    Role = 1,
    Capability = 2,
    Achievement = 3
  }

  export interface ListAssortmentProductsFilter {
    ProductID: number;
    TypeID: number;
    AssortmentID: number;
  }

  export interface UserRequirement {
    Required: boolean;
  }

  export const enum UrlRewriteTypes {
    MovedPermanently = 301,
    MovedTemporarily = 302,
    TemporaryRedirect = 307,
    PermanentRedirect = 308,
    Gone = 410,
    Silent = 999
  }

  export interface ScrollablePageConfig<T> {
    NextResultToken: string;
    Filter: T;
    Limit: number;
  }

  export interface StockMutationFilters {
    ProductIDs: number[];
    MutationQuantity: number;
    Remark: string;
    SourceStockLabelID: number;
    DestinationStockLabelID: number;
    ReasonIDs: number[];
    OrganizationUnitID: number;
    FromDate?: string;
    ToDate?: string;
    UserIDs: number[];
    OrderIDs: number[];
  }

  export interface ScrollablePagedResult<T> {
    Page: T[];
    NextResultToken: string;
  }

  export interface SearchStockMutationResult {
    ID: number;
    CreationTime?: string;
    Product: ProductResult;
    OrganizationUnit: IdNameValue;
    SourceStockLabel: IdNameValue;
    DestinationStockLabel: IdNameValue;
    MutationQuantity: number;
    AutomaticCorrectionQuantity: number;
    SourceUnitCost?: number;
    SourceUnitPrice?: number;
    DestinationUnitCost?: number;
    DestinationUnitPrice?: number;
    Reason: ReasonResult;
    ResourceLines: ResourceLineResult[];
    Type: IdNameValue;
    Remark: string;
    OrderLine: OrderLineResult;
    UserTask: UserTaskResult;
    ShipmentLine: ShipmentLineResult;
    CreatedBy: UserResult;
  }

  export interface ProductResult {
    ID: number;
    CustomID: string;
    BackendID: string;
    PrimitiveName: string;
  }

  export interface IdNameValue {
    ID: number;
    Name: string;
  }

  export interface ReasonResult {
    ID: number;
    Name: string;
    BackendID: string;
  }

  export interface ResourceLineResult {
    ResourceID: number;
    Type: string;
    Value: string;
    IsUnique: boolean;
  }

  export interface OrderLineResult {
    ID: number;
    OrderID: number;
  }

  export interface UserTaskResult {
    ID: number;
    Type: IdNameValue;
  }

  export interface ShipmentLineResult {
    ID: number;
    Shipment: ShipmentResult;
  }

  export interface ShipmentResult {
    ID: number;
    TrackingCode: string;
  }

  export interface UserResult {
    ID: number;
    EmailAddress: string;
    FirstName: string;
    LastName: string;
  }

  export interface ListCumulativeStockFilter {
    ProductIDs: number[];
    OrganizationUnitType: OrganizationUnitTypes;
    OrganizationUnitName: string;
    HasStock: boolean;
  }

  export interface ListCarriersFilter {
    Name: string;
  }

  export interface ListShippingMethodsFilter {
    CarrierID: number;
  }

  export interface FunctionalityWithScope {
    Functionality: string;
    Scope: FunctionalityScope;
  }

  export interface ListProductBarcodesFilter {
    ProductID: number;
    Barcode: string;
    UnitOfMeasureID: number;
    IsSupplierProduct: boolean;
    Origin?: ProductBarcodeOrigin;
  }

  export const enum ProductBarcodeOrigin {
    Imported = 0,
    UserDefined = 1
  }

  export interface ListProductGiftCardsFilter {
    ProductID: number;
    Type: string;
  }

  export interface ProductSearchFilters {
    Name: string;
    LanguageID: string;
    CountryID: string;
  }

  export interface ListProductUnitOfMeasuresFilter {
    ProductID: number;
    UnitOfMeasureID: number;
    Quantity: number;
  }

  export interface ListSupplierProductsFilter {
    SupplierOrganizationUnitID: number;
    BackendID: string;
    PrimitiveName: string;
  }

  export interface ListProductPriceLedgerFilter {
    /**
     * @deprecated This field is deprecated and should no longer be used.
     */
    ProductID: number;
    ProductIDs: number[];
    PriceListID: number;
    PriceListUsageTypeID: number;
    /**
     * @deprecated This field is deprecated and should no longer be used.
     */
    OrganizationUnitID: number;
    OrganizationUnitIDs: number[];
    FromDate?: string;
  }

  export interface ListManualInputAdjustmentsFilter {
    PriceListAdjustmentID: number;
    ProductID: number;
    IsActive: boolean;
  }

  export const enum PaymentReturnActions {
    Default = 0,
    Blocked = 1,
    Forced = 2
  }

  export interface OrganizationUnitSetDefinition {
    CountryFilter: FilterDefinition;
    LanguageFilter: FilterDefinition;
    TypeFilter: OrganizationUnitTypes;
    IsEmpty: boolean;
  }

  export interface FilterDefinition {
    Values: string[];
    Negate: boolean;
  }

  export interface ListOrganizationUnitSetsFilter {
    Name: string;
    ID: number;
    Types: OrganizationUnitSetTypes[];
    OrganizationUnitID: number;
    IncludedOrganizationUnitTypes: OrganizationUnitTypes;
    ExcludedOrganizationUnitTypes: OrganizationUnitTypes;
  }

  export interface ListOrganizationUnitSetsItem {
    ID: number;
    Name: string;
    Type: OrganizationUnitSetTypes;
    OrganizationUnitCount: number;
  }

  export interface OrganizationUnitSubSetDefinition {
    ID: number;
    OperatorType: OrganizationUnitSetOperatorTypes;
  }

  export interface ListCashHandlersFilter {
    Name: string;
    CurrencyID: string;
  }

  export interface ListOrganizationUnitGroupsFilter {
    Name: string;
    BackendID: string;
  }

  export const enum MessageTargetContentTypes {
    Html = 0,
    Pdf = 1,
    Plain = 2,
    Png = 3
  }

  export interface DeviceDto {
    ID: number;
    BackendID: string;
    Name: string;
    Type: FlagsEnumDto;
    TypeID: number;
    NetworkName: string;
    IpAddress: string;
    Station: StationDto;
    StationID: number;
    AssemblyName: string;
    EcrID: string;
    HardwareID: string;
    ProxyID: string;
    OrganizationUnitID: number;
    OrganizationUnit: OrganizationUnitDto;
    /**
     * @deprecated This field is deprecated and should no longer be used.
     */
    IsActive: boolean;
  }

  export interface FlagsEnumDto {
    ID: number;
    Name: string;
    IDs: number[];
    Names: string[];
  }

  export interface StationDto {
    ID: number;
    BackendID: string;
    Name: string;
    OrganizationUnitID: number;
    OrganizationUnit: OrganizationUnitDto;
    OrganizationUnitDescription: string;
    Devices: DeviceDto[];
    HasPrinterDevice: boolean;
    HasPinDevice: boolean;
    HasThermalPrinterDevice: boolean;
    HasCashDrawerDevice: boolean;
    HasCustomerFacingDisplay: boolean;
    ProxyID: string;
  }

  export interface ListDiscountLayerFilter {
    Name: string;
    IsExclusive: boolean;
  }

  export const enum DiscountConditionTypes {
    OneOf = 0,
    All = 1
  }

  export const enum DiscountTriggers {
    Automatic = 0,
    Manual = 1,
    Coupon = 2,
    Bundles = 4,
    SystemManaged = -1
  }

  export interface DiscountCouponDto {
    ID: number;
    CouponCode: string;
    DiscountID: number;
    IsActive: boolean;
    UsageCount: number;
  }

  export interface SearchDiscountsByQueryFilter {
    IsActive: boolean;
    DiscountTriggerID: number;
    Description: string;
    CouponCode: string;
    CreatedBy: string;
    BackendID: string;
    IsActiveAndVerified: boolean;
    ShowOnlyChildDiscounts: boolean;
    OrderType: OrderTypes;
    LayerID: number;
    OrganizationUnitID: number;
    CurrencyID: string;
  }

  export interface CultureFilter {
    LanguageID: string;
    CountryID: string;
  }

  export interface OrganizationUnitCountryFilter {
    OrganizationUnitID: number;
    CountryID: string;
    IncludeInheritedOrganizationUnits: boolean;
  }

  export interface OrganizationUnitLanguageFilter {
    OrganizationUnitID: number;
    LanguageID: string;
    IncludeInheritedOrganizationUnits: boolean;
  }

  export const enum SettingSensitivityTypes {
    Normal = 0,
    Sensitive = 1,
    Masked = 2,
    Encrypted = 6
  }

  export const enum BookingFlags {
    None = 0,
    WithTaxInformation = 1,
    WithoutOffsets = 2,
    WithOrderNumber = 4,
    WithReference = 8,
    WithInvoiceNumber = 16,
    WithCurrencyInformation = 32
  }

  export interface GetRobotsTxt {
  }

  export interface GetRobotsTxtResponse {
    Robots: string;
    Error: ServiceError;
  }

  export interface UpdateRobotsTxt {
    Robots?: string;
  }

  export interface SendContactForm {
    Type?: string;
    Properties?: { [key: string]: string };
  }

  export interface ChangeUserPassword {
    UserID: number;
    NewPassword: string;
    OldPassword: string;
  }

  export interface ChangeUserPasswordResponse {
    Success: boolean;
    Result: PasswordValidationResults;
    Error: ServiceError;
  }

  export const enum PasswordValidationResults {
    Valid = 0,
    TooShort = 1,
    NoMatchWithOldPassword = 2,
    TooLong = 3
  }

  export interface CheckEmailAddressAvailability {
    EmailAddress?: string;
  }

  export interface CheckUsernameAvailabilityResponse {
    IsAvailable: boolean;
    IsValid: boolean;
    PasswordResetRequired: boolean;
    /**
     * @deprecated This field is deprecated and should no longer be used.
     */
    IsMigrated: boolean;
    /**
     * @deprecated This field is deprecated and should no longer be used.
     */
    IsIncomplete: boolean;
    Error: ServiceError;
  }

  export interface CheckNicknameAvailability {
    Nickname?: string;
  }

  /**
   * This service is used to convert the account of an incognito user to a normal customer account. Optionally a password can be provided.
   * Requirements for calling this service:
   * - The current user must be an incognito user
   * - The EmailAddress of the current user must be available (Can be checked with the `CheckEmailAddressAvailability` service)
   * 
   * If configured, the user will receive an `welcome to EVA` email. If no valid password is provided, the email will also contain a password.
   */
  export interface CreateAccountForIncognitoUser {
    Password?: string;
  }

  export interface CreateApiKey {
    UserID: number;
    ApplicationID: number;
    OrganizationUnitID: number;
    RequestPermanentApiKey: boolean;
  }

  export interface CreateApiKeyResponse {
    ApiKey: string;
    ExpirationDate?: string;
    Error: ServiceError;
  }

  export interface CreateCustomer {
    User?: CustomerDto;
    SessionID?: string;
    NoAccount: boolean;
    AutoLogin: boolean;
  }

  export interface CustomerDto {
    EmailAddress: string;
    Gender: string;
    Initials: string;
    FirstName: string;
    LastName: string;
    PhoneNumber: string;
    /**
     * @deprecated Replaced with Subscriptions datamodel
     */
    Sub