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

The EVA core typings

declare module EVA.Core.Management {

  export namespace Errors {
    export namespace CreateEmployee {
      export const UserAlreadyExists = 'CreateEmployee:UserAlreadyExists';
      export const ExistingCustomer = 'CreateEmployee:ExistingCustomer';
    }

    export namespace Assortments {
      export const CannotDeleteDefaultAssortment = 'Assortments:CannotDeleteDefault';
    }

    export namespace Subscriptions {
      export const DuplicateName = 'Subscriptions:DuplicateName';
      export const DuplicateBackendID = 'Subscriptions:DuplicateBackendID';
    }

    export namespace UserOrigins {
      export const AlreadyExists = 'UserOrigins:AlreadyExists';
    }

    export namespace GiftCards {
      export const ProductAlreadyExists = 'GiftCards:ProductAlreadyExists';
      export const UnknownType = 'GiftCards:UnknownType';
      export const InvalidData = 'GiftCards:InvalidData';
      export const ProductNotFound = 'GiftCards:ProductNotFound';
      export const InvalidProductType = 'GiftCards:InvalidProductType';
    }

    export namespace ProductUnitOfMeasures {
      export const ProductNotFound = 'ProductUnitOfMeasures:ProductNotFound';
      export const UnitOfMeasureNotFound = 'ProductUnitOfMeasures:UnitOfMeasureNotFound';
      export const InvalidQuantity = 'ProductUnitOfMeasures:InvalidQuantity';
    }

    export namespace UnitOfMeasures {
      export const AlreadyExists = 'UnitOfMeasures:AlreadyExists';
    }

    export namespace OrganizationUnitSets {
      export const OrganizationUnitSetInUse = 'OrganizationUnitSets:CannotDeleteInUse';
      export const CannotModifySystemSet = 'OrganizationUnitSets:CannotModifySystemSet';
      export const CannotCreateSystemSet = 'OrganizationUnitSets:CannotCreateSystemSet';
      export const CannotUseAdHocSetsAsSubset = 'OrganizationUnitSets:CannotUseAdHocSetsAsSubset';
    }

    export namespace Cultures {
      export const CountryAlreadyExists = 'Cultures:CountryAlreadyExists';
      export const LanguageAlreadyExists = 'Cultures:LanguageAlreadyExists';
    }

  }


  export interface CreateEmployeeUser {
    FirstName?: string;
    LastName?: string;
    Nickname?: string;
    EmailAddress?: string;
    Gender?: string;
    PhoneNumber?: string;
    DateOfBirth?: string;
    Password?: string;
    LanguageID?: string;
    CountryID?: string;
    EmployeeNumber?: string;
    Function?: string;
    PrimaryOrganizationUnitID: number;
    ManagerID: number;
    AdditionalOrganizationUnitIDs?: number[];
    RoleID: number;
    ToCreate?: EVA.Core.UserDto;
  }

  export interface CreateEmployeeUserResponse {
    UserID: number;
    Result: CreateEmployeeResults;
    Error: EVA.Core.ServiceError;
  }

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

  export interface CreateIdentificationPinForEmployee {
    UserID: number;
    OrganizationUnitID: number;
    Pin: string;
  }

  export interface CreateIdentificationPinForEmployeeResponse {
    Pin: string;
    Error: EVA.Core.ServiceError;
  }

  export interface GetEmployeeDataByID {
    ID: number;
  }

  export interface GetEmployeeDataByIDResponse {
    ID: number;
    UserID: number;
    UserFullName: string;
    UserEmailAddress: string;
    EmployeeNumber: string;
    Function: string;
    PrimaryOrganizationUnitID: number;
    PrimaryOrganizationUnitName: string;
    ManagerID: number;
    ManagerFullName: string;
    ManagerEmailAddress: string;
    AdditionalOrganizationUnitIDs: number[];
    Error: EVA.Core.ServiceError;
  }

  export interface GetEmployeeDataByUserID {
    UserID: number;
  }

  export interface CreateEmployeeData {
    UserID: number;
    EmployeeNumber?: string;
    Function?: string;
    PrimaryOrganizationUnitID: number;
    ManagerID: number;
    AdditionalOrganizationUnitIDs?: number[];
  }

  export interface CreateEmployeeDataResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdateEmployeeData {
    ID: number;
    UserID: number;
    EmployeeNumber?: string;
    Function?: string;
    PrimaryOrganizationUnitID: number;
    ManagerID: number;
    AdditionalOrganizationUnitIDs?: number[];
  }

  export interface DeleteEmployeeData {
    ID: number;
  }

  export interface ListEmployeeDatas {
    PageConfig?: EVA.Core.PageConfig;
  }

  export interface ListEmployeeDatasResponse {
    Result: EVA.Core.PagedResult<EmployeeDataDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface EmployeeDataDto {
    ID: number;
    UserID: number;
    UserFullName: string;
    UserEmailAddress: string;
    EmployeeNumber: string;
    Function: string;
    PrimaryOrganizationUnitID: number;
    PrimaryOrganizationUnitName: string;
    ManagerID: number;
    ManagerFullName: string;
    ManagerEmailAddress: string;
    AdditionalOrganizationUnitIDs: number[];
  }

