eva-sdk-js/typings/EVA.PIM.Core.d.ts

The JavaScript based SDK for the EVA platform

/* tslint:disable:max-classes-per-file */
/* tslint:disable:variable-name */
/* tslint:disable:no-trailing-whitespace */
/* tslint:disable:no-consecutive-blank-lines */
/* tslint:disable:no-namespace */
/* tslint:disable:member-access */
/* tslint:disable:typedef-whitespace */
/* tslint:disable:no-internal-module */

declare module EVA.PIM.Core {
  
  export class AbstractComposeProducts extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.ComposeResponse> {
    LanguageIDs : string[]; 
  }
  
  export class AddReferenceDataToProduct extends EVA.API.RequestMessageWithEmptyResponse {
    ProductID : number; // Int32
    Data : any; 
    Name : string; 
  }
  
  export class ProductSearchStrategyModelAggregationStrategy {
    VariationAggregations : EVA.PIM.Core.ProductSearchStrategyModelAggregationStrategyProductVariationAggregation[]; 
    StockFilterType : EVA.PIM.Core.StockFilterTypes; 
  }
  
  export class ProductSearchConfigurationModelAnalyzer implements EVA.PIM.Core.ProductSearchConfigurationModelIHasCulture {
    Name : string; 
    LanguageID : string; 
    Type : string; 
    Tokenizer : string; 
    Filters : string[]; 
    CharFilters : string[]; 
  }
  
  export class ApplyRevision extends EVA.API.RequestMessageWithEmptyResponse {
    RevisionID? : number; // Int32, nullable
  }
  
  export class GetAssortmentContentCulturesResponseAssortmentContentCulture {
    AssortmentID : number; // Int32
    AssortmentName : string; 
    CultureID : string; 
    LanguageID : string; 
    CountryID : string; 
  }
  
  export enum BoostMode {
    Multiply = 0,
    Replace = 1,
    Sum = 2,
    Average = 3,
    Max = 4,
    Min = 5,
  }
  
  export class BrandDto {
    ID : number; // Int32
    Name : string; 
    BackendID : string; 
  }
  
  export class CancelComposeProducts extends EVA.API.RequestMessageWithEmptyResponse {
    CompositionID : string; 
  }
  
  export class ProductSearchConfigurationModelCharFilter implements EVA.PIM.Core.ProductSearchConfigurationModelIHasCulture {
    Name : string; 
    LanguageID : string; 
    Type : string; 
    Options : any; 
  }
  
  export class ComposeAllProducts extends EVA.PIM.Core.AbstractComposeProducts {
  }
  
  export class ComposeProducts extends EVA.PIM.Core.AbstractComposeProducts {
    ProductIDs : number[]; 
  }
  
  export class ComposeProducts2 extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.ComposeProducts2Response> {
    ProductIDs : number[]; 
  }
  
  export class ComposeProducts2Response extends EVA.API.ResponseMessage {
    CompositionID : string; 
  }
  
  export class ComposePropertyTypes extends EVA.API.RequestMessageWithEmptyResponse {
  }
  
  export class ComposeResponse extends EVA.API.ResponseMessage {
    UID : string; 
  }
  
  export class ComposeRevision extends EVA.PIM.Core.AbstractComposeProducts {
    RevisionID : number; // Int32
  }
  
  export class ListContentCultureMappingResponseContentCultureMappingDto {
    ID : number; // Int32
    SourceLanguageID : string; 
    SourceCountryID : string; 
    ContentCultureID : string; 
    ContentLanguageID : string; 
    ContentCountryID : string; 
  }
  
  export class ContentCultureMappingFilter {
    SourceLanguageID : string; 
    SourceCountryID : string; 
    ContentLanguageID : string; 
    ContentCountryID : string; 
  }
  
  export enum ContentUpdateTypes {
    Replace = 0,
    Merge = 1,
  }
  
  export class CreateAssortmentContentCulture extends EVA.API.RequestMessageWithEmptyResponse {
    AssortmentID : number; // Int32
    LanguageID : string; 
    CountryID : string; 
  }
  
  export class CreateBrand extends EVA.API.RequestMessageWithEmptyResponse {
    BackendID : string; 
    Name : string; 
  }
  
  export class CreateContentCultureMapping extends EVA.API.RequestMessageWithEmptyResponse {
    SourceLanguageID : string; 
    SourceCountryID : string; 
    ContentLanguageID : string; 
    ContentCountryID : string; 
  }
  
  export class CreatedLayer {
    ID : number; // Int32
    Name : string; 
    ApplicationID? : number; // Int32, nullable
    Description : string; 
    Level : number; // Int32
    CountryID : string; 
  }
  
  export class CreatedRevision {
    ID : number; // Int32
    Name : string; 
    ApplicationID? : number; // Int32, nullable
  }
  
  export class CreateLayer extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.CreateLayerResponse> {
    ApplicationID? : number; // Int32, nullable
    CountryID : string; 
    Description : string; 
    LanguageID : string; 
    Level : number; // Int32
    Name : string; 
  }
  
  export class CreateLayerResponse extends EVA.API.ResponseMessage {
    Result : EVA.PIM.Core.CreatedLayer; 
  }
  
  export class CreateNewSearchDataIndex extends EVA.API.RequestMessageWithEmptyResponse {
    DeleteOldIndex : boolean; 
  }
  
  export class CreateOrReplaceProductSearchConfiguration extends EVA.API.RequestMessageWithEmptyResponse {
    Configuration : EVA.PIM.Core.ProductSearchConfigurationModel; 
  }
  
