@relewise/client/dist/index.d.ts

Relewise is a next generation personalization SaaS-platform, which offers functionality within product- and content recommendations and personalized search. This official SDK helps you interact with our API.

export declare type AbandonedCartTriggerConfiguration = AbandonedCartTriggerResultTriggerConfiguration & {
    cartName?: string | null;
};

export declare interface AbandonedCartTriggerResultTriggerConfiguration {
    $type: string;
    custom?: Record<string, string | null>;
    /** @format uuid */
    id: string;
    name?: string | null;
    description?: string | null;
    group?: string | null;
    enabled: boolean;
    /** @format date-time */
    created: string;
    createdBy?: string | null;
    /** @format date-time */
    modified: string;
    modifiedBy?: string | null;
    /** @format int32 */
    withinTimeSpanMinutes: number;
    settings?: Record<string, string | null>;
    userConditions?: UserConditionCollection | null;
}

export declare type AbandonedSearchTriggerConfiguration = AbandonedSearchTriggerResultTriggerConfiguration & {
    searchTypesInPrioritizedOrder: ("Product" | "ProductCategory" | "Content")[];
    searchTermCondition?: SearchTermCondition | RetailMediaSearchTermCondition | null;
    suppressOnEntityFromSearchResultViewed: boolean;
    /** @format int32 */
    considerAbandonedAfterMinutes: number;
};

export declare interface AbandonedSearchTriggerResultTriggerConfiguration {
    $type: string;
    custom?: Record<string, string | null>;
    /** @format uuid */
    id: string;
    name?: string | null;
    description?: string | null;
    group?: string | null;
    enabled: boolean;
    /** @format date-time */
    created: string;
    createdBy?: string | null;
    /** @format date-time */
    modified: string;
    modifiedBy?: string | null;
    /** @format int32 */
    withinTimeSpanMinutes: number;
    settings?: Record<string, string | null>;
    userConditions?: UserConditionCollection | null;
}

export declare type Advertiser = AdvertiserEntityStateAdvertiserMetadataValuesRetailMediaEntity & {
    name: string;
    allowedPromotions?: PromotionSpecificationCollection | null;
    allowedLocations?: PromotionLocationCollection | null;
};

export declare interface AdvertiserAdvertiserEntityStateEntityResponse {
    $type: string;
    entities?: Advertiser[] | null;
    /** @format int32 */
    hits: number;
    hitsPerState?: {
        /** @format int32 */
        Active: number;
        /** @format int32 */
        Inactive: number;
        /** @format int32 */
        Archived: number;
    } | null;
    statistics?: Statistics | null;
}

export declare interface AdvertiserEntityStateAdvertiserMetadataValuesAdvertisersRequestSortByAdvertisersRequestEntityFiltersEntitiesRequest {
    $type: string;
    filters?: AdvertisersRequestEntityFilters | null;
    sorting?: AdvertisersRequestSortBySorting | null;
    /** @format int32 */
    skip: number;
    /** @format int32 */
    take: number;
    custom?: Record<string, string | null>;
}

export declare interface AdvertiserEntityStateAdvertiserMetadataValuesRetailMediaEntity {
    $type: string;
    state: "Active" | "Inactive" | "Archived";
    metadata: AdvertiserMetadataValues;
    /** @format uuid */
    id?: string | null;
}

export declare type AdvertiserMetadataValues = MetadataValues & {
    /** @format date-time */
    inactivated?: string | null;
    inactivatedBy?: string | null;
    /** @format date-time */
    activated?: string | null;
    activatedBy?: string | null;
    /** @format date-time */
    archived?: string | null;
    archivedBy?: string | null;
};

export declare interface AdvertiserSaveEntitiesRequest {
    $type: string;
    entities: Advertiser[];
    modifiedBy: string;
    custom?: Record<string, string | null>;
}

export declare interface AdvertiserSaveEntitiesResponse {
    $type: string;
    entities?: Advertiser[] | null;
    statistics?: Statistics | null;
}

export declare type AdvertisersRequest = AdvertiserEntityStateAdvertiserMetadataValuesAdvertisersRequestSortByAdvertisersRequestEntityFiltersEntitiesRequest;

export declare type AdvertisersRequestEntityFilters = RetailMediaEntity2AdvertiserEntityStateAdvertiserMetadataValuesRetailMediaEntity2EntityFilters & {
    ids?: string[] | null;
};

export declare interface AdvertisersRequestSortBySorting {
    sortBy: "Created" | "Modified" | "Name";
    sortOrder: "Ascending" | "Descending";
}

export declare type AdvertisersResponse = AdvertiserAdvertiserEntityStateEntityResponse;

export declare type AllFilters = NonNullable<FilterCollection['items']> extends (infer U)[] ? U : never;

export declare interface AnalyzerRequest {
    $type: string;
    language?: Language | null;
    currency?: Currency | null;
    custom?: Record<string, string | null>;
}

export declare type AndCondition = UserCondition & {
    conditions?: UserConditionCollection | null;
};

export declare type AndFilter = Filter & {
    filters: (AndFilter | BrandAssortmentFilter | BrandDataFilter | BrandDataHasKeyFilter | BrandDisabledFilter | BrandIdFilter | CartDataFilter | CompanyDataFilter | CompanyDataHasKeyFilter | CompanyDisabledFilter | CompanyIdFilter | ContentAssortmentFilter | ContentCategoryAssortmentFilter | ContentCategoryDataFilter | ContentCategoryDataHasKeyFilter | ContentCategoryDisabledFilter | ContentCategoryHasAncestorFilter | ContentCategoryHasChildFilter | ContentCategoryHasContentsFilter | ContentCategoryHasParentFilter | ContentCategoryIdFilter | ContentCategoryLevelFilter | ContentCategoryRecentlyViewedByUserFilter | ContentDataFilter | ContentDataHasKeyFilter | ContentDisabledFilter | ContentHasCategoriesFilter | ContentIdFilter | ContentRecentlyViewedByUserFilter | OrFilter | ProductAndVariantIdFilter | ProductAssortmentFilter | ProductCategoryAssortmentFilter | ProductCategoryDataFilter | ProductCategoryDataHasKeyFilter | ProductCategoryDisabledFilter | ProductCategoryHasAncestorFilter | ProductCategoryHasChildFilter | ProductCategoryHasParentFilter | ProductCategoryHasProductsFilter | ProductCategoryIdFilter | ProductCategoryLevelFilter | ProductCategoryRecentlyViewedByUserFilter | ProductDataFilter | ProductDataHasKeyFilter | ProductDisabledFilter | ProductDisplayNameFilter | ProductHasCategoriesFilter | ProductHasVariantsFilter | ProductIdFilter | ProductInCartFilter | ProductListPriceFilter | ProductRecentlyPurchasedByCompanyFilter | ProductRecentlyPurchasedByUserCompanyFilter | ProductRecentlyPurchasedByUserFilter | ProductRecentlyPurchasedByUserParentCompanyFilter | ProductRecentlyViewedByCompanyFilter | ProductRecentlyViewedByUserCompanyFilter | ProductRecentlyViewedByUserFilter | ProductRecentlyViewedByUserParentCompanyFilter | ProductSalesPriceFilter | VariantAssortmentFilter | VariantDataFilter | VariantDataHasKeyFilter | VariantDisabledFilter | VariantIdFilter | VariantListPriceFilter | VariantSalesPriceFilter | VariantSpecificationFilter)[];
};

