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

The EVA core typings

declare module EVA.PIM {

  export namespace Errors {
    export namespace ProductSearchSynonyms {
      export const InvalidSynonymRule = 'ProductSearchSynonyms:InvalidRule';
    }

    export namespace ProductExcelServices {
      export const MissingHeaderRow = 'ProductExcelServices:MissingHeaderRow';
      export const UnitOfMeasureNotFound = 'ProductExcelServices:UnitOfMeasureNotFound';
      export const ProductNotFound = 'ProductExcelServices:ProductNotFound';
      export const InvalidUnitOfMeasureQuantity = 'ProductExcelServices:InvalidUnitOfMeasureQuantity';
      export const DuplicateBarcode = 'ProductExcelServices:DuplicateBarcode';
      export const InvalidBarcode = 'ProductExcelServices:InvalidBarcode';
    }

  }


  export interface GetProductByID {
    ID: number;
  }

  export interface GetProductByIDResponse {
    ID: number;
    BackendID: string;
    CustomID: string;
    PrimitiveName: string;
    TypeID: number;
    TaxCodeID: number;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdateProduct {
    ID: number;
    BackendID?: string;
    CustomID?: string;
    PrimitiveName?: string;
    TypeID: number;
    TaxCodeID: number;
  }

  /**
   * Replaces all search synonyms for a given LanguageID/CountryID with the provided ones.
   * Any synonyms not present in the request but that currently exist will be deleted.
   * 
   * ## Rules
   * The `Rule` must be formatted according to [what Elasticsearch accepts](https://www.elastic.co/guide/en/elasticsearch/reference/current/analysis-synonym-tokenfilter.html#_solr_synonyms):
   * 
   * - Comma-separated values: `jump, leap, hop` causes any of the matched terms to be replaced by all of the terms.
   * - Arrow notation: `britain=>england` causes the left side to be replaced by the right side.
   * 
   * To create a synonym, a `LanguageID` is required, but `CountryID` is optional.
   * Non-country specific synonyms are merged into the resulting list of synonyms when requesting synonyms for any country for that language.
   */
  export interface ReplaceProductSearchSynonyms {
    Rules: string[];
    LanguageID: string;
    CountryID?: string;
  }

  /**
   * Gets all currently created search synonyms for the provided LanguageID (required) and CountryID (optional).
   */
  export interface GetProductSearchSynonyms {
    LanguageID: string;
    CountryID?: string;
  }

  export interface GetProductSearchSynonymsResponse {
    Result: ProductSearchSynonym[];
    Error: EVA.Core.ServiceError;
  }

  export interface ProductSearchSynonym {
    ID: number;
    Rule: string;
    LanguageID: string;
    CountryID: string;
  }

  export interface ApplyRevision {
    RevisionID: number;
  }

  export interface CreateRevision {
    ApplicationID: number;
    Name?: string;
  }

  export interface CreateRevisionResponse {
    Result: CreatedRevision;
    Error: EVA.Core.ServiceError;
  }

  export interface CreatedRevision {
    ID: number;
    Name: string;
    ApplicationID: number;
  }

  export interface DeleteRevision {
    ID: number;
  }

  export interface GetRevisionStatus {
    RevisionID: number;
  }

  export interface GetRevisionStatusResponse {
    Status: RevisionProgress;
    Error: EVA.Core.ServiceError;
  }

  export interface RevisionProgress {
    TotalItems: number;
    HandledItems: number;
    State: ProductCompositionProgressState;
    Progress?: number;
    ValidationErrors: number;
  }

  export const enum ProductCompositionProgressState {
    None = 0,
    Composing = 1,
    PostProcessing = 2,
    Publishing = 3,
    Complete = 4
  }

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

  export interface ListRevisionsResponse {
    Result: EVA.Core.PagedResult<RevisionDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface RevisionDto {
    ID: number;
    Name: string;
    ApplicationID: number;
    Status: RevisionStatus;
    AppliedOn?: string;
    CreatedBy: ListRevisionUser;
    CreationTime?: string;
  }

  export const enum RevisionStatus {
    Open = 1,
    Applied = 2,
    Inactive = 4,
    InProgress = 8
  }