  export class CreateProduct extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.CreateProductResponse> {
    PrimitiveName : string; 
    ProductType : EVA.Core.ProductTypes; 
    BrandID? : number; // Int32, nullable
    BackendID : string; 
    BackendSystemID : string; 
    OrganizationUnitID? : number; // Int32, nullable
    CustomID : string; 
    TaxCodeID? : number; // Int32, nullable
    LogicalLevel : string; 
    LedgerClassID : string; 
  }
  
  export class CreateProductPropertyCategory extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.CreateProductPropertyCategoryResponse> {
    CategoryID : string; 
    EditFunctionality : string; 
  }
  
  export class CreateProductPropertyCategoryResponse extends EVA.API.ResponseMessage {
  }
  
  export class CreateProductPropertyType extends EVA.API.RequestMessageWithEmptyResponse {
    TypeID : string; 
    CategoryID : string; 
    DataType : EVA.PIM.Common.ProductPropertyTypeDataTypes; 
    SearchType : EVA.PIM.Common.ProductPropertyTypeSearchTypes; 
    Options : EVA.PIM.Core.ProductPropertyTypeOptions; 
    IsArray : boolean; 
    IsEnum : boolean; 
    EditFunctionality : string; 
  }
  
  export class CreateProductPropertyTypeEnumValue extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.CreateProductPropertyTypeEnumValueResponse> {
    ProductPropertyTypeID : string; 
    Identifier : number; // Int32
    Value : string; 
    LanguageID : string; 
    CountryID : string; 
  }
  
  export class CreateProductPropertyTypeEnumValueResponse extends EVA.API.ResponseMessage {
    ID : number; // Int32
  }
  
  export class CreateProductResponse extends EVA.API.ResponseMessage {
    ID : number; // Int32
  }
  
  export class CreateProductSearchStrategy extends EVA.API.RequestMessageGeneric<EVA.API.CreateResponse> {
    CountryID : string; 
    LanguageID : string; 
    Name : string; 
    Code : string; 
    Strategy : EVA.PIM.Core.ProductSearchStrategyModel; 
  }
  
  export class CreateRevision extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.CreateRevisionResponse> {
    ApplicationID? : number; // Int32, nullable
    Name : string; 
  }
  
  export class CreateRevisionResponse extends EVA.API.ResponseMessage {
    Result : EVA.PIM.Core.CreatedRevision; 
  }
  
  export class DeleteAssortmentContentCulture extends EVA.API.RequestMessageWithEmptyResponse {
    AssortmentID : number; // Int32
    LanguageID : string; 
    CountryID : string; 
  }
  
  export class DeleteContentCultureMapping extends EVA.API.RequestMessageWithEmptyResponse {
    ID : number; // Int32
  }
  
  export class DeleteProductPropertyTypeEnumValue extends EVA.API.RequestMessageWithEmptyResponse {
    ID : number; // Int32
  }
  
  export class DeleteProductSearchStrategy extends EVA.API.RequestMessageWithEmptyResponse {
    ID : number; // Int32
  }
  
  export class DeleteRevision extends EVA.API.RequestMessageWithEmptyResponse {
    ID : number; // Int32
  }
  
  export class DownloadProductExcel extends EVA.API.RequestMessageGeneric<EVA.API.ResourceResponseMessage> {
  }
  
  export class EditProduct extends EVA.API.RequestMessageGeneric<EVA.API.EmptyResponseMessage> {
    ID : number; // Int32
    RevisionID? : number; // Int32, nullable
    Edits : EVA.PIM.Core.ProductEdit[]; 
  }
  
  export class EditProductPropertyCategory extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.EditProductPropertyCategoryResponse> {
    ID : string; 
    RevisionID : number; // Int32
    Edits : EVA.PIM.Core.ProductPropertyCategoryEdit[]; 
  }
  
  export class EditProductPropertyCategoryResponse extends EVA.API.ResponseMessage {
  }
  
  export class EditProductPropertyType extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.EditProductPropertyTypeResponse> {
    ID : string; 
    RevisionID? : number; // Int32, nullable
    Edits : EVA.PIM.Core.ProductPropertyTypeEdit[]; 
    SearchType : EVA.PIM.Common.ProductPropertyTypeSearchTypes; 
    Options : EVA.PIM.Core.ProductPropertyTypeOptions; 
  }
  
  export class EditProductPropertyTypeResponse extends EVA.API.ResponseMessage {
  }
  
  export class ExportProductContentExcel extends EVA.API.RequestMessageGeneric<EVA.API.ResourceResponseMessage> {
    Query : string; 
    Filters : { [ key : string ] : EVA.Core.FilterModel }; 
    IncludedFields : string[]; 
  }
  
  export class ProductSearchStrategyModelFilterCondition {
    ProductPropertyTypeID : string; 
    FilterValue : string; 
  }
  
  export class GenerateProductBarcodeExcelSample extends EVA.API.RequestMessageGeneric<EVA.API.ResourceResponseMessage> {
  }
  
  export class GenerateProductContentExcelSample extends EVA.API.RequestMessageGeneric<EVA.API.ResourceResponseMessage> {
  }
  
  export class GenerateProductExcelSample extends EVA.API.RequestMessageGeneric<EVA.API.ResourceResponseMessage> {
  }
  
  export class GetAssortmentContentCultures extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.GetAssortmentContentCulturesResponse> {
  }
  
  export class GetAssortmentContentCulturesResponse extends EVA.API.ResponseMessage {
    ContentCultures : EVA.PIM.Core.GetAssortmentContentCulturesResponseAssortmentContentCulture[]; 
  }
  
  export class GetAvailableEnumValuesForProductPropertyType extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.GetAvailableEnumValuesForProductPropertyTypeResponse> {
    TypeID : string; 
  }
  