export declare interface ApplicableIndexes {
    indexes?: string[] | null;
}

export declare interface ApplicableLanguages {
    languages?: Language[] | null;
}

export declare type ApplyFilterSettings = FilterScopeSettings & {
    apply: boolean;
};

export declare interface AssortmentFacet {
    $type: string;
    assortmentFilterType: "Or";
    selected?: number[] | null;
    field: "Category" | "Assortment" | "ListPrice" | "SalesPrice" | "Brand" | "Data" | "VariantSpecification" | "User";
    settings?: FacetSettings | null;
}

export declare interface AssortmentFacetResult {
    $type: string;
    assortmentFilterType: "Or";
    selected?: number[] | null;
    available?: Int32AvailableFacetValue[] | null;
    field: "Category" | "Assortment" | "ListPrice" | "SalesPrice" | "Brand" | "Data" | "VariantSpecification" | "User";
}

export declare type BatchedTrackingRequest = TrackingRequest & {
    items?: (BrandAdministrativeAction | BrandUpdate | BrandView | Cart | CompanyAdministrativeAction | CompanyUpdate | ContentAdministrativeAction | ContentCategoryAdministrativeAction | ContentCategoryUpdate | ContentCategoryView | ContentUpdate | ContentView | Order | ProductAdministrativeAction | ProductCategoryAdministrativeAction | ProductCategoryUpdate | ProductCategoryView | ProductUpdate | ProductView | SearchTerm | UserUpdate)[] | null;
};

export declare interface BooleanAvailableFacetValue {
    value: boolean;
    /** @format int32 */
    hits: number;
    selected: boolean;
}

export declare interface BooleanBooleanValueFacetResult {
    $type: string;
    selected?: boolean[] | null;
    available?: BooleanAvailableFacetValue[] | null;
    field: "Category" | "Assortment" | "ListPrice" | "SalesPrice" | "Brand" | "Data" | "VariantSpecification" | "User";
}

export declare class BooleanCollectionDataValue extends DataValueBase<CollectionWithType<boolean>> {
    constructor(value: boolean[]);
    readonly isCollection = true;
}

export declare interface BooleanContentDataValueFacet {
    $type: string;
    key: string;
    collectionFilterType?: "Or" | "And" | null;
    selected?: boolean[] | null;
    field: "Category" | "Assortment" | "ListPrice" | "SalesPrice" | "Brand" | "Data" | "VariantSpecification" | "User";
    settings?: FacetSettings | null;
}

export declare interface BooleanContentDataValueFacetResult {
    $type: string;
    key?: string | null;
    collectionFilterType?: "Or" | "And" | null;
    selected?: boolean[] | null;
    available?: BooleanAvailableFacetValue[] | null;
    field: "Category" | "Assortment" | "ListPrice" | "SalesPrice" | "Brand" | "Data" | "VariantSpecification" | "User";
}

export declare interface BooleanDataObjectValueFacet {
    $type: string;
    key: string;
    collectionFilterType?: "Or" | "And" | null;
    selected?: boolean[] | null;
    field: "Category" | "Assortment" | "ListPrice" | "SalesPrice" | "Brand" | "Data" | "VariantSpecification" | "User";
    settings?: FacetSettings | null;
}

export declare interface BooleanDataObjectValueFacetResult {
    $type: string;
    key?: string | null;
    collectionFilterType?: "Or" | "And" | null;
    selected?: boolean[] | null;
    available?: BooleanAvailableFacetValue[] | null;
    field: "Category" | "Assortment" | "ListPrice" | "SalesPrice" | "Brand" | "Data" | "VariantSpecification" | "User";
}

export declare class BooleanDataValue extends DataValueBase<boolean> {
    constructor(value: boolean);
    readonly isCollection = false;
}

export declare interface BooleanProductCategoryDataValueFacet {
    $type: string;
    key: string;
    collectionFilterType?: "Or" | "And" | null;
    selected?: boolean[] | null;
    field: "Category" | "Assortment" | "ListPrice" | "SalesPrice" | "Brand" | "Data" | "VariantSpecification" | "User";
    settings?: FacetSettings | null;
}

export declare interface BooleanProductCategoryDataValueFacetResult {
    $type: string;
    key?: string | null;
    collectionFilterType?: "Or" | "And" | null;
    selected?: boolean[] | null;
    available?: BooleanAvailableFacetValue[] | null;
    field: "Category" | "Assortment" | "ListPrice" | "SalesPrice" | "Brand" | "Data" | "VariantSpecification" | "User";
}

export declare interface BooleanProductDataValueFacet {
    $type: string;
    dataSelectionStrategy: "Product" | "Variant" | "VariantWithFallbackToProduct" | "ProductWithFallbackToVariant";
    key: string;
    collectionFilterType?: "Or" | "And" | null;
    selected?: boolean[] | null;
    field: "Category" | "Assortment" | "ListPrice" | "SalesPrice" | "Brand" | "Data" | "VariantSpecification" | "User";
    settings?: FacetSettings | null;
}