  export interface ListRevisionUser {
    FullName: string;
  }

  export interface ListRevisionValidationErrors {
    RevisionID: number;
    Offset: number;
    Cursor: number;
  }

  export interface ListRevisionValidationErrorsResponse {
    Offset: number;
    Cursor: number;
    Errors: { [key: string]: any }[];
    Error: EVA.Core.ServiceError;
  }

  export interface CreateNewSearchDataIndex {
    DeleteOldIndex: boolean;
  }

  export interface RequestReindexSearchData {
    Script?: string;
    LanguageID?: string;
    CountryID?: string;
    ApplyProductSearchConfiguration: boolean;
  }

  export interface RequestReindexSearchDataResponse {
    Error: EVA.Core.ServiceError;
  }

  export interface AddReferenceDataToProduct {
    ProductID: number;
    Data?: { [key: string]: any };
    Name?: string;
  }

  /**
   * Creates a new Product, given at least your `PrimitiveName` and `ProductType`.
   * 
   * - [x]  Given `PrimitiveName` is a name for the product to help you recognise it, but is rarely exposed to users or customers. This property does not support localization or translations!
   * - [x]  The `ProductType` is a flag enumeration value with one ore more of the following possible values;
   * 
   *   * `0` None
   *   * `1` Stock
   *   * `4` Marketing
   *   * `8` Gift Card
   *   * `16` Service
   *   * `64` Custom Pricing
   *   * `128` External
   *   * `256` Order Costs
   *   * `512` System Generated
   *   * `1024` Product Set
   *   * `2048` Bundle Product
   *   * `16384` Configurable
   *   * `32768` Supplier Product
   * 
   * Optionally, you can supply some additional information;
   * 
   * - [] `BackendID` is a number to help you identify this product. **Unique per `OrganizationUnitID` and `BackendSystemID`.**
   * - [] `BackendSystemID` is a string value to idenfity the source this product originated from - can be anything.
   * - [] `OrganizationUnitID` is the Organization Unit this product is linked to, or `null` when this is a generic EVA product.
   * - [] `CustomID` is a string value to help you identify this product, without any constraints, but indexed for optimal performance.
   * - [] `TaxCodeID` is an integer value indicating either `High`, `Low`, `Zero` or `Exempt` rates (unless modified by plugins) - defaults to `High`.
   * - [] `BrandID` to link it to any `Brand` entity.
   */
  export interface CreateProduct {
    PrimitiveName: string;
    ProductType: EVA.Core.ProductTypes;
    BrandID: number;
    BackendID?: string;
    BackendSystemID?: string;
    OrganizationUnitID: number;
    CustomID?: string;
    TaxCodeID: number;
  }

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

  /**
   * Modifies given product by its `ID` for a specific `RevisionID`.
   * 
   * The `Edits` is a list of `ProductEdit` objects, that defines some `Content` and the `LanguageID`, `CountryID` and  `LayerID` it applies to. The `Content` is a Json object with key-value pairs that holds
   * product information. The keys are simple strings, but the value can be a scalar value (like an int or string), an array of scalar values or an array of objects.
   * 
   * A `Revision` is a versioning container in which one or more product modifications are buffered. The changes to the product do not apply directly, but instead are stored in this `Revision` until it is
   * ready to be published. Also see the `CreateRevision` and `ApplyRevision` services. When omitted, a new 'quick' `Revision` is created and used here.
   * 
   * A `Layer` is a hierarchical solution to building product data. Every layer has its own `Level`, where the bottom layers will be overwritten by higher layers for colliding properties. A `Layer` has a
   * `Revision`. Also see the `CreateLayer` service. When omitted, a new 'quick' `Layer` is created and used here.
   */
  export interface EditProduct {
    ID: number;
    RevisionID: number;
    Edits: ProductEdit[];
  }

  export interface ProductEdit {
    LayerID: number;
    Content: { [key: string]: any };
    LanguageID: string;
    CountryID: string;
  }