  export class GetAvailableEnumValuesForProductPropertyTypeResponse extends EVA.API.ResponseMessage {
    Values : { [ key : number ] : string }; 
  }
  
  export class GetBrand extends EVA.API.GetRequestGeneric<EVA.PIM.Core.GetBrandResponse> {
  }
  
  export class GetBrandResponse extends EVA.API.ResponseMessage {
    Result : EVA.PIM.Core.BrandDto; 
  }
  
  export class GetCompositionProgress extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.GetCompositionProgressResponse> {
    RevisionID? : number; // Int32, nullable
    UID : string; 
  }
  
  export class GetCompositionProgressResponse extends EVA.API.ResponseMessage {
    State : EVA.PIM.Core.ProductCompositionProgressState; 
    Current : number; // Int32
    Total : number; // Int32
    Progress : number; // Double
  }
  
  export class GetLayerByID extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.GetLayerByIDResponse> {
    ID : number; // Int32
  }
  
  export class GetLayerByIDResponse extends EVA.API.ResponseMessage {
    Layer : EVA.PIM.Core.LayerDto; 
  }
  
  export class GetProductByID extends EVA.API.GetRequestGeneric<EVA.PIM.Core.GetProductByIDResponse> {
  }
  
  export class GetProductByIDResponse extends EVA.API.ResponseMessage {
    ID : number; // Int32
    BackendID : string; 
    CustomID : string; 
    PrimitiveName : string; 
    TypeID : number; // Int32
    TaxCodeID : number; // Int32
    LedgerClassID : string; 
  }
  
  export class GetProductCompositionState extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.GetProductCompositionStateResponse> {
    CompositionID : string; 
  }
  
  export class GetProductCompositionStateResponse extends EVA.API.ResponseMessage {
    Status : string; 
    TotalProductCount : number; // Int32
    TotalComposeCount : number; // Int32
    ProductsComposed : number; // Int32
    CompositionCount : number; // Int32
    DocumentsCopiedToElasticsearch : number; // Int32
    DocumentsCopiedToStaging : number; // Int32
    BytesWrittenToElasticsearch : number; // Int64
    BytesWrittenToStaging : number; // Int64
    CreationTime : string; // DateTime
    CompositionsPerSecond : number; // Int32
    ProductsComposedPerSecond : number; // Int32
    DocumentsCopiedToElasticsearchPerSecond : number; // Int32
    DocumentsCopiedToStagingPerSecond : number; // Int32
    BytesWrittenToElasticsearchPerSecond : number; // Int32
    BytesWrittenToStagingPerSecond : number; // Int32
    RemainingBatchCount : number; // Int32
    CompletionTime? : string; // DateTime, nullable
    ComposeWaitTimeInSeconds : number; // Double
    StorageWaitTimeInSeconds : number; // Double
    ElapsedTimeInSeconds : number; // Double
    ElasticsearchWaitTimeInSeconds : number; // Double
    ComposeProcessingTimeInSeconds : number; // Double
    DatabaseQueryWaitTimeInSeconds : number; // Double
  }
  
  export class GetProductForEditByID extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.GetProductForEditByIDResponse> {
    ID : number; // Int32
    RevisionID : number; // Int32
  }
  
  export class GetProductForEditByIDResponse extends EVA.API.ResponseMessage {
    ID : number; // Int32
    CatalogID : number; // Int32
    DisplayValue : string; 
    LayersWithContent : EVA.PIM.Core.LayerWithContentDto[]; 
    Types : { [ key : string ] : any }; 
  }
  
  export class GetProductForQuickEditByID extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.GetProductForQuickEditByIDResponse> {
    ID : number; // Int32
  }
  
  export class GetProductForQuickEditByIDResponse extends EVA.API.ResponseMessage {
    ID : number; // Int32
    CatalogID : number; // Int32
    DisplayValue : string; 
    Content : any; 
    Types : { [ key : string ] : any }; 
  }
  
  export class GetProductPropertyCategoryByID extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.GetProductPropertyCategoryByIDResponse> {
    ID : string; 
    RevisionID : number; // Int32
  }
  
  export class GetProductPropertyCategoryByIDResponse extends EVA.API.ResponseMessage {
    ID : string; 
    CatalogID : number; // Int32
    LayersWithContent : EVA.PIM.Core.LayerWithContentDto[]; 
  }
  
  export class GetProductPropertyTypeByID extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.GetProductPropertyTypeByIDResponse> {
    ID : string; 
    RevisionID : number; // Int32
  }
  
  export class GetProductPropertyTypeByIDResponse extends EVA.API.ResponseMessage {
    ID : string; 
    CatalogID : number; // Int32
    LayersWithContent : EVA.PIM.Core.LayerWithContentDto[]; 
    CategoryID : string; 
  }
  
  export class GetProductPropertyTypeEnumValueByID extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.GetProductPropertyTypeEnumValueByIDResponse> {
    ID : number; // Int32
  }
  
  export class GetProductPropertyTypeEnumValueByIDResponse extends EVA.API.ResponseMessage {
    ID : number; // Int32
    ProductPropertyTypeID : string; 
    CatalogID : number; // Int32
    Identifier : number; // Int32
    Value : string; 
    LanguageID : string; 
    CountryID : string; 
  }
  
  export class GetProductSearchConfiguration extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.GetProductSearchConfigurationResponse> {
  }
  
  export class GetProductSearchConfigurationResponse extends EVA.API.ResponseMessage {
    Configuration : EVA.PIM.Core.ProductSearchConfigurationModel; 
  }
  
  export class GetProductSearchSynonyms extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.GetProductSearchSynonymsResponse> {
    LanguageID : string; 
  }
  