export declare interface BooleanProductDataValueFacetResult {
    $type: string;
    dataSelectionStrategy: "Product" | "Variant" | "VariantWithFallbackToProduct" | "ProductWithFallbackToVariant";
    key?: string | null;
    collectionFilterType?: "Or" | "And" | null;
    selected?: boolean[] | null;
    available?: BooleanAvailableFacetValue[] | null;
    field: "Category" | "Assortment" | "ListPrice" | "SalesPrice" | "Brand" | "Data" | "VariantSpecification" | "User";
}

export declare interface BooleanValueFacet {
    $type: string;
    selected?: boolean[] | null;
    field: "Category" | "Assortment" | "ListPrice" | "SalesPrice" | "Brand" | "Data" | "VariantSpecification" | "User";
    settings?: FacetSettings | null;
}

export declare type BoostAndBuryRule = MerchandisingRule & {
    multiplierSelector?: DataDoubleSelector | FixedDoubleValueSelector | null;
};

export declare interface Brand {
    id: string;
    displayName?: string | null;
    assortments?: number[] | null;
    data?: Record<string, DataValue>;
}

export declare type BrandAdministrativeAction = Trackable & {
    filters: FilterCollection;
    language?: Language | null;
    kind: "Disable" | "Enable" | "Delete";
    currency?: Currency | null;
};

export declare type BrandAssortmentFilter = Filter & {
    assortments: number[];
};

export declare type BrandDataFilter = DataFilter;

export declare type BrandDataHasKeyFilter = Filter & {
    key: string;
};

export declare type BrandDetailsCollectionResponse = TimedResponse & {
    brands?: BrandResultDetails[] | null;
    /** @format int32 */
    totalNumberOfResults?: number | null;
};

export declare type BrandDisabledFilter = Filter;

export declare type BrandFacet = StringValueFacet;

export declare type BrandFacetResult = StringBrandNameAndIdResultValueFacetResult;

export declare class BrandFilterBuilder extends FilterBuilderBase<BrandFilterBuilder> {
    constructor();
    /**
     * Adds a brand assortment filter to the request.
     * @param assortmentIds - Array of assortment IDs or a single ID.
     * @param negated - If true, negates the filter (default is false).
     * @param options - Optional settings for the filter.
     * @returns The BrandFilterBuilder instance for chaining.
     */
    addBrandAssortmentFilter(assortmentIds: number[] | number, negated?: boolean, options?: FilterOptions): this;
    /**
     * Filters the request to only return the specified brands.
     * @param brandIds - Array of brand IDs or a single ID.
     * @param negated - If true, negates the filter (default is false).
     * @param options - Optional settings for the filter.
     * @returns The BrandFilterBuilder instance for chaining.
     */
    addBrandIdFilter(brandIds: string | string[], negated?: boolean, options?: FilterOptions): this;
    /**
     * Adds a brand data filter to the request.
     * @param key - Data key.
     * @param conditionBuilder - Function to build the condition.
     * @param mustMatchAllConditions - If true, all conditions must be met (default is true).
     * @param filterOutIfKeyIsNotFound - If true, filters out brands without the key (default is true).
     * @param negated - If true, negates the filter (default is false).
     * @param options - Optional settings for the filter.
     * @returns The BrandFilterBuilder instance for chaining.
     */
    addBrandDataFilter(key: string, conditionBuilder: (builder: ConditionBuilder) => void, mustMatchAllConditions?: boolean, filterOutIfKeyIsNotFound?: boolean, negated?: boolean, options?: EntityDataFilterOptions): this;
    /**
     * Adds a brand has key filter to the request.
     * @param key - Data key.
     * @param negated - If true, negates the filter (default is false).
     * @param options - Optional settings for the filter.
     * @returns The BrandFilterBuilder instance for chaining.
     */
    addBrandDataHasKeyFilter(key: string, negated?: boolean, options?: FilterOptions): this;
    /**
     * Adds a brand is disabled filter to the request. Only works for brand queries, not in searches or recommendations.
     * @param negated - If true, negates the filter (default is false).
     * @param options - Optional settings for the filter.
     * @returns The BrandFilterBuilder instance for chaining.
     */
    addBrandDisabledFilter(negated?: boolean, options?: FilterOptions): this;
}

export declare type BrandIdFilter = Filter & {
    brandIds?: string[] | null;
};

export declare type BrandIdRelevanceModifier = RelevanceModifier & {
    brandId?: string | null;
    /** @format double */
    ifProductIsBrandMultiplyWeightBy: number;
    /** @format double */
    ifProductIsNotBrandMultiplyWeightBy: number;
};

export declare interface BrandIndexConfiguration {
    id?: FieldIndexConfiguration | null;
    displayName?: FieldIndexConfiguration | null;
}

export declare interface BrandNameAndIdResult {
    id?: string | null;
    displayName?: string | null;
}

export declare interface BrandNameAndIdResultAvailableFacetValue {
    value?: BrandNameAndIdResult | null;
    /** @format int32 */
    hits: number;
    selected: boolean;
}

export declare type BrandQuery = LicensedRequest & {
    filters: FilterCollection;
    /** @format int32 */
    numberOfResults: number;
    language?: Language | null;
    currency?: Currency | null;
    /** @format int32 */
    skipNumberOfResults: number;
    returnTotalNumberOfResults: boolean;
    includeDisabledBrands: boolean;
};

export declare interface BrandRecommendationRequest {
    $type: string;
    settings: BrandRecommendationRequestSettings;
    language?: Language | null;
    user?: User | null;
    relevanceModifiers: RelevanceModifierCollection;
    filters: FilterCollection;
    displayedAtLocationType: string;
    currency?: Currency | null;
    /** @deprecated */
    channel?: Channel | null;
    custom?: Record<string, string | null>;
}

export declare interface BrandRecommendationRequestSettings {
    /** @format int32 */
    numberOfRecommendations: number;
    allowFillIfNecessaryToReachNumberOfRecommendations: boolean;
    allowReplacingOfRecentlyShownRecommendations: boolean;
    prioritizeDiversityBetweenRequests: boolean;
    selectedBrandProperties?: SelectedBrandPropertiesSettings | null;
    custom?: Record<string, string>;
    /** @format int32 */
    prioritizeResultsNotRecommendedWithinSeconds?: number | null;
}

export declare type BrandRecommendationResponse = RecommendationResponse & {
    recommendations?: BrandResult[] | null;
};