  /**
   * Retrieves a `Product` with detailed information per `Layer`, from the given `ID` and `RevisionID` parameter.
   * 
   * In the response, `Content` is a Json formatted object containing key-value pair data, where the keys are simple strings and the value can be a scalar value (like an int or string), an array of scalar
   * values or an array of objects.
   * 
   * The `Types` property in the response data holds meta-data information about the property keys used in the `Content` object like property name, group and (of course) data type.
   * 
   * :point_right: Use the `GetProductForQuickEditByID` service when you want to apply all published `Revision`'s and only need the compressed `Layer` version of `Content`.
   */
  export interface GetProductForEditByID {
    ID: number;
    RevisionID: number;
  }

  export interface GetProductForEditByIDResponse {
    ID: number;
    CatalogID: number;
    DisplayValue: string;
    LayersWithContent: LayerWithContentDto[];
    Types: { [key: string]: { [key: string]: any } };
    Error: EVA.Core.ServiceError;
  }

  export interface LayerWithContentDto {
    ID: number;
    Name: string;
    Level: number;
    ApplicationID: number;
    LanguageID: string;
    CountryID: string;
    Content: { [key: string]: any };
    Description: string;
    DisplayValue: string;
  }

  /**
   * Retrieves a `Product` with detailed information, based on all currently applied `Revision`'s and the `Layer` data compressed into a single truth, from the given `ID` parameter.
   * 
   * In the response, `Content` is a Json formatted object containing key-value pair data, where the keys are simple strings and the value can be a scalar value (like an int or string), an array of scalar
   * values or an array of objects.
   * 
   * The `Types` property in the response data holds meta-data information about the property keys used in the `Content` object like property name, group and (of course) data type.
   * 
   * :point_right: Use the `GetProductForEditByID` service when you want to specify the `Revision` to apply and receive per-layer `Content`.
   */
  export interface GetProductForQuickEditByID {
    ID: number;
  }

  export interface GetProductForQuickEditByIDResponse {
    ID: number;
    CatalogID: number;
    DisplayValue: string;
    Content: { [key: string]: any };
    Types: { [key: string]: { [key: string]: any } };
    Error: EVA.Core.ServiceError;
  }

  export interface GetReferenceDataForProduct {
    ProductID: number;
  }

  export interface GetReferenceDataForProductResponse {
    Data: { [key: string]: { [key: string]: any } };
    Error: EVA.Core.ServiceError;
  }

  export interface GenerateProductExcelSample {
  }

  export interface DownloadProductExcel {
  }

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

  export interface UploadProductExcelResponse {
    Error: EVA.Core.ServiceError;
  }

  export interface UploadProductContentExcel {
    LanguageID?: string;
    Data?: number[];
  }

  export interface UploadProductContentExcelResponse {
    Error: EVA.Core.ServiceError;
  }

  export interface GenerateProductContentExcelSample {
  }

  export interface ExportProductContentExcel {
    Query?: string;
    Filters?: { [key: string]: EVA.Core.FilterModel };
    IncludedFields?: string[];
  }

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

  export interface UploadProductBarcodeExcelResponse {
    Error: EVA.Core.ServiceError;
  }

  export interface GenerateProductBarcodeExcelSample {
  }

  /**
   * Create a new ProductPropertyType
   */
  export interface CreateProductPropertyType {
    TypeID: string;
    CategoryID: string;
    DataType: ProductPropertyTypeDataTypes;
    SearchType: ProductPropertyTypeSearchTypes;
    IsArray: boolean;
    IsEnum: boolean;
    EditFunctionality?: string;
  }

  export const enum ProductPropertyTypeDataTypes {
    None = 0,
    Integer = 1,
    Double = 2,
    Boolean = 3,
    String = 4,
    Blob = 5,
    Date = 6,
    RichText = 7
  }

  export const enum ProductPropertyTypeSearchTypes {
    None = 0,
    Keyword = 1,
    Text = 2,
    IsHidden = 4
  }

  export interface EditProductPropertyType {
    ID?: string;
    RevisionID: number;
    Edits: ProductPropertyTypeEdit[];
    SearchType: ProductPropertyTypeSearchTypes;
  }

  export interface ProductPropertyTypeEdit {
    LayerID: number;
    Content: { [key: string]: any };
  }

  export interface EditProductPropertyTypeResponse {
    Error: EVA.Core.ServiceError;
  }