  export class GetProductSearchSynonymsResponse extends EVA.API.ResponseMessage {
    Result : EVA.PIM.Core.GetProductSearchSynonymsResponseProductSearchSynonym[]; 
  }
  
  export class GetReferenceDataForProduct extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.GetReferenceDataForProductResponse> {
    ProductID : number; // Int32
  }
  
  export class GetReferenceDataForProductResponse extends EVA.API.ResponseMessage {
    Data : { [ key : string ] : any }; 
  }
  
  export class GetRevisionStatus extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.GetRevisionStatusResponse> {
    RevisionID : number; // Int32
  }
  
  export class GetRevisionStatusResponse extends EVA.API.ResponseMessage {
    Status : EVA.PIM.Core.RevisionProgress; 
  }
  
  export interface ProductSearchConfigurationModelIHasCulture {
    LanguageID : string; 
  }
  
  export enum ImageSortingLogic {
    ByCurrentOrdering = 0,
    BySize = 1,
  }
  
  export class ImportProducts extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.ImportProductsResponse> {
    // <br />A string that identifies the system that was used to call this service. In combination with a product's ID, this is what uniquely identifies the product in EVA.<br />The SystemID must be the same for every call, if it's different from a previous call then new products will be created.
    SystemID : string; 
    // Determines the behavior of this service.
    Type : EVA.PIM.Core.ImportType; 
    // <br />The LogicalLevel that will be assigned to the root level of a product hierarcy. If not specified a default value is used.<br /><br />See ProductVariation.LogicalLevel for more information.<br />
    RootLogicalLevel : string; 
    // The list of products to create or update. If a product does not exist it's created and if a product with the same ID and SystemID already exists it is updated.
    Products : EVA.PIM.Core.ImportProductsProduct[]; 
  }
  
  export class ImportProductsResponse extends EVA.API.ResponseMessage {
    // The EVA IDs of the products were touched by this call.
    UpdatedProductIDs : number[]; 
    // The EVA IDs of the products that were newly created by this call.
    CreatedProductIDs : number[]; 
    // If the Type of the request was PreviewOnly this property will contain the product structure that would be generated.
    PreviewResult : string; 
    // Contains an entry for every product mapping the input string ID to its internal EVA integer ID.
    ProductMap : EVA.PIM.Core.ProductMapItem[]; 
  }
  
  export enum ImportType {
    Normal = 0,
    ContentOnly = 1,
    PreviewOnly = 2,
  }
  
  export enum ImportTypes {
    Normal = 0,
    ContentOnly = 1,
  }
  
  export class LayerDto {
    ID : number; // Int32
    Description : string; 
    Level : number; // Int32
    ApplicationID? : number; // Int32, nullable
    LanguageID : string; 
    CatalogID : number; // Int32
    Name : string; 
    CountryID : string; 
    Type : EVA.PIM.Common.ContentLayerTypes; 
  }
  
  export class LayerWithContentDto {
    ID : number; // Int32
    Name : string; 
    Level : number; // Int32
    ApplicationID? : number; // Int32, nullable
    LanguageID : string; 
    CountryID : string; 
    Content : any; 
    Description : string; 
    DisplayValue : string; 
  }
  
  export class ListApplicationContentCulture {
    ApplicationID : number; // Int32
    LanguageID : string; 
    CountryID : string; 
    Culture : string; 
  }
  
  export class ListApplicationCultures extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.ListApplicationCulturesResponse> {
  }
  
  export class ListApplicationCulturesResponse extends EVA.API.ResponseMessage {
    Result : EVA.PIM.Core.ListApplicationContentCulture[]; 
  }
  
  export class ListContentCultureMapping extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.ListContentCultureMappingResponse> {
    PageConfig : EVA.Framework.PageConfigGeneric<EVA.PIM.Core.ContentCultureMappingFilter>; 
  }
  
  export class ListContentCultureMappingResponse extends EVA.API.PagedResultResponse<EVA.PIM.Core.ListContentCultureMappingResponseContentCultureMappingDto> {
  }
  
  export class ListLayers extends EVA.API.PagedResultRequest<EVA.PIM.Core.ListLayersResponse> {
  }
  
  export class ListLayersResponse extends EVA.API.PagedResultResponse<EVA.PIM.Core.LayerDto> {
  }
  
  export class ListProductPropertyCategories extends EVA.API.PagedResultRequest<EVA.PIM.Core.ListProductPropertyCategoriesResponse> {
  }
  
  export class ListProductPropertyCategoriesDto {
    ID : string; 
    DisplayName : string; 
  }
  
  export class ListProductPropertyCategoriesResponse extends EVA.API.PagedResultResponse<EVA.PIM.Core.ListProductPropertyCategoriesDto> {
  }
  
  export class ListProductPropertyTypeEnumValues extends EVA.API.PagedResultRequest<EVA.PIM.Core.ListProductPropertyTypeEnumValuesResponse> {
  }
  
  export class ListProductPropertyTypeEnumValuesResponse extends EVA.API.PagedResultResponse<EVA.PIM.Core.ListProductPropertyTypeEnumValuesResponseProductPropertyTypeEnumValueDto> {
  }
  
  export class ListProductPropertyTypes extends EVA.API.PagedResultRequest<EVA.PIM.Core.ListProductPropertyTypesResponse> {
  }
  
  export class ListProductPropertyTypesDto {
    ID : string; 
    DisplayName : string; 
    CategoryID : string; 
    CategoryDisplayName : string; 
    DataType : EVA.PIM.Common.ProductPropertyTypeDataTypes; 
  }
  