export declare interface BrandRecommendationWeights {
    /** @format double */
    brandViews: number;
    /** @format double */
    productViews: number;
    /** @format double */
    productPurchases: number;
}

export declare interface BrandResult {
    id?: string | null;
    displayName?: string | null;
    /** @format int32 */
    rank: number;
    viewedByUser?: ViewedByUserInfo | null;
    assortments?: number[] | null;
    data?: Record<string, DataValue>;
    custom?: Record<string, string | null>;
}

export declare interface BrandResultDetails {
    brandId?: string | null;
    displayName?: string | null;
    assortments?: number[] | null;
    data?: Record<string, DataValue>;
    viewedByUser?: ViewedByUserInfo | null;
    /** @format date-time */
    createdUtc: string;
    /** @format date-time */
    lastViewedUtc?: string | null;
    /** @format int64 */
    viewedTotalNumberOfTimes: number;
    /** @format int32 */
    viewedByDifferentNumberOfUsers: number;
    disabled: boolean;
    custom?: Record<string, string | null>;
    /** @format int32 */
    purchasedFromByDifferentNumberOfUsers: number;
    purchasedByUser?: PurchasedByUserInfo | null;
}

export declare class BrandSettingsRecommendationBuilder extends RecommendationRequestBuilder {
    protected recommendationSettings: BrandRecommendationRequestSettings;
    constructor(settings: Settings);
    /**
     * Select the properties of the brand to be returned, by default only the brand id is returned.
     * @param brandProperties
     */
    setSelectedBrandProperties(brandProperties: Partial<SelectedBrandPropertiesSettings> | null): this;
    setNumberOfRecommendations(count: number): this;
    allowFillIfNecessaryToReachNumberOfRecommendations(allowed?: boolean): this;
    allowReplacingOfRecentlyShownRecommendations(allowed?: boolean): this;
    prioritizeDiversityBetweenRequests(prioritize?: boolean): this;
}

export declare interface BrandsRecommendationBuilder<TRequest = BrandRecommendationRequest> {
    build(): TRequest;
}

export declare type BrandUpdate = Trackable & {
    brand?: Brand | null;
    kind: "None" | "UpdateAndAppend" | "ReplaceProvidedProperties" | "ClearAndReplace";
};

export declare type BrandView = Trackable & {
    user?: User | null;
    brand: Brand;
    /** @deprecated */
    channel?: Channel | null;
};

export declare interface Budget {
    $type: string;
    /** @format double */
    maxTotalCost?: number | null;
    /** @format double */
    totalCost: number;
}

export declare type ByHitsFacetSorting = FacetSorting;

export declare class BySingleProductRecommendationBuilder extends ProductSettingsRecommendationBuilder {
    protected productAndVariantId: ProductAndVariantId | null;
    constructor(settings: Settings);
    product(product: {
        productId: string;
        variantId?: string;
    }): this;
}

export declare type Campaign = CampaignEntityStateCampaignMetadataValuesRetailMediaEntity & {
    name: string;
    schedule?: ISchedule | null;
    promotions: PromotionCollection;
    /** @format uuid */
    advertiserId: string;
    budget: CPMBudget;
    status: CampaignStatusWithHistory;
    conditions?: CampaignCampaignConditions | null;
};

export declare interface CampaignAnalytics {
    products?: CampaignAnalyticsProductAnalytics | null;
}

export declare interface CampaignAnalyticsProductAnalytics {
    timeSeries?: CampaignAnalyticsProductAnalyticsPeriodMetrics[] | null;
    /** @format int32 */
    promotions: number;
    promotedProducts?: CampaignAnalyticsProductAnalyticsPromotedProductMetrics[] | null;
}

export declare interface CampaignAnalyticsProductAnalyticsPeriodMetrics {
    /** @format date-time */
    periodFromUtc: string;
    /** @format int32 */
    views: number;
    /** @format int32 */
    salesQuantity: number;
    currencies?: CampaignAnalyticsProductAnalyticsPeriodMetricsCurrencyMetrics[] | null;
}

export declare interface CampaignAnalyticsProductAnalyticsPeriodMetricsCurrencyMetrics {
    currency?: string | null;
    /** @format double */
    revenue: number;
}

export declare interface CampaignAnalyticsProductAnalyticsPromotedProductMetrics {
    productId?: string | null;
    /** @format int32 */
    promotions: number;
}

export declare type CampaignAnalyticsRequest = LicensedRequest & {
    /** @format uuid */
    id: string;
    periodUtc: DateTimeRange;
    filters?: FilterCollection | null;
};

export declare type CampaignAnalyticsResponse = TimedResponse & {
    analytics?: CampaignAnalytics | null;
};

export declare type CampaignCampaignConditions = RetailMediaConditions & {
    searchTerm?: RetailMediaSearchTermConditionCollection | null;
};

export declare interface CampaignCampaignEntityStateEntityResponse {
    $type: string;
    entities?: Campaign[] | null;
    /** @format int32 */
    hits: number;
    hitsPerState?: {
        /** @format int32 */
        Proposed: number;
        /** @format int32 */
        Approved: number;
        /** @format int32 */
        Archived: number;
    } | null;
    statistics?: Statistics | null;
}

export declare interface CampaignEntityStateCampaignMetadataValuesCampaignsRequestSortByCampaignsRequestEntityFiltersEntitiesRequest {
    $type: string;
    filters?: CampaignsRequestEntityFilters | null;
    sorting?: CampaignsRequestSortBySorting | null;
    /** @format int32 */
    skip: number;
    /** @format int32 */
    take: number;
    custom?: Record<string, string | null>;
}

export declare interface CampaignEntityStateCampaignMetadataValuesRetailMediaEntity {
    $type: string;
    state: "Proposed" | "Approved" | "Archived";
    metadata: CampaignMetadataValues;
    /** @format uuid */
    id?: string | null;
}

export declare type CampaignMetadataValues = MetadataValues & {
    /** @format date-time */
    proposed?: string | null;
    proposedBy?: string | null;
    /** @format date-time */
    approved?: string | null;
    approvedBy?: string | null;
    /** @format date-time */
    archived?: string | null;
    archivedBy?: string | null;
};

export declare interface CampaignSaveEntitiesRequest {
    $type: string;
    entities: Campaign[];
    modifiedBy: string;
    custom?: Record<string, string | null>;
}