  export interface GenerateIdentificationPinForEmployee {
    UserID: number;
    OrganizationUnitID: number;
  }

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

  /**
   * 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: number[];
  }

  export interface DownloadInitialInventorySample {
  }

  export interface UploadInitialInventory {
    Data?: number[];
    IgnoreInTransitStock: boolean;
  }

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

  export interface ListRestockedProducts {
    OrganizationUnitID: number;
    From?: string;
    To?: string;
    StockLabelIDs: number[];
  }

  export interface ListRestockedProductsResponse {
    Results: { [key: number]: number[] };
    Error: EVA.Core.ServiceError;
  }

  /**
   * List the Stock per product/stocklabel for a subset of OrganizationUnits.
   * 
   * FilterOptions:
   * - DateTime: View the stock on a certain moment in time
   * - SplitByOrganizationUnit: The stock will (not) be grouped by OrganizationUnit
   * - Query: Filter on products, is used as input in ElasticSearch
   * 
   * It is also possible to download an Excel sheet of the stock for all products, this can be done by settings `DownloadOverview` to true.
   * The `Url` property on the response will contain the download url.
   */
  export interface ListStockForOrganizationUnits {
    DateTime?: string;
    OrganizationUnitIDs: number[];
    SplitByOrganizationUnit: boolean;
    DownloadOverview: boolean;
    Query?: string;
    PageConfig?: EVA.Core.PageConfig;
  }

  export interface ListStockForOrganizationUnitsResponse {
    Products: { [key: number]: ProductDto };
    Url: string;
    Result: EVA.Core.PagedResult<StockDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface ProductDto {
    Product: { [key: string]: any };
    TaxRate?: number;
    TaxCodeID: number;
    UnitCost?: number;
    UnitPrice?: number;
    UnitPriceInTax?: number;
  }

  export interface StockDto {
    ProductID: number;
    QuantityOnHand: number;
    QuantityCommitted: number;
    QuantityAvailable: number;
    StockLabel: number;
    OrganizationUnitID: number;
    OrganizationUnitName: string;
  }

  export interface ExportUnshippedPurchaseOrdersToExcel {
    ShipFromOrganizationUnitID: number;
  }

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

  export interface ProcessUnshippedPurchaseOrdersFromExcel {
    Data?: number[];
  }

  export interface GeneratePurchaseOrderExcelSample {
  }

  export interface UploadPurchaseOrderExcel {
    Data?: number[];
  }

  export interface ListLedgerClass {
    ID: number;
  }

  export interface ListLedgerClassResponse {
    Result: LedgerClassDto[];
    Error: EVA.Core.ServiceError;
  }

  export interface LedgerClassDto {
    ID: string;
  }

  export interface GetFraudItem {
    ID: number;
  }

  export interface GetFraudItemResponse {
    ID: number;
    TypeID: number;
    Data: string;
    Object: any;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdateFraudItem {
    ID: number;
    Data?: string;
    Object?: any;
  }

  export interface CreateFraudItem {
    TypeID: number;
    Data?: string;
    Object?: any;
  }

  export interface CreateFraudItemResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  export interface DeleteFraudItem {
    ID: number;
  }

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

  export interface ListFraudItemsResponse {
    Result: EVA.Core.PagedResult<FraudItemDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface FraudItemDto {
    ID: number;
    TypeID: number;
    Data: string;
    Object: any;
  }

  export interface DownloadFraudItems {
  }

  export interface UploadFraudItems {
    Data?: number[];
  }

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

  export interface ListBadges {
    PageConfig?: EVA.Core.PageConfig;
  }

  export interface ListBadgesResponse {
    Result: EVA.Core.PagedResult<BadgeDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface BadgeDto {
    ID: number;
    Name: string;
    Description: string;
    TypeID: number;
    Type: EVA.Core.BadgeTypes;
  }

  export interface SaveBadge {
    Badge?: BadgeDto;
  }

  export interface GetAssortmentByID {
    ID: number;
  }

  export interface GetAssortmentByIDResponse {
    ID: number;
    Name: string;
    IsDefault: boolean;
    Error: EVA.Core.ServiceError;
  }

  export interface CreateAssortment {
    Name?: string;
  }

  export interface CreateAssortmentResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdateAssortment {
    ID: number;
    Name?: string;
  }

  export interface DeleteAssortment {
    ID: number;
  }

  export interface ListAssortments {
    PageConfig?: EVA.Core.PageConfig;
  }

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

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

  export interface GetAssortmentProductByID {
    ID: number;
  }

  export interface GetAssortmentProductByIDResponse {
    ID: number;
    ProductID: number;
    ProductCustomID: string;
    AssortmentID: number;
    AssortmentName: string;
    ProductStatus?: EVA.Core.ProductStatus;
    StartDate?: string;
    EndDate?: string;
    Error: EVA.Core.ServiceError;
  }