  export class ListProductPropertyTypesResponse extends EVA.API.PagedResultResponse<EVA.PIM.Core.ListProductPropertyTypesDto> {
  }
  
  export class ListProductSearchStrategies extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.ListProductSearchStrategiesResponse> {
    PageConfig : EVA.Framework.PageConfigGeneric<EVA.PIM.Core.ListProductSearchStrategiesFilter>; 
  }
  
  export class ListProductSearchStrategiesFilter {
    LanguageID : string; 
    CountryID : string; 
  }
  
  export class ListProductSearchStrategiesResponse extends EVA.API.PagedResultResponse<EVA.PIM.Core.ListProductSearchStrategyItem> {
  }
  
  export class ListProductSearchStrategyItem {
    ID : number; // Int32
    CatalogID : number; // Int32
    LanguageID : string; 
    CountryID : string; 
    Name : string; 
    Code : string; 
    TypeID : number; // Int32
    Type : EVA.PIM.Core.ProductSearchStrategyTypes; 
    OrganizationUnitTypeID? : number; // Int32, nullable
    OrganizationUnitType : EVA.Framework.OrganizationUnitTypes; 
    Strategy : EVA.PIM.Core.ProductSearchStrategyModel; 
    SerializedStrategy : string; 
  }
  
  export class ListRevisions extends EVA.API.PagedResultRequest<EVA.PIM.Core.ListRevisionsResponse> {
  }
  
  export class ListRevisionsResponse extends EVA.API.PagedResultResponse<EVA.PIM.Core.RevisionDto> {
  }
  
  export class ListRevisionUser {
    FullName : string; 
  }
  
  export class ListRevisionValidationErrors extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.ListRevisionValidationErrorsResponse> {
    RevisionID : number; // Int32
    Offset? : number; // Int32, nullable
    Cursor? : number; // Int32, nullable
  }
  
  export class ListRevisionValidationErrorsResponse extends EVA.API.ResponseMessage {
    Offset? : number; // Int32, nullable
    Cursor? : number; // Int32, nullable
    Errors : any[]; 
  }
  
  export enum MatchOperator {
    And = 0,
    Or = 1,
  }
  
  export class ProductSearchStrategyModelMultiMatchFuzziness {
    EditDistance? : number; // Int32, nullable
    PrefixLength? : number; // Int32, nullable
    MaxExpansions? : number; // Int32, nullable
  }
  
  export class ProductSearchStrategyModelMultiMatchQuery {
    Type : EVA.PIM.Core.MultiMatchType; 
    Slop? : number; // Int32, nullable
    Fuzziness : EVA.PIM.Core.ProductSearchStrategyModelMultiMatchFuzziness; 
    Operator : EVA.PIM.Core.MatchOperator; 
    Boost? : number; // Int32, nullable
    RequirementType : EVA.PIM.Core.QueryRequirementType; 
    PropertiesToSearch : EVA.PIM.Core.ProductSearchStrategyModelProductPropertyTypeToSearch[]; 
    Analyzer : string; 
    MinimumShouldMatch : string; 
  }
  
  export enum MultiMatchType {
    BestFields = 0,
    MostFields = 1,
    CrossFields = 2,
    Phrase = 3,
    PhrasePrefix = 4,
  }
  
  export class PreviewProductPropertyCategory extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.PreviewProductPropertyCategoryResponse> {
    ID : string; 
    RevisionID : number; // Int32
    Edits : EVA.PIM.Core.ProductPropertyCategoryEdit[]; 
  }
  
  export class PreviewProductPropertyCategoryResponse extends EVA.API.ResponseMessage {
    Result : any; 
  }
  
  export class PreviewProductPropertyType extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.PreviewProductPropertyTypeResponse> {
    ID : string; 
    RevisionID : number; // Int32
    Edits : EVA.PIM.Core.ProductPropertyTypeEdit[]; 
  }
  
  export class PreviewProductPropertyTypeResponse extends EVA.API.ResponseMessage {
    Result : any; 
  }
  
  export class ImportProductsProduct {
    // The unique identifier for the product.
    ID : string; 
    // The culture independent name of the product by which it can be recognized even if it otherwise does not have any content. Required unless Type = ContentOnly.
    Name : string; 
    // The (optional) brand of the product. Only has to be specified on the root level of a hierarchy.
    Brand : string; 
    // The (optional) ledger class ID of the product. Only has to be specified on the root level of a hierarchy.
    LedgerClassID : string; 
    // <br />The TaxCode determines how sales tax applies to this product. This must refer to an existing TaxCode in EVA, if it doesn't exist yet an error is returned.<br /><br />Required unless Type = ContentOnly.<br /><br />The string expected here is the Name property of the tax code, so 'High' for TaxCode High.<br /><br />EVA defines the following default tax codes:<br /><br />- High<br />- Intermediate<br />- Low<br />- Zero<br />- Exempt<br /><br />In a hierarchy, the TaxCode only has to be specified for the root level; all products part of the hierarchy will always have the same TaxCode.<br />
    TaxCode : string; 
    // An (optional) list of barcodes for this product. A barcode should be globally unique and any duplicate barcodes will result in an error.
    Barcodes : string[]; 
    // Defines what kind of product it is. If the product is part of a hierarchy, this is only relevant for the SKU level, all other levels will have type Configurable.
    Type : EVA.PIM.Core.ImportProductsProductType; 
    // Defines the status of a product.
    Status : EVA.PIM.Core.ImportProductsProductStatus; 
    // Defines the variations hierarchy of the product.
    Variations : EVA.PIM.Core.ImportProductsProductVariation; 
    // The per-language content of the product.<br /><br />A small set of default properties has been defined, such as Name and MarketingDescription. Additional content can be defined inside `CustomContent`, which is a key-value container<br />where the key is the name of a property and value should be a single scalar value (string, number, boolean or null) or an array of values.<br /><br />If LanguageID is left null, this will be the fallback content for languages that have no content of their own.<br />For example, you may offer a French website but you only have English product content, if you specify your English content with LanguageID = null<br />then products on the French website will have the English content.<br />
    Content : EVA.PIM.Core.ImportProductsProductContent[]; 
    // <br />Defines the per-language value of the variation property for this product. For example, if the variation property is `color` then the value could be 'red' or 'blue'.<br /><br />If the variation value isn't language sensitive then the LanguageID should be left null. If there isn't an item where LanguageID is null, all languages for which this product has content must have<br />a value for the variation property.<br />
    VariationValues : EVA.PIM.Core.ImportProductsProductVariationValue[]; 
  }
  