export declare interface CampaignSaveEntitiesResponse {
    $type: string;
    entities?: Campaign[] | null;
    statistics?: Statistics | null;
}

export declare type CampaignsRequest = CampaignEntityStateCampaignMetadataValuesCampaignsRequestSortByCampaignsRequestEntityFiltersEntitiesRequest;

export declare type CampaignsRequestEntityFilters = RetailMediaEntity2CampaignEntityStateCampaignMetadataValuesRetailMediaEntity2EntityFilters & {
    ids?: string[] | null;
    advertiserIds?: string[] | null;
};

export declare interface CampaignsRequestSortBySorting {
    sortBy: "Created" | "Modified" | "Name";
    sortOrder: "Ascending" | "Descending";
}

export declare type CampaignsResponse = CampaignCampaignEntityStateEntityResponse;

export declare interface CampaignStatusWithHistory {
    current: "Active" | "Inactive" | "ScheduleCompleted" | "BudgetReached";
    history: CampaignStatusWithHistoryChange[];
}

export declare interface CampaignStatusWithHistoryChange {
    /** @format date-time */
    utcTime: string;
    status: "Active" | "Inactive" | "ScheduleCompleted" | "BudgetReached";
}

export declare type Cart = Trackable & {
    user?: User | null;
    name?: string | null;
    subtotal?: Money | null;
    lineItems?: LineItem[] | null;
    data?: Record<string, DataValue>;
    /** @deprecated */
    channel?: Channel | null;
};

export declare type CartDataFilter = Filter & {
    key: string;
    filterOutIfKeyIsNotFound: boolean;
    mustMatchAllConditions: boolean;
    conditions?: ValueConditionCollection | null;
    language?: Language | null;
    currency?: Currency | null;
};

export declare interface CartDetails {
    name?: string | null;
    /** @format date-time */
    modifiedUtc: string;
    lineItems?: LineItem[] | null;
    subtotal?: Money | null;
    data?: Record<string, DataValue>;
}

export declare interface Category {
    $type: string;
    id?: string | null;
    displayName?: Multilingual | null;
    categoryPaths?: CategoryPath[] | null;
    assortments?: number[] | null;
    data?: Record<string, DataValue>;
    custom?: Record<string, string | null>;
}

export declare interface CategoryAdministrativeAction {
    $type: string;
    filters: FilterCollection;
    language?: Language | null;
    kind: "Disable" | "Enable" | "Delete";
    currency?: Currency | null;
    custom?: Record<string, string | null>;
}

export declare type CategoryFacet = StringValueFacet & {
    categorySelectionStrategy: "ImmediateParent" | "Ancestors" | "Descendants";
};

export declare type CategoryFacetResult = StringCategoryNameAndIdResultValueFacetResult & {
    categorySelectionStrategy: "ImmediateParent" | "Ancestors" | "Descendants";
};

export declare type CategoryHierarchyFacet = CategoryPathValueFacet & {
    categorySelectionStrategy: "ImmediateParent" | "Ancestors" | "Descendants";
    selectedPropertiesSettings?: SelectedContentCategoryPropertiesSettings | SelectedProductCategoryPropertiesSettings | null;
};

export declare type CategoryHierarchyFacetResult = FacetResult & {
    categorySelectionStrategy: "ImmediateParent" | "Ancestors" | "Descendants";
    nodes: CategoryHierarchyFacetResultCategoryNode[];
};

export declare interface CategoryHierarchyFacetResultCategoryNode {
    category: ContentCategoryResult | ProductCategoryResult;
    /** @format int32 */
    hits: number;
    parentId?: string | null;
    children?: CategoryHierarchyFacetResultCategoryNode[] | null;
    selected: boolean;
}

export declare interface CategoryIdFilter {
    $type: string;
    categoryIds?: string[] | null;
    evaluationScope: "ImmediateParent" | "ImmediateParentOrItsParent" | "Ancestor";
    negated: boolean;
    custom?: Record<string, string>;
    settings?: FilterSettings | null;
}

export declare interface CategoryIndexConfiguration {
    $type: string;
    unspecified?: CategoryIndexConfigurationEntry | null;
}

export declare interface CategoryIndexConfigurationEntry {
    id?: FieldIndexConfiguration | null;
    displayName?: FieldIndexConfiguration | null;
    data?: DataIndexConfiguration | null;
}

export declare interface CategoryLevelFilter {
    $type: string;
    levels?: number[] | null;
    negated: boolean;
    custom?: Record<string, string>;
    settings?: FilterSettings | null;
}

export declare interface CategoryNameAndId {
    id: string;
    displayName?: Multilingual | null;
}

export declare interface CategoryNameAndIdResult {
    id?: string | null;
    displayName?: string | null;
}

export declare interface CategoryNameAndIdResultAvailableFacetValue {
    value?: CategoryNameAndIdResult | null;
    /** @format int32 */
    hits: number;
    selected: boolean;
}

export declare interface CategoryPath {
    breadcrumbPathStartingFromRoot: CategoryNameAndId[];
}

export declare interface CategoryPathResult {
    pathFromRoot?: CategoryNameAndIdResult[] | null;
    /** @format int32 */
    rank: number;
}

export declare interface CategoryPathResultDetails {
    breadcrumbPathStartingFromRoot?: CategoryNameAndId[] | null;
}

export declare interface CategoryPathValueFacet {
    $type: string;
    selected?: CategoryPath[] | null;
    field: "Category" | "Assortment" | "ListPrice" | "SalesPrice" | "Brand" | "Data" | "VariantSpecification" | "User";
    settings?: FacetSettings | null;
}

export declare interface CategoryResult {
    $type: string;
    categoryId?: string | null;
    displayName?: string | null;
    /** @format int32 */
    rank: number;
    viewedByUser?: ViewedByUserInfo | null;
    paths?: CategoryPathResult[] | null;
    assortments?: number[] | null;
    data?: Record<string, DataValue>;
    custom?: Record<string, string | null>;
}

export declare interface CategoryUpdate {
    $type: string;
    kind: "UpdateAndAppend" | "ReplaceProvidedProperties" | "ClearAndReplace";
    custom?: Record<string, string | null>;
}

export declare interface Channel {
    name: string;
    subChannel?: Channel | null;
}