  export interface CreateAssortmentProduct {
    ProductID: number;
    AssortmentID: number;
    ProductStatus?: EVA.Core.ProductStatus;
    StartDate?: string;
    EndDate?: string;
  }

  export interface CreateAssortmentProductResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdateAssortmentProduct {
    ID: number;
    ProductID: number;
    AssortmentID: number;
    ProductStatus?: EVA.Core.ProductStatus;
    StartDate?: string;
    EndDate?: string;
  }

  export interface DeleteAssortmentProduct {
    ID: number;
  }

  export interface ListAssortmentProducts {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListAssortmentProductsFilter>;
  }

  export interface ListAssortmentProductsResponse {
    Result: EVA.Core.PagedResult<AssortmentProductDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface AssortmentProductDto {
    ID: number;
    ProductID: number;
    ProductCustomID: string;
    AssortmentID: number;
    AssortmentName: string;
    ProductStatus?: EVA.Core.ProductStatus;
    StartDate?: string;
    EndDate?: string;
  }

  export interface DownloadAssortmentProducts {
    AssortmentID: number;
  }

  export interface DownloadAssortmentProductsSample {
  }

  export interface UploadAssortmentProducts {
    AssortmentID: number;
    Data?: number[];
  }

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

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

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

  export interface SubscriptionDto {
    ID: number;
    Name: string;
    BackendID: string;
    ConfirmationRequired: boolean;
    Default: boolean;
    UserField: string;
    Handler: string;
  }

  /**
   * Create a new Subscription
   */
  export interface CreateSubscription {
    Name: string;
    BackendID?: string;
    /**
     * If the user should confirm this subscription, the handler has to support this.
     */
    ConfirmationRequired: boolean;
    /**
     * The default value in the frontend when a user doesn't have this subscription yet.
     */
    Default: boolean;
    /**
     * A UserField that is required when using this Subscription, p/a EmailAddress, PhoneNumber.
     */
    UserField?: string;
    /**
     * A Handler for the actions on this subscription. Available handlers can be listed with the `GetSubscriptionHandlers` service.
     */
    Handler?: string;
  }

  export interface CreateSubscriptionResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  /**
   * Update an existing Subscription
   */
  export interface UpdateSubscription2 {
    ID: number;
    Name: string;
    BackendID?: string;
    ConfirmationRequired: boolean;
    Default: boolean;
    UserField?: string;
    Handler?: string;
  }

  /**
   * Delete a Subscription
   */
  export interface DeleteSubscription {
    ID: number;
  }

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

  export interface GetSubscriptionHandlersResponse {
    Handlers: string[];
    Error: EVA.Core.ServiceError;
  }

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

  export interface ListUserOriginsResponse {
    UserOrigins: UserOriginDto[];
    Error: EVA.Core.ServiceError;
  }

  export interface UserOriginDto {
    BackendID: string;
    ID: number;
    Name: string;
    Description: string;
  }

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

  export interface CreateUserOriginResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

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

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

  /**
   * Get the configured UserRequirements for the current, or given, `OrganizationUnit`.
   */
  export interface GetUserRequirements {
    OrganizationUnitID: number;
  }

  export interface GetUserRequirementsResponse {
    Requirements: { [key: string]: EVA.Core.UserRequirement };
    Error: EVA.Core.ServiceError;
  }

  /**
   * Update the UserRequirements for the current, or given, `OrganizationUnit`.
   */
  export interface SetUserRequirements {
    OrganizationUnitID: number;
    Requirements?: { [key: string]: EVA.Core.UserRequirement };
  }

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

  export interface GetAvailableUserRequirementsPropertiesResponse {
    Properties: string[];
    Error: EVA.Core.ServiceError;
  }

  export interface GenerateIdentificationCodeForEmployee {
  }

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

  export interface UserIdWithIdentificationCodeDto {
    UserId: number;
    IdentificationCode: string;
  }

  /**
   * 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: number[];
  }

  export interface CreateUrlRewrite {
    ToCreate?: UrlRewriteDto;
  }

  export interface UrlRewriteDto {
    ID: number;
    RequestPath: string;
    TargetPath: string;
    UrlRewriteType: EVA.Core.UrlRewriteTypes;
    Description: string;
    IsActive: boolean;
    IsRegex: boolean;
  }

  export interface DeleteUrlRewrite {
    ID: number;
  }

  export interface GetUrlRewriteByID {
    ID: number;
  }

  export interface GetUrlRewriteByIDResponse {
    Rewrite: UrlRewriteDto;
    Error: EVA.Core.ServiceError;
  }

  export interface GetUrlRewrites {
  }

  export interface GetUrlRewritesResponse {
    Rewrites: UrlRewriteDto[];
    Error: EVA.Core.ServiceError;
  }

  export interface ListUrlRewrites {
    PageConfig?: EVA.Core.PageConfig;
  }

  export interface ListUrlRewritesResponse {
    Result: EVA.Core.PagedResult<UrlRewriteDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdateUrlRewrite {
    ToUpdate?: UrlRewriteDto;
  }

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

  export interface GetStockMutationReasonsForOrganizationUnitResponse {
    Reasons: StockMutationReason[];
    Error: EVA.Core.ServiceError;
  }

  export interface StockMutationReason {
    ID: number;
    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>;
  }

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

  /**
   * Calculates the current stock and committed stock for the given set of organizations and products.
   */
  export interface CalculateStockDetails {
    OrganizationUnitIDs: number[];
    ProductIDs: number[];
  }