  export interface GetAvailableEnumValuesForProductPropertyType {
    TypeID?: string;
  }

  export interface GetAvailableEnumValuesForProductPropertyTypeResponse {
    Values: { [key: number]: string };
    Error: EVA.Core.ServiceError;
  }

  export interface GetProductPropertyTypeByID {
    ID?: string;
    RevisionID: number;
  }

  export interface GetProductPropertyTypeByIDResponse {
    ID: string;
    CatalogID: number;
    LayersWithContent: LayerWithContentDto[];
    CategoryID: string;
    Error: EVA.Core.ServiceError;
  }

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

  export interface ListProductPropertyTypesResponse {
    Result: EVA.Core.PagedResult<ListProductPropertyTypesDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface ListProductPropertyTypesDto {
    ID: string;
    /**
     * @deprecated Replaced with DisplayName
     */
    Name: string;
    DisplayName: string;
    CategoryID: string;
    /**
     * @deprecated Replaced with CategoryDisplayName
     */
    CategoryName: string;
    CategoryDisplayName: string;
    DataType: ProductPropertyTypeDataTypes;
  }

  export interface PreviewProductPropertyType {
    ID?: string;
    RevisionID: number;
    Edits: ProductPropertyTypeEdit[];
  }

  export interface PreviewProductPropertyTypeResponse {
    Result: { [key: string]: any };
    Error: EVA.Core.ServiceError;
  }

  export interface GetProductPropertyTypeEnumValueByID {
    ID: number;
  }

  export interface GetProductPropertyTypeEnumValueByIDResponse {
    ID: number;
    ProductPropertyTypeID: string;
    CatalogID: number;
    Identifier: number;
    Value: string;
    LanguageID: string;
    CountryID: string;
    Error: EVA.Core.ServiceError;
  }

  export interface CreateProductPropertyTypeEnumValue {
    ProductPropertyTypeID?: string;
    Identifier: number;
    Value?: string;
    LanguageID?: string;
    CountryID?: string;
  }

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

  export interface UpdateProductPropertyTypeEnumValue {
    ID: number;
    Identifier: number;
    Value?: string;
    LanguageID?: string;
    CountryID?: string;
  }

  export interface DeleteProductPropertyTypeEnumValue {
    ID: number;
  }

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

  export interface ListProductPropertyTypeEnumValuesResponse {
    Result: EVA.Core.PagedResult<ProductPropertyTypeEnumValueDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface ProductPropertyTypeEnumValueDto {
    ID: number;
    ProductPropertyTypeID: string;
    Identifier: number;
    Value: string;
    LanguageID: string;
    CountryID: string;
  }

  export interface SearchProductPropertyTypes {
    Query?: string;
    PageConfig?: EVA.Core.PageConfig;
  }

  export interface SearchProductPropertyTypesResponse {
    Result: EVA.Core.PagedResult<{ [key: string]: any }>;
    Error: EVA.Core.ServiceError;
  }

  export interface CreateProductPropertyCategory {
    CategoryID?: string;
    EditFunctionality?: string;
  }

  export interface CreateProductPropertyCategoryResponse {
    Error: EVA.Core.ServiceError;
  }

  export interface EditProductPropertyCategory {
    ID?: string;
    RevisionID: number;
    Edits: ProductPropertyCategoryEdit[];
  }

  export interface ProductPropertyCategoryEdit {
    LayerID: number;
    Content: { [key: string]: any };
  }

  export interface EditProductPropertyCategoryResponse {
    Error: EVA.Core.ServiceError;
  }

  export interface GetProductPropertyCategoryByID {
    ID?: string;
    RevisionID: number;
  }

  export interface GetProductPropertyCategoryByIDResponse {
    ID: string;
    CatalogID: number;
    LayersWithContent: LayerWithContentDto[];
    Error: EVA.Core.ServiceError;
  }

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

  export interface ListProductPropertyCategoriesResponse {
    Result: EVA.Core.PagedResult<ListProductPropertyCategoriesDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface ListProductPropertyCategoriesDto {
    ID: string;
    /**
     * @deprecated Replaced with DisplayName
     */
    Name: string;
    DisplayName: string;
  }