export declare type ClearTextParser = Parser;

export declare interface CollectionWithType<T> {
    $type: string;
    $values: T[];
}

export declare interface Company {
    id: string;
    parent?: Company | null;
    data?: Record<string, DataValue>;
}

export declare type CompanyAdministrativeAction = Trackable & {
    filters: FilterCollection;
    language?: Language | null;
    kind: "Disable" | "Enable" | "Delete";
    currency?: Currency | null;
};

export declare type CompanyDataFilter = DataFilter;

export declare type CompanyDataHasKeyFilter = Filter & {
    key: string;
};

export declare type CompanyDisabledFilter = Filter;

export declare class CompanyFilterBuilder extends FilterBuilderBase<CompanyFilterBuilder> {
    constructor();
    /**
     * Filters the request to only return the specified companies.
     * @param companyIds - Array of company IDs or a single ID.
     * @param negated - If true, negates the filter (default is false).
     * @param options - Optional settings for the filter.
     * @returns The CompanyFilterBuilder instance for chaining.
     */
    addCompanyIdFilter(companyIds: string | string[], negated?: boolean, options?: FilterOptions): this;
    /**
     * Adds a company data filter to the request.
     * @param key - Data key.
     * @param conditionBuilder - Function to build the condition.
     * @param mustMatchAllConditions - If true, all conditions must be met (default is true).
     * @param filterOutIfKeyIsNotFound - If true, filters out companies without the key (default is true).
     * @param negated - If true, negates the filter (default is false).
     * @param options - Optional settings for the filter.
     * @returns The CompanyFilterBuilder instance for chaining.
     */
    addCompanyDataFilter(key: string, conditionBuilder: (builder: ConditionBuilder) => void, mustMatchAllConditions?: boolean, filterOutIfKeyIsNotFound?: boolean, negated?: boolean, options?: EntityDataFilterOptions): this;
    /**
     * Adds a company has key filter to the request.
     * @param key - Data key.
     * @param negated - If true, negates the filter (default is false).
     * @param options - Optional settings for the filter.
     * @returns The CompanyFilterBuilder instance for chaining.
     */
    addCompanyDataHasKeyFilter(key: string, negated?: boolean, options?: FilterOptions): this;
    /**
     * Adds a company is disabled filter to the request. Only works for company queries, not in searches or recommendations.
     * @param negated - If true, negates the filter (default is false).
     * @param options - Optional settings for the filter.
     * @returns The CompanyFilterBuilder instance for chaining.
     */
    addCompanyDisabledFilter(negated?: boolean, options?: FilterOptions): this;
}

export declare type CompanyIdFilter = Filter & {
    companyIds: string[];
};

export declare type CompanyUpdate = Trackable & {
    company: Company;
    kind: "UpdateAndAppend" | "ReplaceProvidedProperties" | "ClearAndReplace";
    parents?: Company[] | null;
    replaceExistingParents: boolean;
};

export declare class ConditionBuilder {
    conditions: Conditions[];
    addContainsCondition<T>(value: DataValueBase<T>, valueCollectionEvaluationMode?: 'All' | 'Any', negated?: boolean): this;
    addDistinctCondition(numberOfOccurrencesAllowedWithTheSameValue: number, negated?: boolean): this;
    addEqualsCondition<T>(value: DataValueBase<T>, negated?: boolean): this;
    addGreaterThanCondition(value: number, negated?: boolean): this;
    addLessThanCondition(value: number, negated?: boolean): this;
    addDataObjectCondition(conditions: (builder: DataObjectFilterConditionBuilder) => void, skip?: number, take?: number, negated?: boolean): this;
    addHasValueCondition(negated?: boolean): this;
    addRelativeDateTimeCondition(comparison: 'Before' | 'After', unit: 'UnixMilliseconds' | 'UnixSeconds' | 'UnixMinutes', currentTimeOffset?: number, negated?: boolean): this;
    build(): ValueConditionCollection | null;
}

export declare interface ConditionConfiguration {
    user?: UserConditionConfiguration | null;
    input?: InputConditionConfiguration | null;
    target?: TargetConditionConfiguration | null;
    context?: ContextConditionConfiguration | null;
}

export declare type Conditions = ContainsCondition | DistinctCondition | EqualsCondition | GreaterThanCondition | LessThanCondition | HasValueCondition | RelativeDateTimeCondition;

export declare type Constructor<T> = new () => T;

export declare type ContainsCondition = ValueCondition & {
    value?: DataValue | null;
    valueCollectionEvaluationMode: "All" | "Any";
    objectFilter?: DataObjectFilter | null;
};

export declare interface Content {
    id: string;
    displayName?: Multilingual | null;
    categoryPaths?: CategoryPath[] | null;
    assortments?: number[] | null;
    data?: Record<string, DataValue>;
    custom?: Record<string, string>;
}

export declare type ContentAdministrativeAction = Trackable & {
    filters: FilterCollection;
    language?: Language | null;
    kind: "DisableInRecommendations" | "Disable" | "EnableInRecommendations" | "Enable" | "PermanentlyDelete" | "Delete";
    currency?: Currency | null;
};

export declare type ContentAssortmentFacet = AssortmentFacet;

export declare type ContentAssortmentFacetResult = AssortmentFacetResult;

export declare type ContentAssortmentFilter = Filter & {
    assortments: number[];
};

export declare type ContentAttributeSorting = ContentSorting & {
    attribute: "Id" | "DisplayName";
    mode: "Auto" | "Alphabetical" | "Numerical";
};

export declare interface ContentCategoriesRecommendationBuilder<TRequest = ContentCategoryRecommendationRequest> {
    build(): TRequest;
}

export declare class ContentCategoriesRecommendationCollectionBuilder {
    private requests;
    private distinctCategoriesAcrossResults;
    addRequest(request: (PersonalContentCategoryRecommendationRequest | PopularContentCategoriesRecommendationRequest)): this;
    requireDistinctCategoriesAcrossResults(distinctCategoriesAcrossResults?: boolean): this;
    build(): ContentCategoryRecommendationRequestCollection;
}

export declare type ContentCategory = Category;

export declare type ContentCategoryAdministrativeAction = CategoryAdministrativeAction;

export declare type ContentCategoryAssortmentFilter = Filter & {
    assortments: number[];
};