  export interface CalculateStockDetailsResponse {
    Results: {
      OrganizationUnitID: number;
      OrganizationUnitName: string;
      ProductID: number;
      QuantityOnHand: number;
      QuantityCommitted: number;
      TotalQuantityAvailable: number;
    }[];
    Error: EVA.Core.ServiceError;
  }

  /**
   * Returns the current stock with commitments for the given product and organization(set).
   */
  export interface GetStockDetailsForOrganizationUnit {
    ProductID: number;
    OrganizationUnitSetID: number;
    OrganizationUnitID: number;
    StockLabelIDs: number[];
  }

  export interface GetStockDetailsForOrganizationUnitResponse {
    Results: {
      OrganizationUnitID: number;
      OrganizationUnitName: string;
      StockLabel: EVA.Core.EnumDto;
      QuantityOnHand: number;
      QuantityCommitted: number;
    }[];
    Error: EVA.Core.ServiceError;
  }

  export interface ListCumulativeStock {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListCumulativeStockFilter>;
    IncludedFields?: string[];
  }

  export interface ListCumulativeStockResponse {
    Result: EVA.Core.PagedResult<{
      OrganizationUnitID: number;
      OrganizationUnitName: string;
      OrganizationUnitBackendID: string;
      Product: EVA.Core.IProductSearchItem;
      QuantityOnHand: number;
    }>;
    Error: EVA.Core.ServiceError;
  }

  export interface CreateCarrier {
    Name: string;
    Code?: string;
    BackendID?: string;
  }

  export interface CreateCarrierResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  export interface GetCarrierByID {
    ID: number;
  }

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

  export interface ListCarriers {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListCarriersFilter>;
  }

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

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

  export interface UpdateCarrier {
    ID: number;
    Name: string;
    Code?: string;
    BackendID?: string;
  }

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

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

  export interface ShippingMethodDto {
    ID: number;
    Name: string;
    CarrierID: number;
    CarrierName: string;
  }

  export interface GetOrganizationUnitShippingMethodByID {
    ID: number;
  }

  export interface GetOrganizationUnitShippingMethodByIDResponse {
    ID: number;
    ShippingMethodID: number;
    ShippingMethodName: string;
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    Priority: number;
    Error: EVA.Core.ServiceError;
  }

  export interface CreateOrganizationUnitShippingMethod {
    ShippingMethodID: number;
    OrganizationUnitID: number;
    Priority: number;
  }

  export interface CreateOrganizationUnitShippingMethodResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdateOrganizationUnitShippingMethod {
    ID: number;
    ShippingMethodID: number;
    OrganizationUnitID: number;
    Priority: number;
  }

  export interface DeleteOrganizationUnitShippingMethod {
    ID: number;
  }

  export interface ListOrganizationUnitShippingMethods {
    PageConfig?: EVA.Core.PageConfig;
  }

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

  export interface OrganizationUnitShippingMethodDto {
    ID: number;
    ShippingMethodID: number;
    ShippingMethodName: string;
    ShippingMethodCarrierName: string;
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    Priority: number;
  }

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

  export interface GetShippingCostByIDResponse {
    ID: number;
    BackendID: string;
    ShippingMethodID: number;
    ShippingMethodName: string;
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    CountryID: string;
    MinimumOrderAmount?: number;
    MaximumOrderAmount?: number;
    CurrencyID: string;
    UnitPriceInTax?: number;
    ZipCodes: string[];
    Error: EVA.Core.ServiceError;
  }

  /**
   * Create a `ShippingCost`
   */
  export interface CreateShippingCost {
    BackendID?: string;
    ShippingMethodID: number;
    OrganizationUnitID: number;
    CountryID?: string;
    ZipCodes?: string[];
    MinimumOrderAmount?: number;
    MaximumOrderAmount?: number;
    CurrencyID: string;
    UnitPriceInTax?: number;
  }

  export interface CreateShippingCostResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  /**
   * Update a `ShippingCost`
   */
  export interface UpdateShippingCost {
    ID: number;
    BackendID?: string;
    ShippingMethodID: number;
    OrganizationUnitID: number;
    CountryID?: string;
    ZipCodes?: string[];
    MinimumOrderAmount?: number;
    MaximumOrderAmount?: number;
    CurrencyID: string;
    UnitPriceInTax?: number;
  }

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

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

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

  export interface ShippingCostDto {
    ID: number;
    BackendID: string;
    ShippingMethodID: number;
    ShippingMethodName: string;
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    CountryID: string;
    ZipCodes: string[];
    MinimumOrderAmount?: number;
    MaximumOrderAmount?: number;
    CurrencyID: string;
    UnitPriceInTax?: number;
  }