  export interface PreviewProductPropertyCategory {
    ID?: string;
    RevisionID: number;
    Edits: ProductPropertyCategoryEdit[];
  }

  export interface PreviewProductPropertyCategoryResponse {
    Result: { [key: string]: any };
    Error: EVA.Core.ServiceError;
  }

  /**
   * Returns the AssortmentContentCultures
   */
  export interface GetAssortmentContentCultures {
  }

  export interface GetAssortmentContentCulturesResponse {
    ContentCultures: AssortmentContentCulture[];
    Error: EVA.Core.ServiceError;
  }

  export interface AssortmentContentCulture {
    AssortmentID: number;
    AssortmentName: string;
    CultureID: string;
    LanguageID: string;
    CountryID: string;
  }

  /**
   * Creates a new AssortmentContentCulture.
   * If it already exists, nothing will be done.
   */
  export interface CreateAssortmentContentCulture {
    AssortmentID: number;
    LanguageID?: string;
    CountryID?: string;
  }

  /**
   * Deletes an existing AssortmentContentCulture. If there are any existing mappings to this ContentCulture, they will also be deleted.
   */
  export interface DeleteAssortmentContentCulture {
    AssortmentID: number;
    LanguageID?: string;
    CountryID?: string;
  }

  /**
   * Returns the current ContentCultureMapping.
   */
  export interface ListContentCultureMapping {
    PageConfig?: EVA.Core.PageConfig<ContentCultureMappingFilter>;
  }

  export interface ContentCultureMappingFilter {
    SourceLanguageID: string;
    SourceCountryID: string;
    ContentLanguageID: string;
    ContentCountryID: string;
  }

  export interface ListContentCultureMappingResponse {
    Result: EVA.Core.PagedResult<ContentCultureMappingDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface ContentCultureMappingDto {
    ID: number;
    SourceLanguageID: string;
    SourceCountryID: string;
    ContentCultureID: string;
    ContentLanguageID: string;
    ContentCountryID: string;
  }

  /**
   * Creates a new ContentCultureMapping for the current application.
   */
  export interface CreateContentCultureMapping {
    SourceLanguageID?: string;
    SourceCountryID?: string;
    ContentLanguageID: string;
    ContentCountryID: string;
  }

  /**
   * Deletes an existing ContentCultureMapping.
   */
  export interface DeleteContentCultureMapping {
    ID: number;
  }

  export interface ListApplicationCultures {
  }

  export interface ListApplicationCulturesResponse {
    Result: ListApplicationContentCulture[];
    Error: EVA.Core.ServiceError;
  }

  export interface ListApplicationContentCulture {
    ApplicationID: number;
    LanguageID: string;
    CountryID: string;
    Culture: string;
  }

  export interface CreateLayer {
    ApplicationID: number;
    CountryID?: string;
    Description?: string;
    LanguageID?: string;
    Level: number;
    Name?: string;
  }

  export interface CreateLayerResponse {
    Result: CreatedLayer;
    Error: EVA.Core.ServiceError;
  }

  export interface CreatedLayer {
    ID: number;
    Name: string;
    ApplicationID: number;
    Description: string;
    Level: number;
    CountryID: string;
  }

  export interface GetLayerByID {
    ID: number;
  }

  export interface GetLayerByIDResponse {
    Layer: LayerDto;
    Error: EVA.Core.ServiceError;
  }

  export interface LayerDto {
    ID: number;
    Description: string;
    Level: number;
    ApplicationID: number;
    LanguageID: string;
    CatalogID: number;
    Name: string;
    CountryID: string;
    Type: ContentLayerTypes;
  }

  export const enum ContentLayerTypes {
    UserLayer = 0,
    SystemLayer = 1
  }

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

  export interface ListLayersResponse {
    Result: EVA.Core.PagedResult<LayerDto>;
    Error: EVA.Core.ServiceError;
  }

  export interface UpdateLayer {
    ID: number;
    Name?: string;
    Description?: string;
    Level: number;
  }

  /**
   * Creates a search strategy for the provided LanguageID and CountryID (both are optional).
   * 
   * All parts of the `Strategy` field are optional.
   */
  export interface CreateProductSearchStrategy {
    CountryID?: string;
    LanguageID?: string;
    Name: string;
    Code?: string;
    Strategy: ProductSearchStrategyModel;
  }