  export enum ProductCompositionProgressState {
    None = 0,
    Composing = 1,
    PostProcessing = 2,
    Publishing = 3,
    Complete = 4,
  }
  
  export class ImportProductsProductContent {
    LanguageID : string; 
    CountryID : string; 
    MarketingDescription : string; 
    Name : string; 
    ShortDescription : string; 
    LongDescription : string; 
    // The publication status determines the visibility of the product. A product generally won't be visible to non-employee users unless it has publication status 'public'.
    PublicationStatuses : string[]; 
    Images : EVA.PIM.Core.ImportProductsProductImage[]; 
    Tags : string[]; 
    CustomContent : any; 
  }
  
  export class ProductEdit {
    LayerID? : number; // Int32, nullable
    Content : any; 
    LanguageID : string; 
    CountryID : string; 
  }
  
  export class ImportProductsProductImage {
    // The unique identifier for the image. Optional, if null then an ID is generated based on the hash of the ImageUrl
    ID : string; 
    // Where can the image be downloaded? Required unless ImageData is provided.
    ImageUrl : string; 
    // The image mime type. Optional, if null then the mime type will be guessed by the ImageUrl
    MimeType : string; 
    // The human readable name of the image. Optional, if null then the name will be the ID of the image.
    Name : string; 
    // The raw image data. Only required if ImageUrl is left empty.
    ImageData : string; 
  }
  
  export enum ProductImportValidationFailureReason {
    InfiniteRecursionInReferences = 0,
    InfiniteRecursionInBackendIDs = 1,
    InfiniteRecursionInIDs = 2,
    DuplicateBackendID = 3,
    DuplicateProductID = 4,
    MissingField = 5,
    MissingLogicalLevel = 6,
    InconsistentData = 7,
    MissingImageUrl = 8,
    MissingImageMimeType = 9,
    InvalidProductType = 10,
    MissingConfigurableProperty = 11,
    MissingConfigurablePropertyValue = 12,
    ImageBlobCategoryRequired = 13,
    UnknownProduct = 14,
  }
  
  export class ProductMapItem {
    BackendID : string; 
    ID : number; // Int32
  }
  
  export class ProductPropertyCategoryEdit {
    LayerID : number; // Int32
    Content : any; 
  }
  
  export enum ProductPropertyDataTypes {
    String = 0,
    Int = 1,
    Double = 2,
    Bool = 3,
  }
  
  export enum ProductPropertyIndexTypes {
    NotIndexed = 0,
    IndexedNotAnalyzed = 1,
    IndexedAnalyzed = 2,
  }
  
  export class ProductSearchConfigurationModelProductPropertyTypeConfiguration implements EVA.PIM.Core.ProductSearchConfigurationModelIHasCulture {
    Name : string; 
    LanguageID : string; 
    Analyzer : string; 
    SearchAnalyzer : string; 
    CopyTo : string; 
  }
  
  export class ProductPropertyTypeEdit {
    LayerID : number; // Int32
    Content : any; 
  }
  
  export class ListProductPropertyTypeEnumValuesResponseProductPropertyTypeEnumValueDto {
    ID : number; // Int32
    ProductPropertyTypeID : string; 
    Identifier : number; // Int32
    Value : string; 
    LanguageID : string; 
    CountryID : string; 
  }
  
  export enum ProductPropertyTypeOptions {
    None = 0,
    AlphabeticallySortable = 1,
  }
  
  export class ProductSearchStrategyModelProductPropertyTypeToSearch {
    ID : string; 
    Boost? : number; // Double, nullable
  }
  
  export class ProductSearchConfigurationModel {
    Analyzers : EVA.PIM.Core.ProductSearchConfigurationModelAnalyzer[]; 
    TokenFilters : EVA.PIM.Core.ProductSearchConfigurationModelTokenFilter[]; 
    CharFilters : EVA.PIM.Core.ProductSearchConfigurationModelCharFilter[]; 
    ProductPropertyTypes : EVA.PIM.Core.ProductSearchConfigurationModelProductPropertyTypeConfiguration[]; 
    DisableSynonyms : boolean; 
    IndexPipelineScript : string; 
  }
  
  export enum ProductSearchItemFlags {
    DisplayValue = 1,
    CustomID = 2,
    BackendID = 4,
    BrandName = 8,
    LogicalLevel = 16,
    ConfigurableProperties = 32,
    Name = 64,
    Type = 128,
    Status = 256,
    Unstackable = 512,
    MaxQuantityPerOrder = 1024,
    Barcodes = 2048,
    PublicationStatuses = 4096,
    ProductMedia = 8192,
    PrimaryImage = 16384,
    ParentProductIDs = 32768,
    ParentHierarchy = 65536,
    LogicalLevelHierarchy = 131072,
    ProductRequirements = 262144,
    DisplayPrice = 524288,
    OriginalPrice = 1048576,
    CurrencyID = 2097152,
    TaxExemptionCode = 4194304,
    TaxExemptionReason = 8388608,
    ShortDescription = 16777216,
    LongDescription = 33554432,
    PriceLabel = 67108864,
    ExcludeFromGiftWrapping = 134217728,
  }
  