  /**
   * Create a new ShippingMethod
   */
  export interface CreateShippingMethod {
    Name: string;
    Code?: string;
    PaymentHandledByCarrier: boolean;
    CarrierID: number;
  }

  export interface CreateShippingMethodResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

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

  export interface GetShippingMethodByIDResponse {
    ID: number;
    Name: string;
    Code: string;
    PaymentHandledByCarrier: boolean;
    CarrierID: number;
    CarrierName: string;
    CarrierCode: string;
    Error: EVA.Core.ServiceError;
  }

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

  export interface ListManagementShippingMethodsResponse {
    Result: EVA.Core.PagedResult<ShippingMethodDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface ShippingMethodDto {
    ID: number;
    Name: string;
    Code: string;
    PaymentHandledByCarrier: boolean;
    CarrierID: number;
    CarrierName: string;
    CarrierCode: string;
  }

  /**
   * Update an existing ShippingMethod
   */
  export interface UpdateShippingMethod {
    ID: number;
    Name: string;
    Code?: string;
    PaymentHandledByCarrier: boolean;
    CarrierID: number;
  }

  export interface GetShippingRestrictionByID {
    ID: number;
  }

  export interface GetShippingRestrictionByIDResponse {
    ID: number;
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    CountryID: string;
    CountryName: string;
    ZipCodeFrom: string;
    ZipCodeTo: string;
    ProductPropertyTypeID: string;
    Error: EVA.Core.ServiceError;
  }

  export interface CreateShippingRestriction {
    OrganizationUnitID: number;
    CountryID?: string;
    ZipCodeFrom?: string;
    ZipCodeTo?: string;
    ProductPropertyTypeID?: string;
  }

  export interface CreateShippingRestrictionResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdateShippingRestriction {
    ID: number;
    OrganizationUnitID: number;
    CountryID?: string;
    ZipCodeFrom?: string;
    ZipCodeTo?: string;
    ProductPropertyTypeID?: string;
  }

  export interface DeleteShippingRestriction {
    ID: number;
  }

  export interface ListShippingRestrictions {
    PageConfig?: EVA.Core.PageConfig;
  }

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

  export interface ShippingRestrictionDto {
    ID: number;
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    CountryID: string;
    CountryName: string;
    ZipCodeFrom: string;
    ZipCodeTo: string;
    ProductPropertyTypeID: string;
  }

  export interface DownloadShippingRestrictions {
  }

  export interface UploadShippingRestrictions {
    Data?: number[];
  }

  export interface UploadShippingRestrictionsResponse {
    Messages: string[];
    Error: EVA.Core.ServiceError;
  }

  export interface GetRole {
    ID: number;
  }

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

  export interface RoleWithFunctionalitiesDto {
    Functionalities: string[];
    ScopedFunctionalities: FunctionalityWithScope[];
    ID: number;
    Name: string;
    UserTypeID: number;
    ApplicationID: number;
    Code: string;
  }

  export interface FunctionalityWithScope {
    Functionality: string;
    Scope: EVA.Core.FunctionalityScope;
  }

  export interface ListRoles {
    PageConfig?: EVA.Core.PageConfig;
  }

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

  export interface RoleDto {
    ID: number;
    Name: string;
    UserTypeID: number;
    ApplicationID: number;
    Code: string;
  }

  export interface CreateRole {
    ToCreate?: RoleDto;
  }

  export interface UpdateRole {
    ToUpdate?: RoleDto;
  }

  export interface DeleteRole {
    ID: number;
  }

  export interface AttachFunctionalitiesToRole {
    RoleID: number;
    Functionalities?: string[];
    ScopedFunctionalities?: EVA.Core.FunctionalityWithScope[];
  }

  export interface DetachFunctionalitiesFromRole {
    RoleID: number;
    Functionalities?: string[];
    ScopedFunctionalities?: EVA.Core.FunctionalityWithScope[];
  }

  /**
   * Return all active functionalities with the OrganizationUnitIDs where they are active.
   */
  export interface GetAllFunctionalitiesForCurrentUser {
  }

  export interface GetAllFunctionalitiesForCurrentUserResponse {
    Functionalities: {
      Functionality: string;
      FunctionalityScope: EVA.Core.FunctionalityScope;
      OrganizationUnitIDs: number[];
    }[];
    Error: EVA.Core.ServiceError;
  }

  /**
   * Return a tree of all the organizationunits with all active functionalities. If `DisableHierarchy` is false, the Functioanlity also applies to all children.
   */
  export interface GetAllFunctionalitiesForCurrentUserAsTree {
  }

  export interface GetAllFunctionalitiesForCurrentUserAsTreeResponse {
    OrganizationUnits: OrganizationUnitDto[];
    Error: EVA.Core.ServiceError;
  }

  export interface OrganizationUnitDto {
    ID: number;
    Functionalities: {
      Functionality: string;
      FunctionalityScope: EVA.Core.FunctionalityScope;
      DisableHierarchy: boolean;
    }[];
    Children: OrganizationUnitDto[];
  }