  export interface ProductSearchStrategyModel {
    Condition: StrategyCondition;
    Scoring: ScoringStrategy;
    Sorting: SortingStrategy;
    Query: QueryStrategy;
  }

  export interface StrategyCondition {
    Query: QueryCondition;
    Filters: FilterCondition[];
  }

  export interface QueryCondition {
    Text: string;
    Type: QueryConditionTypes;
  }

  export const enum QueryConditionTypes {
    Equals = 0,
    Contains = 1,
    StartsWith = 2
  }

  export interface FilterCondition {
    ProductPropertyTypeID: string;
    FilterValue: string;
  }

  export interface ScoringStrategy {
    ScoreMode: ScoreModes;
    BoostMode: BoostMode;
    ScoringFunctions: ScoringFunction[];
    MaxBoost: number;
    MinScore: number;
    StockScoring: StockScoringStrategy;
  }

  export const enum ScoreModes {
    Multiply = 0,
    Sum = 1,
    Average = 2,
    First = 3,
    Max = 4,
    Min = 5
  }

  export const enum BoostMode {
    Multiply = 0,
    Replace = 1,
    Sum = 2,
    Average = 3,
    Max = 4,
    Min = 5
  }

  export interface ScoringFunction {
    Type: ScoringFunctionTypes;
    Options: { [key: string]: any };
    Weight: number;
  }

  export const enum ScoringFunctionTypes {
    FieldValueFactor = 0,
    Script = 1
  }

  export interface StockScoringStrategy {
    AdjustScoreByStock: boolean;
    BoostAmount: number;
    Type: StockStrategyTypes;
  }

  export const enum StockStrategyTypes {
    CurrentOrganizationUnit = 0,
    Suppliers = 1
  }

  export interface SortingStrategy {
    Sort: SortingStrategySort[];
    StockSorting: StockSortingStrategy;
  }

  export interface SortingStrategySort {
    Order: SortingStrategyOrder;
    Script: SortingStrategySortScript;
    Field: string;
    MissingValue: any;
  }

  export const enum SortingStrategyOrder {
    Ascending = 0,
    Descending = 1
  }

  export interface SortingStrategySortScript {
    Type: SortingScriptType;
    Source: string;
    Language: string;
  }

  export const enum SortingScriptType {
    Number = 0,
    String = 1
  }

  export interface StockSortingStrategy {
    SortByStock: boolean;
    Type: StockStrategyTypes;
  }

  export interface QueryStrategy {
    Queries: MultiMatchQuery[];
    MinimumShouldMatch: string;
    StockFilter: StockFilterStrategy;
  }

  export interface MultiMatchQuery {
    Type: MultiMatchType;
    Slop: number;
    Fuzziness: MultiMatchFuzziness;
    Operator: MatchOperator;
    Boost: number;
    RequirementType: QueryRequirementType;
    PropertiesToSearch: ProductPropertyTypeToSearch[];
    Analyzer: string;
    MinimumShouldMatch: string;
  }

  export const enum MultiMatchType {
    BestFields = 0,
    MostFields = 1,
    CrossFields = 2,
    Phrase = 3,
    PhrasePrefix = 4
  }

  export interface MultiMatchFuzziness {
    EditDistance: number;
    PrefixLength: number;
    MaxExpansions: number;
  }

  export const enum MatchOperator {
    And = 0,
    Or = 1
  }

  export const enum QueryRequirementType {
    Must = 0,
    Should = 1
  }

  export interface ProductPropertyTypeToSearch {
    ID: string;
    Boost?: number;
  }

  export interface StockFilterStrategy {
    FilterByStock: boolean;
    Type: StockStrategyTypes;
  }

  /**
   * Updates a search strategy, replacing the current strategy with the one provided and setting the LanguageID/CountryID
   * to the provided ones (both are optional).
   * 
   * All parts of the `Strategy` field are optional.
   */
  export interface UpdateProductSearchStrategy {
    ID: number;
    CountryID?: string;
    LanguageID?: string;
    Name?: string;
    Code?: string;
    Strategy: ProductSearchStrategyModel;
  }