  export enum ProductSearchItemMediaFlags {
    Gallery = 1,
    ImageCount = 2,
    Media = 4,
    PrimaryImage = 8,
  }
  
  export class ProductSearchStrategyModel {
    Condition : EVA.PIM.Core.ProductSearchStrategyModelStrategyCondition; 
    Scoring : EVA.PIM.Core.ProductSearchStrategyModelScoringStrategy; 
    Sorting : EVA.PIM.Core.ProductSearchStrategyModelSortingStrategy; 
    Query : EVA.PIM.Core.ProductSearchStrategyModelQueryStrategy; 
    Aggregation : EVA.PIM.Core.ProductSearchStrategyModelAggregationStrategy; 
  }
  
  export enum ProductSearchStrategyTypes {
    Full = 0,
    Partial = 1,
  }
  
  export class GetProductSearchSynonymsResponseProductSearchSynonym {
    ID : number; // Int32
    Rule : string; 
    LanguageID : string; 
  }
  
  export class ImportProductsProductStatus {
    // The product will be unavailable until the pre-order date.
    PreRelease : boolean; 
    // The product won't be available for endless aisle pickup from shop.
    DeliveryOnly : boolean; 
    // The product will be unavailable for delivery.
    DisableDelivery : boolean; 
    // The product won't be available from a shop at all.
    DisablePickup : boolean; 
    // The product won't be orderable if there is no available stock.
    DisableBackorder : boolean; 
    // Indicates the product won't be back in store and all current stock is all there is going to be.
    UseUp : boolean; 
  }
  
  export class ImportProductsProductType {
    // A normal stock-keeping product. This will be the default if not specified.
    Stock : boolean; 
    // A giftcard product.
    GiftCard : boolean; 
    // A non-physical product that represents a service of some sort.
    Service : boolean; 
    // Indicates the product is of a bundle type.
    BundleProduct : boolean; 
  }
  
  export class ImportProductsProductVariation {
    // The property on which the product hierarchy varies. For example 'size' or 'color'.
    Property : string; 
    // <br />The LogicalLevel of a product defines the 'level' on which the product can be thought to sit in the hierarchy.<br /><br />For example, the various different colors of a shirt can be thought to have LogicalLevel = 'color' and the actual SKU might have LogicalLevel = 'size' or 'sku'.<br /><br />You are free to use any value, but it's recommended to keep this consistent between all products, or at least between products of the same kind, as it's a useful way to<br />structure a frontend by for example filtering on the color level and only show sizes when navigating to the product detail.<br />
    LogicalLevel : string; 
    // The actual variations of the product on the specified LogicalLevel.
    Products : EVA.PIM.Core.ImportProductsProduct[]; 
  }
  
  export class ProductSearchStrategyModelAggregationStrategyProductVariationAggregation {
    LogicalLevel : string; 
    VariationField : string; 
  }
  
  export class ImportProductsProductVariationValue {
    // Can be left null if the variation value isn't culture dependent.
    LanguageID : string; 
    // Can be left null if the variation value isn't culture dependent.
    CountryID : string; 
    Value : string; 
  }
  
  export enum PropertyValueType {
    None = 0,
    Int = 1,
    String = 2,
    Bool = 3,
    DateTime = 4,
    Float = 5,
  }
  
  export enum PropertyValueTypes {
    Unknown = 0,
    Integer = 1,
    String = 2,
    Boolean = 3,
    Double = 4,
    Date = 5,
  }
  
  export class ProductSearchStrategyModelQueryCondition {
    Text : string; 
    Type : EVA.PIM.Core.QueryConditionTypes; 
  }
  
  export enum QueryConditionTypes {
    Equals = 0,
    Contains = 1,
    StartsWith = 2,
  }
  
  export enum QueryRequirementType {
    Must = 0,
    Should = 1,
  }
  
  export class ProductSearchStrategyModelQueryStrategy {
    Queries : EVA.PIM.Core.ProductSearchStrategyModelMultiMatchQuery[]; 
    MinimumShouldMatch : string; 
    StockFilter : EVA.PIM.Core.ProductSearchStrategyModelStockFilterStrategy; 
  }
  
  export class ReplaceProductSearchSynonyms extends EVA.API.RequestMessageWithEmptyResponse {
    Rules : string[]; 
    LanguageID : string; 
  }
  
  export class RequestReindexSearchData extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.RequestReindexSearchDataResponse> {
    Script : string; 
    LanguageID : string; 
    CountryID : string; 
    ApplyProductSearchConfiguration : boolean; 
  }
  
  export class RequestReindexSearchDataResponse extends EVA.API.ResponseMessage {
  }
  
  export class RevisionDto {
    ID : number; // Int32
    Name : string; 
    ApplicationID? : number; // Int32, nullable
    Status : EVA.PIM.Core.RevisionStatus; 
    AppliedOn? : string; // DateTime, nullable
    CreatedBy : EVA.PIM.Core.ListRevisionUser; 
    CreationTime : string; // DateTime
  }
  
  export class RevisionProgress {
    TotalItems : number; // Int32
    HandledItems : number; // Int32
    State : EVA.PIM.Core.ProductCompositionProgressState; 
    Progress : number; // Double
    ValidationErrors : number; // Int64
  }
  