export declare type ContentCategoryDataFilter = DataFilter;

export declare type ContentCategoryDataHasKeyFilter = Filter & {
    key: string;
};

export declare type ContentCategoryDataRelevanceModifier = DataRelevanceModifier;

export declare type ContentCategoryDetailsCollectionResponse = TimedResponse & {
    categories?: ContentCategoryResultDetails[] | null;
    /** @format int32 */
    totalNumberOfResults?: number | null;
};

export declare type ContentCategoryDisabledFilter = Filter;

export declare type ContentCategoryHasAncestorFilter = HasAncestorCategoryFilter;

export declare type ContentCategoryHasChildFilter = HasChildCategoryFilter;

export declare type ContentCategoryHasContentsFilter = Filter;

export declare type ContentCategoryHasParentFilter = HasParentCategoryFilter;

export declare type ContentCategoryIdFilter = CategoryIdFilter;

export declare interface ContentCategoryIdFilterCategoryQuery {
    $type: string;
    filters: FilterCollection;
    /** @format int32 */
    numberOfResults: number;
    language?: Language | null;
    currency?: Currency | null;
    /** @format int32 */
    skipNumberOfResults: number;
    returnTotalNumberOfResults: boolean;
    includeDisabledCategories: boolean;
    /** @format int32 */
    includeChildCategoriesToDepth: number;
    /** @format int32 */
    includeParentCategoriesToDepth: number;
    custom?: Record<string, string | null>;
}

export declare type ContentCategoryInterestTriggerConfiguration = ContentCategoryInterestTriggerResultTriggerConfiguration & {
    categoryViews?: Int32NullableRange | null;
    contentViews?: Int32NullableRange | null;
    filters?: FilterCollection | null;
};

export declare interface ContentCategoryInterestTriggerResultTriggerConfiguration {
    $type: string;
    custom?: Record<string, string | null>;
    /** @format uuid */
    id: string;
    name?: string | null;
    description?: string | null;
    group?: string | null;
    enabled: boolean;
    /** @format date-time */
    created: string;
    createdBy?: string | null;
    /** @format date-time */
    modified: string;
    modifiedBy?: string | null;
    /** @format int32 */
    withinTimeSpanMinutes: number;
    settings?: Record<string, string | null>;
    userConditions?: UserConditionCollection | null;
}

export declare type ContentCategoryLevelFilter = CategoryLevelFilter;

export declare type ContentCategoryQuery = ContentCategoryIdFilterCategoryQuery;

export declare type ContentCategoryRecentlyViewedByUserFilter = Filter & {
    /** @format date-time */
    sinceUtc?: string | null;
    /** @format int32 */
    sinceMinutesAgo?: number | null;
};

export declare type ContentCategoryRecentlyViewedByUserRelevanceModifier = RecentlyViewedByUserRelevanceModifier;

export declare interface ContentCategoryRecommendationRequest {
    $type: string;
    settings: ContentCategoryRecommendationRequestSettings;
    language?: Language | null;
    user?: User | null;
    relevanceModifiers: RelevanceModifierCollection;
    filters: FilterCollection;
    displayedAtLocationType: string;
    currency?: Currency | null;
    /** @deprecated */
    channel?: Channel | null;
    custom?: Record<string, string | null>;
}

export declare type ContentCategoryRecommendationRequestCollection = LicensedRequest & {
    requests?: (PersonalContentCategoryRecommendationRequest | PopularContentCategoriesRecommendationRequest)[] | null;
    requireDistinctCategoriesAcrossResults: boolean;
};

export declare interface ContentCategoryRecommendationRequestSettings {
    /** @format int32 */
    numberOfRecommendations: number;
    allowFillIfNecessaryToReachNumberOfRecommendations: boolean;
    allowReplacingOfRecentlyShownRecommendations: boolean;
    prioritizeDiversityBetweenRequests: boolean;
    selectedContentCategoryProperties?: SelectedContentCategoryPropertiesSettings | null;
    custom?: Record<string, string | null>;
    /** @format int32 */
    prioritizeResultsNotRecommendedWithinSeconds?: number | null;
}

export declare type ContentCategoryRecommendationResponse = RecommendationResponse & {
    recommendations?: ContentCategoryResult[] | null;
};

export declare type ContentCategoryRecommendationResponseCollection = TimedResponse & {
    responses?: ContentCategoryRecommendationResponse[] | null;
};

export declare interface ContentCategoryRecommendationWeights {
    /** @format double */
    categoryViews: number;
    /** @format double */
    contentViews: number;
}

export declare type ContentCategoryResult = CategoryResult;

export declare type ContentCategoryResultDetails = ContentCategoryResultDetailsCategoryResultDetails;

export declare interface ContentCategoryResultDetailsCategoryResultDetails {
    $type: string;
    categoryId?: string | null;
    displayName?: Multilingual | null;
    assortments?: number[] | null;
    data?: Record<string, DataValue>;
    viewedByUser?: ViewedByUserInfo | null;
    /** @format date-time */
    createdUtc: string;
    /** @format date-time */
    lastViewedUtc?: string | null;
    /** @format int64 */
    viewedTotalNumberOfTimes: number;
    /** @format int32 */
    viewedByDifferentNumberOfUsers: number;
    disabled: boolean;
    custom?: Record<string, string | null>;
    childCategories?: ContentCategoryResultDetails[] | null;
    parentCategories?: ContentCategoryResultDetails[] | null;
}

export declare type ContentCategorySearchRequest = PaginatedSearchRequest & {
    term: string;
    settings?: ContentCategorySearchSettings | null;
};

export declare type ContentCategorySearchResponse = PaginatedSearchResponse;

export declare type ContentCategorySearchSettings = SearchSettings & {
    /** @format int32 */
    numberOfRecommendations?: number | null;
    onlyIncludeRecommendationsForEmptyResults?: boolean | null;
};

export declare class ContentCategorySettingsRecommendationBuilder extends RecommendationRequestBuilder {
    protected recommendationSettings: ContentCategoryRecommendationRequestSettings;
    constructor(settings: Settings);
    /**
     * Select the properties of the content category to be returned, by default only the content category id is returned.
     * @param contentCategoryProperties
     */
    setSelectedContentCategoryProperties(contentCategoryProperties: Partial<SelectedContentCategoryPropertiesSettings> | null): this;
    setNumberOfRecommendations(count: number): this;
    allowFillIfNecessaryToReachNumberOfRecommendations(allowed?: boolean): this;
    allowReplacingOfRecentlyShownRecommendations(allowed?: boolean): this;
    prioritizeDiversityBetweenRequests(prioritize?: boolean): this;
}