  /**
   * Deletes a search strategy by the provided ID.
   */
  export interface DeleteProductSearchStrategy {
    ID: number;
  }

  /**
   * Retrieves a paged list of search strategies, optionally filtered by a CountryID or LanguageID.
   */
  export interface ListProductSearchStrategies {
    PageConfig?: EVA.Core.PageConfig<ListProductSearchStrategiesFilter>;
  }

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

  export interface ListProductSearchStrategiesResponse {
    Result: EVA.Core.PagedResult<ListProductSearchStrategyItem>;
    Error: EVA.Core.ServiceError;
  }

  export interface ListProductSearchStrategyItem {
    ID: number;
    CatalogID: number;
    LanguageID: string;
    CountryID: string;
    Name: string;
    Code: string;
    TypeID: number;
    Type: ProductSearchStrategyTypes;
    OrganizationUnitTypeID: number;
    OrganizationUnitType: EVA.Core.OrganizationUnitTypes;
    Strategy: ProductSearchStrategyModel;
    SerializedStrategy: string;
  }

  export const enum ProductSearchStrategyTypes {
    Full = 0,
    Partial = 1
  }

  /**
   * Creates a ProductSearchConfiguration for your current Catalog if it doesn't exist, or replaces the existing one.
   * All properties on the configuration are optional.
   */
  export interface CreateOrReplaceProductSearchConfiguration {
    Configuration?: ProductSearchConfigurationModel;
  }

  export interface ProductSearchConfigurationModel {
    Analyzers: Analyzer[];
    TokenFilters: TokenFilter[];
    CharFilters: CharFilter[];
    ProductPropertyTypes: ProductPropertyTypeConfiguration[];
    DisableSynonyms: boolean;
    IndexPipelineScript: string;
  }

  export interface Analyzer {
    Name: string;
    LanguageID: string;
    CountryID: string;
    Type: string;
    Tokenizer: string;
    Filters: string[];
    CharFilters: string[];
  }

  export interface TokenFilter {
    Name: string;
    LanguageID: string;
    CountryID: string;
    Type: string;
    Options: { [key: string]: any };
  }

  export interface CharFilter {
    Name: string;
    LanguageID: string;
    CountryID: string;
    Type: string;
    Options: { [key: string]: any };
  }

  export interface ProductPropertyTypeConfiguration {
    Name: string;
    LanguageID: string;
    CountryID: string;
    Analyzer: string;
    SearchAnalyzer: string;
    CopyTo: string;
  }

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

  /**
   * Retrieves the ProductSearchConfiguration for your current Catalog, or an empty one if it doesn't exist.
   */
  export interface GetProductSearchConfiguration {
  }

  export interface GetProductSearchConfigurationResponse {
    Configuration: ProductSearchConfigurationModel;
    Error: EVA.Core.ServiceError;
  }

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

  export interface GetBrand {
    ID: number;
  }

  export interface GetBrandResponse {
    Result: BrandDto;
    Error: EVA.Core.ServiceError;
  }

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

  export interface UpdateBrand {
    ToUpdate?: BrandDto;
  }

  /**
   * Compose ALL the products, use with caution.
   */
  export interface ComposeAllProducts {
    LanguageIDs: string[];
  }

  export interface ComposeResponse {
    UID: string;
    Error: EVA.Core.ServiceError;
  }

  /**
   * Composes all the products that have been affected in `RevisionID`.
   */
  export interface ComposeRevision {
    RevisionID: number;
    LanguageIDs: string[];
  }

  /**
   * Composes the given set of products
   */
  export interface ComposeProducts {
    ProductIDs: number[];
    LanguageIDs: string[];
  }

  export interface ComposePropertyTypes {
  }

  /**
   * Returns the progress of a composition session. `RevisionID` is preferred over the `UID` and
   * of of both is required.
   */
  export interface GetCompositionProgress {
    RevisionID: number;
    UID?: string;
  }

  export interface GetCompositionProgressResponse {
    State: ProductCompositionProgressState;
    Current: number;
    Total: number;
    Progress?: number;
    Error: EVA.Core.ServiceError;
  }

}