  export enum RevisionStatus {
    Open = 1,
    Applied = 2,
    Inactive = 4,
    InProgress = 8,
  }
  
  export enum RevisionTypes {
    UserRevision = 0,
    SystemRevision = 1,
  }
  
  export enum ScoreModes {
    Multiply = 0,
    Sum = 1,
    Average = 2,
    First = 3,
    Max = 4,
    Min = 5,
  }
  
  export class ProductSearchStrategyModelScoringFunction {
    Type : EVA.PIM.Core.ScoringFunctionTypes; 
    Options : any; 
    Weight? : number; // Int32, nullable
  }
  
  export enum ScoringFunctionTypes {
    FieldValueFactor = 0,
    Script = 1,
  }
  
  export class ProductSearchStrategyModelScoringStrategy {
    ScoreMode : EVA.PIM.Core.ScoreModes; 
    BoostMode : EVA.PIM.Core.BoostMode; 
    ScoringFunctions : EVA.PIM.Core.ProductSearchStrategyModelScoringFunction[]; 
    MaxBoost? : number; // Int32, nullable
    MinScore? : number; // Int32, nullable
    StockScoring : EVA.PIM.Core.ProductSearchStrategyModelStockScoringStrategy; 
  }
  
  export class SearchProductPropertyTypes extends EVA.API.PagedResultRequest<EVA.PIM.Core.SearchProductPropertyTypesResponse> {
    Query : string; 
  }
  
  export class SearchProductPropertyTypesResponse extends EVA.API.PagedResultResponse<any> {
  }
  
  export enum SortingScriptType {
    Number = 0,
    String = 1,
  }
  
  export class ProductSearchStrategyModelSortingStrategy {
    Sort : EVA.PIM.Core.ProductSearchStrategyModelSortingStrategySort[]; 
    StockSorting : EVA.PIM.Core.ProductSearchStrategyModelStockSortingStrategy; 
  }
  
  export enum SortingStrategyOrder {
    Ascending = 0,
    Descending = 1,
  }
  
  export class ProductSearchStrategyModelSortingStrategySort {
    Order : EVA.PIM.Core.SortingStrategyOrder; 
    Script : EVA.PIM.Core.ProductSearchStrategyModelSortingStrategySortScript; 
    Field : string; 
    MissingValue : any; 
  }
  
  export class ProductSearchStrategyModelSortingStrategySortScript {
    Type : EVA.PIM.Core.SortingScriptType; 
    Source : string; 
    Language : string; 
  }
  
  export class ProductSearchStrategyModelStockFilterStrategy {
    FilterByStock : boolean; 
    Type : EVA.PIM.Core.StockFilterTypes; 
  }
  
  export enum StockFilterTypes {
    CurrentOrganizationUnit = 0,
    Suppliers = 1,
  }
  
  export class ProductSearchStrategyModelStockScoringStrategy {
    AdjustScoreByStock : boolean; 
    BoostAmount : number; // Int32
    Type : EVA.PIM.Core.StockFilterTypes; 
  }
  
  export class ProductSearchStrategyModelStockSortingStrategy {
    SortByStock : boolean; 
    Type : EVA.PIM.Core.StockFilterTypes; 
  }
  
  export class ProductSearchStrategyModelStrategyCondition {
    Query : EVA.PIM.Core.ProductSearchStrategyModelQueryCondition; 
    Filters : EVA.PIM.Core.ProductSearchStrategyModelFilterCondition[]; 
  }
  
  export class ProductSearchConfigurationModelTokenFilter implements EVA.PIM.Core.ProductSearchConfigurationModelIHasCulture {
    Name : string; 
    LanguageID : string; 
    Type : string; 
    Options : any; 
  }
  
  export class UpdateBrand extends EVA.API.UpdateRequest<EVA.PIM.Core.BrandDto> implements EVA.API.IRequestRespondsAs<EVA.API.EmptyResponseMessage> {
  }
  
  export class UpdateLayer extends EVA.API.RequestMessageWithEmptyResponse {
    ID : number; // Int32
    Name : string; 
    Description : string; 
    Level : number; // Int32
  }
  
  export class UpdateProduct extends EVA.API.RequestMessageWithEmptyResponse {
    ID : number; // Int32
    BackendID : string; 
    CustomID : string; 
    PrimitiveName : string; 
    TypeID : number; // Int32
    TaxCodeID : number; // Int32
    LedgerClassID : string; 
  }
  
  export class UpdateProductPropertyTypeEnumValue extends EVA.API.RequestMessageWithEmptyResponse {
    ID : number; // Int32
    Identifier : number; // Int32
    Value : string; 
    LanguageID : string; 
    CountryID : string; 
  }
  
  export class UpdateProductSearchStrategy extends EVA.API.RequestMessageWithEmptyResponse {
    ID : number; // Int32
    CountryID : string; 
    LanguageID : string; 
    Name : string; 
    Code : string; 
    Strategy : EVA.PIM.Core.ProductSearchStrategyModel; 
  }
  
  export class UploadProductBarcodeExcel extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.UploadProductBarcodeExcelResponse> {
    Data : string; 
  }
  
  export class UploadProductBarcodeExcelResponse extends EVA.API.ResponseMessage {
  }
  
  export class UploadProductContentExcel extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.UploadProductContentExcelResponse> {
    LanguageID : string; 
    Data : string; 
  }
  
  export class UploadProductContentExcelResponse extends EVA.API.ResponseMessage {
  }
  
  export class UploadProductExcel extends EVA.API.RequestMessageGeneric<EVA.PIM.Core.UploadProductExcelResponse> {
    Data : string; 
  }
  
  export class UploadProductExcelResponse extends EVA.API.ResponseMessage {
  }
  
}