  export interface GetAvailableRoles {
    UserID: number;
  }

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

  export interface GetFlattenedFunctionalityByUserID {
    UserID: number;
    OrganizationUnitID: number;
  }

  export interface GetFlattenedFunctionalityByUserIDResponse {
    Functionalities: string[];
    ScopedFunctionalities: EVA.Core.FunctionalityWithScope[];
    Error: EVA.Core.ServiceError;
  }

  export interface GetFunctionalitiesByUserID {
    UserID: number;
    OrganizationUnitID: number;
  }

  export interface GetFunctionalitiesByUserIDResponse {
    AvailableFunctionalities: string[];
    CurrentFunctionalities: string[];
    CurrentFunctionalitiesExtended: FunctionalityDto[];
    Error: EVA.Core.ServiceError;
  }

  export interface FunctionalityDto {
    Functionality: string;
    EndDate?: string;
    DisableHierarchy: boolean;
    FunctionalityScope: EVA.Core.FunctionalityScope;
  }

  export interface GetSupportedFunctionalities {
  }

  export interface GetSupportedFunctionalitiesResponse {
    Functionalities: string[];
    ScopedFunctionalities: FunctionalityDefinition[];
    Error: EVA.Core.ServiceError;
  }

  export interface FunctionalityDefinition {
    Name: string;
    Description: string;
    NoInheritance: boolean;
    Unscoped: boolean;
  }

  export interface GetUserRolesByUserID {
    UserID: number;
    OrganizationUnitID: number;
    PageConfig?: EVA.Core.PageConfig;
  }

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

  export interface UserRoleDto {
    ID: number;
    UserID: number;
    OrganizationUnitID: number;
    OrganizationUnitGroupID: number;
    RoleID: number;
    EndDate?: string;
    DisableHierarchy: boolean;
    Pending: boolean;
    Role: RoleDto;
  }

  export interface ApprovePendingUser {
    UserID: number;
  }

  export interface ListPendingUsers {
    PageConfig?: EVA.Core.PageConfig;
  }

  export interface ListPendingUsersResponse {
    Result: EVA.Core.PagedResult<PendingUser>;
    Error: EVA.Core.ServiceError;
  }

  export interface PendingUser {
    ID: number;
    FullName: string;
    EmailAddress: string;
    GravatarHash: string;
  }

  export interface GetRoleSetByID {
    ID: number;
  }

  export interface GetRoleSetByIDResponse {
    ID: number;
    Name: string;
    Roles: RoleDto[];
    Error: EVA.Core.ServiceError;
  }

  export interface ListRoleSets {
    PageConfig?: EVA.Core.PageConfig;
  }

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

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

  export interface CreateRoleSet {
    Name?: string;
  }

  export interface CreateRoleSetResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdateRoleSet {
    ID: number;
    Name?: string;
  }

  export interface DeleteRoleSet {
    ID: number;
  }

  export interface SetRolesForRoleSet {
    RoleSetID: number;
    Roles?: number[];
  }

  export interface GetRolesForOrganizationUnit {
    OrganizationUnitID: number;
  }

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

  export interface UpdateUserFunctionalities {
    Data: UpdatedUserFunctionalitiesDto[];
    UserID: number;
    OrganizationUnitID: number;
    Functionalities?: UpdatedFunctionalityDto[];
  }

  export interface UpdatedUserFunctionalitiesDto {
    UserID: number;
    OrganizationUnitID: number;
    Functionalities: UpdatedFunctionalityDto[];
  }

  export interface UpdatedFunctionalityDto {
    Functionality: string;
    FunctionalityScope: EVA.Core.FunctionalityScope;
    IsRemoved: boolean;
    EndDate?: string;
    DisableHierarchy: boolean;
  }

  export interface UpdateUserRoles {
    RoleID: number;
    OrganizationUnitID: number;
    OrganizationUnitGroupID: number;
    IsRemoved: boolean;
    UserID: number;
    EndDate?: string;
    UserType: EVA.Core.UserTypes;
    DisableHierarchy: boolean;
    Pending: boolean;
  }

  export interface CreateProductBarcode {
    ProductID: number;
    Barcode: string;
    UnitOfMeasureID: number;
    Name?: string;
  }

  export interface DeleteProductBarcode {
    Barcode: string;
  }

  export interface ListProductBarcodes {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListProductBarcodesFilter>;
  }

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

  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;
  }

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

  export interface ListProductGiftCardsResponse {
    Result: EVA.Core.PagedResult<ProductGiftCardDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface ProductGiftCardDto {
    ID: number;
    ProductID: number;
    ProductName: string;
    Type: string;
    Data: { [key: string]: any };
  }

  /**
   * Create a new ProductGiftCard
   */
  export interface CreateProductGiftCard {
    ProductID: number;
    Type: string;
    Data?: { [key: string]: any };
  }