export declare type ContentCategoryUpdate = CategoryUpdate & {
    category?: ContentCategory | null;
};

export declare type ContentCategoryView = Trackable & {
    user?: User | null;
    idPath: string[];
    /** @deprecated */
    channel?: Channel | null;
};

export declare interface ContentContentHighlightPropsHighlightSettings {
    $type: string;
    enabled: boolean;
    limit: HighlightSettings2ContentContentHighlightPropsHighlightSettings2Limits;
    highlightable: ContentHighlightProps;
    shape: HighlightSettings2ContentContentHighlightPropsHighlightSettings2ResponseShape;
}

export declare type ContentDataBooleanValueFacet = BooleanContentDataValueFacet;

export declare type ContentDataBooleanValueFacetResult = BooleanContentDataValueFacetResult;

export declare type ContentDataDoubleRangeFacet = DoubleNullableContentDataRangeFacet;

export declare type ContentDataDoubleRangeFacetResult = DoubleNullableContentDataRangeFacetResult;

export declare type ContentDataDoubleRangesFacet = DoubleNullableContentDataRangesFacet;

export declare type ContentDataDoubleRangesFacetResult = DoubleNullableContentDataRangesFacetResult;

export declare type ContentDataDoubleValueFacet = DoubleContentDataValueFacet;

export declare type ContentDataDoubleValueFacetResult = DoubleContentDataValueFacetResult;

export declare type ContentDataFilter = DataFilter;

export declare type ContentDataHasKeyFilter = Filter & {
    key: string;
};

export declare type ContentDataIntegerValueFacet = Int32ContentDataValueFacet;

export declare type ContentDataIntegerValueFacetResult = Int32ContentDataValueFacetResult;

export declare type ContentDataObjectFacet = DataObjectFacet;

export declare type ContentDataObjectFacetResult = DataObjectFacetResult;

export declare type ContentDataRelevanceModifier = DataRelevanceModifier;

export declare type ContentDataSorting = ContentSorting & {
    key?: string | null;
    mode: "Auto" | "Alphabetical" | "Numerical";
};

export declare type ContentDataStringValueFacet = StringContentDataValueFacet;

export declare type ContentDataStringValueFacetResult = StringContentDataValueFacetResult;

export declare type ContentDetailsCollectionResponse = TimedResponse & {
    contents?: ContentResultDetails[] | null;
    /** @format int32 */
    totalNumberOfResults?: number | null;
};

export declare type ContentDisabledFilter = Filter;

export declare type ContentFacetQuery = FacetQuery & {
    items: (ContentAssortmentFacet | ProductAssortmentFacet | ProductCategoryAssortmentFacet | BrandFacet | CategoryFacet | CategoryHierarchyFacet | ContentDataObjectFacet | ContentDataDoubleRangeFacet | ContentDataDoubleRangesFacet | ContentDataStringValueFacet | ContentDataBooleanValueFacet | ContentDataDoubleValueFacet | ContentDataIntegerValueFacet | DataObjectFacet | DataObjectDoubleRangeFacet | DataObjectDoubleRangesFacet | DataObjectStringValueFacet | DataObjectBooleanValueFacet | DataObjectDoubleValueFacet | PriceRangeFacet | PriceRangesFacet | ProductCategoryDataObjectFacet | ProductCategoryDataDoubleRangeFacet | ProductCategoryDataDoubleRangesFacet | ProductCategoryDataStringValueFacet | ProductCategoryDataBooleanValueFacet | ProductCategoryDataDoubleValueFacet | ProductDataObjectFacet | ProductDataDoubleRangeFacet | ProductDataDoubleRangesFacet | ProductDataStringValueFacet | ProductDataBooleanValueFacet | ProductDataDoubleValueFacet | ProductDataIntegerValueFacet | RecentlyPurchasedFacet | VariantSpecificationFacet)[];
};

export declare interface ContentFacetResult {
    items?: (ProductAssortmentFacetResult | ContentAssortmentFacetResult | ProductCategoryAssortmentFacetResult | BrandFacetResult | CategoryFacetResult | CategoryHierarchyFacetResult | ContentDataObjectFacetResult | ContentDataDoubleRangeFacetResult | ContentDataDoubleRangesFacetResult | ContentDataStringValueFacetResult | ContentDataBooleanValueFacetResult | ContentDataDoubleValueFacetResult | ContentDataIntegerValueFacetResult | DataObjectFacetResult | DataObjectDoubleRangeFacetResult | DataObjectDoubleRangesFacetResult | DataObjectStringValueFacetResult | DataObjectBooleanValueFacetResult | DataObjectDoubleValueFacetResult | PriceRangeFacetResult | PriceRangesFacetResult | ProductCategoryDataObjectFacetResult | ProductCategoryDataDoubleRangeFacetResult | ProductCategoryDataDoubleRangesFacetResult | ProductCategoryDataStringValueFacetResult | ProductCategoryDataBooleanValueFacetResult | ProductCategoryDataDoubleValueFacetResult | ProductDataObjectFacetResult | ProductDataDoubleRangeFacetResult | ProductDataDoubleRangesFacetResult | ProductDataStringValueFacetResult | ProductDataBooleanValueFacetResult | ProductDataDoubleValueFacetResult | ProductDataIntegerValueFacetResult | RecentlyPurchasedFacetResult | VariantSpecificationFacetResult)[] | null;
}

export declare class ContentFilterBuilder extends FilterBuilderBase<ContentFilterBuilder> {
    constructor();
    /**
     * Adds a content assortment filter to the request.
     * @param assortmentIds - Array of assortment IDs or a single ID.
     * @param negated - If true, negates the filter (default is false).
     * @param options - Optional settings for the filter.
     * @returns The ContentFilterBuilder instance for chaining.
     */
    addContentAssortmentFilter(assortmentIds: number[] | number, negated?: boolean, options?: FilterOptions): this;
    /**
     * Adds a content category assortment filter to the request.
     * @param assortmentIds - Array of assortment