  export interface CreateProductGiftCardResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  /**
   * Update an existing ProductGiftCard
   */
  export interface UpdateProductGiftCard {
    ID: number;
    ProductID: number;
    Type: string;
    Data?: { [key: string]: any };
  }

  /**
   * Delete a ProductGiftCard
   */
  export interface DeleteProductGiftCard {
    ID: number;
  }

  /**
   * Get an exisiting ProductSearch by ID
   */
  export interface GetProductSearchByID {
    ID: number;
  }

  export interface GetProductSearchByIDResponse {
    Name: string;
    LanguageID: string;
    CountryID: string;
    Filters: { [key: string]: EVA.Core.FilterModel };
    Error: EVA.Core.ServiceError;
  }

  /**
   * List the ProductSearches
   */
  export interface ListProductSearches {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ProductSearchFilters>;
  }

  export interface ListProductSearchesResponse {
    Result: EVA.Core.PagedResult<ProductSearchDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface ProductSearchDto {
    ID: number;
    Name: string;
    LanguageID: string;
    CountryID: string;
    Filters: { [key: string]: EVA.Core.FilterModel };
  }

  /**
   * Create a new ProductSearch
   */
  export interface CreateProductSearch {
    Name: string;
    Filters?: { [key: string]: EVA.Core.FilterModel };
  }

  export interface CreateProductSearchResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  /**
   * Update an existing ProductSearch
   */
  export interface UpdateProductSearch {
    ID: number;
    Name: string;
    Filters: { [key: string]: EVA.Core.FilterModel };
  }

  /**
   * Delete a ProductSearch
   */
  export interface DeleteProductSearch {
    ID: number;
  }

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

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

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

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

  export interface CreateProductUnitOfMeasureResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  /**
   * Update an existing ProductUnitOfMeasure
   */
  export interface UpdateProductUnitOfMeasure {
    ID: number;
    ProductID: number;
    UnitOfMeasureID: number;
    Quantity: number;
  }

  /**
   * Delete a ProductUnitOfMeasure
   */
  export interface DeleteProductUnitOfMeasure {
    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<SupplierProductDto>;
    Error: EVA.Core.ServiceError;
  }

  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 {
    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;
  }

  /**
   * Create a new SupplierProduct
   */
  export interface CreateSupplierProduct {
    SupplierOrganizationUnitID: number;
    BackendID: string;
    BrandName?: string;
    PrimitiveName: string;
    Status?: EVA.Core.ProductStatus;
    Description?: string;
    PreferredMinimumOrderQuantity: number;
    TaxCodeID: number;
  }

  export interface CreateSupplierProductResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  /**
   * Update an existing SupplierProduct
   */
  export interface UpdateSupplierProduct {
    ID: number;
    BackendID: string;
    BrandName?: string;
    PrimitiveName: string;
    Status?: EVA.Core.ProductStatus;
    Description?: string;
    PreferredMinimumOrderQuantity: number;
    TaxCodeID: number;
  }

  /**
   * Delete a SupplierProduct
   */
  export interface DeleteSupplierProduct {
    ID: number;
  }

  /**
   * Update the stock of a SupplierProduct, this is handled in the background
   */
  export interface UpdateSupplierProductStock {
    ID: number;
    Quantity: number;
  }

  /**
   * Update the prices of a SupplierProduct, this is handled in the background
   */
  export interface UpdateSupplierProductPrices {
    ID: number;
    CurrencyID: string;
    UnitCost?: number;
    RecommendedRetailPrice?: number;
  }

  /**
   * Retrieves the suppliers (Organization Units) for the given Product.
   */
  export interface GetSuppliersForProduct {
    ProductID: number;
  }

  export interface GetSupplierForProductResponse {
    Result: SupplierDto[];
    Error: EVA.Core.ServiceError;
  }

  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 {
    OrganizationUnitID: number;
    Data?: number[];
  }

  export interface UploadSupplierProductsResponse {
    TotalProductCount: number;
    FailedCount: number;
    Messages: { [key: string]: string };
    DeletedCount: number;
    Error: EVA.Core.ServiceError;
  }

  /**
   * 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 {
    OrganizationUnitID: number;
    Data?: number[];
  }

  /**
   * 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 {
    OrganizationUnitID: number;
    Data?: number[];
  }

  /**
   * 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 {
    OrganizationUnitID: number;
    Data?: number[];
  }

  /**
   * 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 {
    OrganizationUnitID: number;
  }

  /**
   * Download the current stock for the supplier products.
   */
  export interface DownloadSupplierProductsStock {
    OrganizationUnitID: number;
  }

  /**
   * Download the current prices for the supplier products in the given Currency.
   */
  export interface DownloadSupplierProductsPricing {
    OrganizationUnitID: number;
    CurrencyID?: string;
  }

  /**
   * Download the current barcodes for the supplier products.
   */
  export interface DownloadSupplierProductsBarcodes {
    OrganizationUnitID: number;
  }

  /**
   * List the UnitOfMeasures
   */
  export interface ListUnitOfMeasures {
  }

  export interface ListUnitOfMeasuresResponse {
    UnitOfMeasures: UnitOfMeasureDto[];
    Error: EVA.Core.ServiceError;
  }

  export interface UnitOfMeasureDto {
    BackendID: string;
    ID: number;
    Name: string;
    Description: string;
  }

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

  export interface CreateUnitOfMeasureResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  /**
   * Update an existing UnitOfMeasure
   */
  export interface UpdateUnitOfMeasure {
    ID: number;
    Name: string;
    Description?: string;
    BackendID?: string;
  }

  /**
   * Delete a UnitOfMeasure
   */
  export interface DeleteUnitOfMeasure {
    ID: number;
  }

  /**
   * List the pricechanges in an OrganizationUnit.
   * 
   * It is required to supply some OrganizationUnitIDs or some ProductIDs in the PageConfig filter.
   */
  export interface ListOrganizationUnitPriceChanges {
    PageConfig?: EVA.Core.PageConfig<EVA.Core.ListProductPriceLedgerFilter>;
  }

  export interface ListProductPriceLedgerResponse {
    Result: EVA.Core.PagedResult<OrganizationUnitPriceChange>;
    Error: EVA.Core.ServiceError;
  }

  export interface OrganizationUnitPriceChange {
    ProductID: number;
    PriceListID: number;
    PriceListUsageTypeID: number;
    PriceListUsageTypeName: string;
    OrganizationUnitID: number;
    OrganizationUnitName: string;
    OldPrice?: number;
    NewPrice?: number;
    OldOriginalPrice?: number;
    NewOriginalPrice?: number;
    CreationTime?: string;
    CurrencyID: 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 GetPriceListAdjustmentByID {
    ID: number;
  }

  export interface GetPriceListAdjustmentByIDResponse {
    ID: number;
    PriceListID: number;
    PriceList: {
      Name: string;
      CurrencyID: string;
    };
    Sequence: number;
    Name: string;
    EffectiveDate?: string;
    ExpireDate?: string;
    OverridePrice: boolean;
    Type: string;
    Data: { [key: string]: any };
    Error: EVA.Core.ServiceError;
  }

  export interface CreatePriceListAdjustment {
    PriceListID: number;
    Sequence: number;
    Name?: string;
    EffectiveDate?: string;
    ExpireDate?: string;
    OverridePrice: boolean;
    Type?: string;
    Data?: { [key: string]: any };
  }

  export interface CreatePriceListAdjustmentResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdatePriceListAdjustment {
    ID: number;
    PriceListID: number;
    Sequence: number;
    Name?: string;
    EffectiveDate?: string;
    ExpireDate?: string;
    OverridePrice: boolean;
    Type?: string;
    Data?: { [key: string]: any };
  }

  export interface DeletePriceListAdjustment {
    ID: number;
  }

  export interface ListPriceListAdjustments {
    PageConfig?: EVA.Core.PageConfig;
  }

  export interface ListPriceListAdjustmentsResponse {
    Result: EVA.Core.PagedResult<PriceListAdjustmentDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface PriceListAdjustmentDto {
    ID: number;
    PriceListID: number;
    PriceList: {
      Name: string;
      CurrencyID: string;
    };
    Sequence: number;
    Name: string;
    EffectiveDate?: string;
    ExpireDate?: string;
    OverridePrice: boolean;
    Type: string;
    Data: { [key: string]: any };
  }

  export interface GetPriceListByID {
    ID: number;
  }

  export interface GetPriceListByIDResponse {
    ID: number;
    Name: string;
    CurrencyID: string;
    IncludingVat: boolean;
    IsActive: boolean;
    SpecialPricesPriceListID: number;
    SpecialPricesPriceList: PriceListDto;
    Error: EVA.Core.ServiceError;
  }

  export interface PriceListDto {
    ID: number;
    Name: string;
    CurrencyID: string;
    IncludingVat: boolean;
    IsActive: boolean;
    SpecialPricesPriceListID: number;
    SpecialPricesPriceList: PriceListDto;
  }

  export interface CreatePriceList {
    Name?: string;
    CurrencyID?: string;
    IncludingVat: boolean;
    IsActive: boolean;
    SpecialPricesPriceListID: number;
  }

  export interface CreatePriceListResponse {
    ID: number;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdatePriceList {
    ID: number;
    Name?: string;
    CurrencyID?: string;
    IncludingVat: boolean;
    IsActive: boolean;
    SpecialPricesPriceListID: number;
  }

  export interface DeletePriceList {
    ID: number;
  }

  export interface ListPriceLists {
    PageConfig?: EVA.Core.PageConfig;
  }

  export interface ListPriceListsResponse {
    Result: EVA.Core.PagedResult<PriceListDto>;
    Error: EVA.Core.ServiceError;
  }

  /**
   * Get a PriceListManualInputAdjustment by ID
   */
  export interface GetPriceListManualInputAdjustmentByID {
    ID: number;
  }

  export interface GetPriceListManualInputAdjustmentByIDResponse {
    ID: number;
    PriceListAdjustmentID: number;
    Produc