@coveo/platform-client 35.0.0

package/dist/definitions/resources/ApiKeys/ApiKeysInterfaces.d.ts

@@ -0,0 +1,133 @@
+import { GranularResource, PrivilegeModel } from '../BaseInterfaces';
+export interface ApiKeyModel extends GranularResource {
+    /**
+     * The unique identifier of the [organization](https://docs.coveo.com/en/222/) the API key was created for.
+     */
+    organizationId?: string;
+    /**
+     * The unique identifier of the API key.
+     *
+     * **Example:** t4hk287bfj5sg6wskg64ckk5a
+     */
+    id?: string;
+    /**
+     * Whether the API key is enabled.
+     */
+    enabled?: boolean;
+    /**
+     * The value of the API key.
+     *
+     * **Example:** xx65151ec3-7b30-4772-a99a-09b4c0f71343
+     */
+    value?: string;
+    /**
+     * The display name for the API key.
+     *
+     * **Example:** PushApiKey
+     */
+    displayName?: string;
+    /**
+     * A brief description of the API key.
+     *
+     * **Example:** API key used for managing sources.
+     */
+    description?: string;
+    /**
+     * The username or the email address that was used to create this API key.
+     */
+    createdBy?: any;
+    /**
+     * The API key creation date in Unix timestamp in milliseconds.
+     *
+     * **Example:** 1614969486000
+     */
+    createdDate?: number;
+    /**
+     * The approximate API key last used date in Unix timestamp in milliseconds.
+     *
+     * **Example:** 1624575600000
+     */
+    lastUsedDate?: number;
+    /**
+     * A set of IP addresses allowed to use the API key.
+     *
+     * **Notes:**
+     * - IP ranges using CIDR notation are also supported.
+     * - If an IP address is included in both the `allowedIps` as well as the `deniedIps`, the IP address will be denied.
+     *
+     * **Example:** [`"192.168.0.0/16"`, `"29.186.225.13"`]
+     */
+    allowedIps?: string[];
+    /**
+     * A set of IP addresses that will be denied access when attempting to use the API key.
+     *
+     * **Notes:**
+     * - IP ranges using CIDR notation are also supported.
+     * - If an IP address is included in both the `allowedIps` as well as the `deniedIps`, the IP address will be denied.
+     *
+     * **Example:** [`"192.168.0.0/16"`, `"29.186.225.13"`]
+     */
+    deniedIps?: string[];
+    /**
+     * A set of privileges.
+     */
+    privileges?: PrivilegeModel[];
+    /**
+     * The unique identifier of the API key.
+     *
+     * **Example:** t4hk287bfj5sg6wskg64ckk5a
+     */
+    resourceId?: string;
+    /**
+     * Additional configuration to be included in an API key. [to be revised]
+     */
+    additionalConfiguration?: AdditionalConfigurationModel;
+}
+export interface CreateApiKeyOptions {
+    /**
+     * The unique identifier of the template on which to base the API key.
+     */
+    apiKeyTemplateId?: string;
+}
+interface AdditionalConfigurationModel {
+    /**
+     * Configuration specific to commerce organization. [to be revised]
+     */
+    commerce?: CommerceConfigurationModel;
+    search?: SearchConfigurationModel;
+}
+interface CommerceConfigurationModel {
+    /**
+     * The catalog identifier to be linked to an API key. [to be revised]
+     */
+    catalogId: string;
+}
+interface SearchConfigurationModel {
+    apiKeyQueryAuthentication?: QueryAuthenticationModel[];
+    enforcedQueryPipelineConfiguration?: EnforceQueryPipelineConfigurationModel;
+    impersonationRestriction?: ImpersonationRestrictionsModel;
+}
+interface QueryAuthenticationModel {
+    /**
+     * Authentication name. [to be revised]
+     */
+    name: string;
+    /**
+     * Authentication provider. [to be revised]
+     */
+    provider: string;
+    /**
+     * Authentication type. [to be revised]
+     */
+    type: string;
+}
+interface EnforceQueryPipelineConfigurationModel {
+    /**
+     * Search hub name to be linked to an API key. [to be revised]
+     */
+    searchHub: string;
+}
+interface ImpersonationRestrictionsModel {
+    allowedUserIds: QueryAuthenticationModel[];
+}
+export {};

package/dist/definitions/resources/ApiKeys/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ApiKeys';
+export * from './ApiKeysInterfaces';

package/dist/definitions/resources/BaseInterfaces.d.ts

@@ -0,0 +1,51 @@
+export declare type PageModel<T = any, TItemsKey extends string = 'items'> = {
+    [key in TItemsKey]: T[];
+} & {
+    totalEntries: number;
+    totalPages: number;
+};
+export declare type New<T, K extends string | number | symbol = null> = Omit<T, 'id' | K>;
+export interface IdAndDisplayNameModel {
+    id: string;
+    displayName?: string;
+}
+export interface PrivilegeModel {
+    /**
+     * The owner of the privilege.
+     * See [Valid Privilege owner, targetDomain, and type Combinations](https://docs.coveo.com/en/159/).
+     */
+    owner: string;
+    /**
+     * The target domain of the privilege.
+     * See [Valid Privilege owner, targetDomain, and type Combinations](https://docs.coveo.com/en/159/).
+     */
+    targetDomain: string;
+    /**
+     * The `displayName` of the source targeted by the privilege.
+     * Note: The wildcard character (`*`) will include all sources.
+     */
+    targetId?: string;
+    /**
+     * The type of the privilege.
+     * See [Valid Privilege owner, targetDomain, and type Combinations](https://docs.coveo.com/en/159/).
+     */
+    type?: string;
+    /**
+     * The access level of the global privileges.
+     */
+    level?: string;
+}
+export interface GranularResource {
+    apiKeysThatCanEdit?: IdAndDisplayNameModel[];
+    groupsThatCanEdit?: IdAndDisplayNameModel[];
+}
+export interface Paginated {
+    /**
+     * The 0-based index number of the page of elements to retrieve.
+     */
+    page?: number;
+    /**
+     * The number of elements to list per page.
+     */
+    perPage?: number;
+}

package/dist/definitions/resources/CaseAssistConfigs/CaseAssistConfig.d.ts

@@ -0,0 +1,16 @@
+import { New, PageModel } from '../BaseInterfaces';
+import Resource from '../Resource';
+import { CaseAssistConfigListOptions, CaseAssistConfigModel, SuggestionRequestBody } from './CaseAssistConfigInterfaces';
+import { PreviewRequestBody, DocumentSuggestions, CaseClassifications } from './CaseAssistPreviewInterfaces';
+export default class CaseAssistConfig extends Resource {
+    static baseUrl: string;
+    list(options?: CaseAssistConfigListOptions): Promise<PageModel<CaseAssistConfigModel, "configurations">>;
+    create(caseAssistConfig: New<CaseAssistConfigModel>): Promise<CaseAssistConfigModel>;
+    delete(caseAssistConfigId: string): Promise<Record<string, unknown>>;
+    get(caseAssistConfigId: string): Promise<CaseAssistConfigModel>;
+    update(caseAssistConfig: CaseAssistConfigModel): Promise<CaseAssistConfigModel>;
+    classify(caseAssistConfigId: string, body: SuggestionRequestBody): Promise<CaseClassifications>;
+    suggestDocuments(caseAssistConfigId: string, body: SuggestionRequestBody): Promise<DocumentSuggestions>;
+    previewDocumentSuggestion(body: PreviewRequestBody): Promise<DocumentSuggestions>;
+    previewCaseClassication(body: PreviewRequestBody): Promise<CaseClassifications>;
+}

package/dist/definitions/resources/CaseAssistConfigs/CaseAssistConfigInterfaces.d.ts

@@ -0,0 +1,59 @@
+import { Paginated } from '../BaseInterfaces';
+export declare enum DocumentSuggestionsStrategies {
+    ITD = "ITD"
+}
+export declare enum TypingAidsStrategies {
+    StaticValues = "StaticValues",
+    ValuesFromIndex = "ValuesFromIndex"
+}
+export declare enum CaseClassificationStrategies {
+    Some = "Some",
+    Axon = "Axon"
+}
+export interface CaseAssistConfigListOptions extends Paginated {
+}
+export interface ITDConfigurationModel {
+    pipeline?: string;
+    filter?: string;
+    strategy: DocumentSuggestionsStrategies;
+}
+export interface StaticValuesConfigurationModel {
+    values: string[];
+    strategy: TypingAidsStrategies;
+}
+export interface ValuesFromIndexConfigurationModel {
+    filter: string;
+    field: string;
+    strategy: TypingAidsStrategies;
+}
+export interface FieldToPredict {
+    name: string;
+}
+export interface CaseClassificationSomeConfigurationModel {
+    filter?: string;
+    fieldsToPredict?: FieldToPredict[];
+    strategy: CaseClassificationStrategies;
+}
+export interface CaseClassificationAxonConfigurationModel {
+    modelId: string;
+    strategy: CaseClassificationStrategies;
+}
+export declare type TypingAidsConfigurations = StaticValuesConfigurationModel | ValuesFromIndexConfigurationModel;
+export declare type DocumentSuggestionsConfigurations = ITDConfigurationModel;
+export declare type CaseClassificationConfiguration = CaseClassificationSomeConfigurationModel | CaseClassificationAxonConfigurationModel;
+export interface CaseAssistConfigModel {
+    id: string;
+    name: string;
+    documentSuggestionConfiguration?: DocumentSuggestionsConfigurations;
+    typingAidsConfiguration?: TypingAidsConfigurations;
+    classificationConfigurations?: CaseClassificationConfiguration[];
+}
+export interface ContextField {
+    value: string;
+}
+export declare type ContextFields = Record<string, ContextField>;
+export interface SuggestionRequestBody {
+    visitorId: string;
+    locale: string;
+    fields: ContextFields;
+}

package/dist/definitions/resources/CaseAssistConfigs/CaseAssistPreviewInterfaces.d.ts

@@ -0,0 +1,27 @@
+import { New } from '../BaseInterfaces';
+import { CaseAssistConfigModel, ContextFields } from './CaseAssistConfigInterfaces';
+export interface Document {
+    title: string;
+    clickUri: string;
+    excerpt: string;
+    fields: Record<string, number | string>;
+}
+export interface DocumentSuggestions {
+    documents: Document[];
+    totalCount: number;
+}
+export interface FieldValueSuggestion {
+    predictions: Array<{
+        value: string;
+        confidence: number;
+    }>;
+}
+export interface CaseClassifications {
+    fields: Record<string, FieldValueSuggestion>;
+}
+export interface PreviewRequestBody {
+    visitorId: string;
+    locale: string;
+    fields: ContextFields;
+    configuration: New<CaseAssistConfigModel>;
+}

package/dist/definitions/resources/CaseAssistConfigs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './CaseAssistConfig';
+export * from './CaseAssistConfigInterfaces';
+export * from './CaseAssistPreviewInterfaces';

package/dist/definitions/resources/Catalogs/Catalog.d.ts

@@ -0,0 +1,21 @@
+import { New, PageModel } from '../BaseInterfaces';
+import Resource from '../Resource';
+import { CachedCatalogFieldsModel, CachedCatalogFieldStatsModel, CatalogFieldsOptions, CatalogFieldStatsOptions, CatalogModel, CatalogsListOptions, CreateCatalogModel, FieldsSuggestionsModel, FieldsSuggestionsQueryModel } from './CatalogInterfaces';
+export default class Catalog extends Resource {
+    static baseUrl: string;
+    list(options?: CatalogsListOptions): Promise<PageModel<CatalogModel, "items">>;
+    create(catalog: New<CreateCatalogModel>): Promise<CreateCatalogModel>;
+    delete(catalogId: string): Promise<Record<string, unknown>>;
+    get(catalogId: string): Promise<CatalogModel>;
+    /**
+     * @deprecated getFields(catalogId: string, options?: CatalogFieldsOptions) is kept for backward compatibility, you should now use `getFieldStats(catalogId: string, options?: CatalogFieldStatsOptions)`.
+     */
+    getFields(catalogId: string, options?: CatalogFieldsOptions): Promise<CachedCatalogFieldsModel>;
+    update(catalog: CreateCatalogModel): any;
+    /**
+     * @deprecated `update(catalog: CatalogModel) is kept for backward compatibility, you should now use `update(catalog: CreateCatalogModel)`.
+     */
+    update(catalog: CatalogModel): any;
+    getFieldsSuggestions(query: FieldsSuggestionsQueryModel): Promise<FieldsSuggestionsModel>;
+    getFieldStats(catalogId: string, options?: CatalogFieldStatsOptions): Promise<CachedCatalogFieldStatsModel>;
+}

package/dist/definitions/resources/Catalogs/CatalogConfiguration.d.ts

@@ -0,0 +1,11 @@
+import { New, PageModel } from '../BaseInterfaces';
+import Resource from '../Resource';
+import { CatalogConfigurationModel, CreateCatalogConfigurationModel, CatalogConfigurationsListOptions } from './CatalogInterfaces';
+export default class CatalogConfiguration extends Resource {
+    static baseUrl: string;
+    list(options?: CatalogConfigurationsListOptions): Promise<PageModel<CatalogConfigurationModel, "items">>;
+    create(configuration: New<CreateCatalogConfigurationModel>): Promise<CatalogConfigurationModel>;
+    delete(configurationId: string): Promise<Record<string, unknown>>;
+    get(configurationId: string): Promise<CatalogConfigurationModel>;
+    update(configuration: CreateCatalogConfigurationModel): Promise<CatalogConfigurationModel>;
+}

package/dist/definitions/resources/Catalogs/CatalogInterfaces.d.ts

@@ -0,0 +1,338 @@
+export interface CatalogsListOptions {
+    /**
+     * Filter that will be matched against the catalog name, description and its configuration name.
+     */
+    filter?: string;
+    /**
+     * The 0-based index number of the page of catalogs to retrieve.
+     */
+    page?: number;
+    /**
+     * The number of catalogs to list per page.
+     */
+    pageSize?: number;
+}
+export declare type CatalogConfigurationsListOptions = Omit<CatalogsListOptions, 'filter'>;
+export interface CatalogFieldsOptions {
+    /**
+     * If true, the database cache will be bypassed. This will resolve your fields once, and save them into the database.
+     */
+    bypassCache?: boolean;
+}
+export interface CatalogFieldsMapping {
+    /**
+     * Mapping of index fields to standard commerce fields
+     */
+    [name: string]: string;
+}
+export interface CreateCatalogConfigurationModel {
+    /**
+     * The unique identifier of the catalog configuration.
+     */
+    id: string;
+    /**
+     * The name of the catalog configuration.
+     */
+    name: string;
+    /**
+     * The configuration product structure
+     */
+    product: Omit<CreateProductHierarchyModel, 'fields'>;
+    /**
+     * The configuration variant structure
+     */
+    variant?: Omit<CreateVariantHierarchyModel, 'fields'>;
+    /**
+     * The configuration availability structure
+     */
+    availability?: Omit<CreateAvailabilityHierarchyModel, 'fields'>;
+    /**
+     * The configuration mapping of index fields to standard commerce fields
+     */
+    fieldsMapping: CatalogFieldsMapping;
+}
+export interface CatalogConfigurationModel {
+    /**
+     * The unique identifier of the catalog configuration.
+     */
+    id: string;
+    /**
+     * The name of the catalog configuration.
+     */
+    name: string;
+    /**
+     * The configuration product structure
+     */
+    product: HierarchyWithFields<ProductHierarchyModel>;
+    /**
+     * The configuration variant structure
+     */
+    variant?: HierarchyWithFields<VariantHierarchyModel>;
+    /**
+     * The configuration availability structure
+     */
+    availability?: HierarchyWithFields<AvailabilityHierarchyModel>;
+    /**
+     * The configuration mapping of index fields to standard commerce fields
+     */
+    fieldsMapping: CatalogFieldsMapping;
+    /**
+     * Catalogs associated to the configuration
+     */
+    associatedCatalogs: IAssociatedCatalogModel[];
+}
+export interface IAssociatedCatalogModel {
+    /**
+     * The unique identifier of the catalog
+     */
+    id: string;
+    /**
+     * The name of the catalog
+     */
+    name: string;
+    /**
+     * The source containing catalog products
+     */
+    sourceId?: string;
+    /**
+     * The source containing catalog availabilities
+     */
+    availabilitySourceId?: string;
+}
+export interface BaseCatalogModel {
+    /**
+     * The unique identifier of the catalog
+     */
+    id: string;
+    /**
+     * The name of the catalog
+     */
+    name: string;
+    /**
+     * The description of the catalog
+     */
+    description?: string;
+    /**
+     * The source containing catalog products
+     */
+    sourceId?: string;
+    /**
+     * The source containing catalog availabilities
+     */
+    availabilitySourceId?: string;
+    /**
+     * @deprecated use `sourceId` and `availabilitySourceId` instead.
+     */
+    scope?: ScopeModel;
+}
+export declare type HierarchyWithFields<T extends {
+    fields?: string[];
+}> = Omit<T, 'fields'> & {
+    /**
+     * Fields for a specific object type
+     */
+    fields: string[];
+};
+interface Updated {
+    /**
+     * Cache last updated timestamp
+     */
+    lastUpdated: number;
+    /**
+     * Cache next update timestamp
+     */
+    nextUpdate: number;
+}
+interface Cached<T> extends Updated {
+    /**
+     * Cached items
+     */
+    item: T;
+}
+interface CatalogFieldsModel {
+    /**
+     * Fields for the product object type
+     */
+    productFields: string[];
+    /**
+     * Fields for the variant object type
+     */
+    variantFields: string[];
+    /**
+     * Fields for the availability object type
+     */
+    availabilityFields: string[];
+}
+export declare type CachedCatalogFieldsModel = Cached<CatalogFieldsModel>;
+export interface CatalogModel extends BaseCatalogModel {
+    /**
+     * @deprecated use `configuration.product` instead.
+     */
+    product: ProductHierarchyModel;
+    /**
+     * @deprecated use `configuration.variant` instead.
+     */
+    variant?: HierarchyWithFields<VariantHierarchyModel>;
+    /**
+     * @deprecated use `configuration.availability` instead.
+     */
+    availability?: HierarchyWithFields<AvailabilityHierarchyModel>;
+    /**
+     * The related catalog configuration id
+     */
+    catalogConfigurationId?: string;
+    /**
+     * The catalog configuration
+     */
+    configuration?: CatalogConfigurationModel;
+}
+export declare type CreateCatalogModel = BaseCatalogModel & ({
+    product?: CreateProductHierarchyModel;
+    variant?: CreateVariantHierarchyModel;
+    availability?: CreateAvailabilityHierarchyModel;
+    catalogConfigurationId?: never;
+} | {
+    product?: never;
+    variant?: never;
+    availability?: never;
+    catalogConfigurationId: string;
+});
+export interface FieldsSuggestionsQueryModel {
+    /**
+     * Source names for which to retrieve product and variant field suggestions
+     */
+    sourceNames: string[];
+    /**
+     * Source names for which to retrievee availability field suggestions
+     */
+    availabilitySourceNames?: string[];
+    /**
+     * The product object type
+     */
+    productObjectType: string;
+    /**
+     * The variant object type
+     */
+    variantObjectType?: string;
+    /**
+     * The availability object type
+     */
+    availabilityObjectType?: string;
+}
+export interface FieldsSuggestionsModel {
+    /**
+     * List of field suggestions
+     */
+    fields: FieldSuggestions[];
+}
+export interface FieldSuggestions {
+    /**
+     * Suggested field name
+     */
+    name: string;
+    /**
+     * Example values for the field
+     */
+    examples: string[];
+}
+export interface ProductHierarchyModel {
+    /**
+     * @deprecated `fields` will be ignored by the service on creation or update, but is kept for backward compatibility.
+     */
+    fields?: string[];
+    /**
+     * Field used as the unique product identifier
+     */
+    idField: string;
+    /**
+     * Product object type
+     */
+    objectType: string;
+}
+export declare type CreateProductHierarchyModel = ProductHierarchyModel;
+export interface VariantHierarchyModel {
+    /**
+     * @deprecated `fields` will be ignored by the service on creation or update, but is kept for backward compatibility.
+     */
+    fields: string[];
+    /**
+     * Field used as the unique variant identifier
+     */
+    idField: string;
+    /**
+     * Variant object type
+     */
+    objectType: string;
+}
+export declare type CreateVariantHierarchyModel = VariantHierarchyModel;
+export interface AvailabilityHierarchyModel {
+    /**
+     * Field used to contain the list of SKUs for an availability
+     */
+    availableSkusField: string;
+    /**
+     * @deprecated `fields` will be ignored by the service on creation or update, but is kept for backward compatibility.
+     */
+    fields: string[];
+    /**
+     * Field used as the unique availability identifier
+     */
+    idField?: string;
+    /**
+     * Availability object type
+     */
+    objectType: string;
+}
+export declare type CreateAvailabilityHierarchyModel = AvailabilityHierarchyModel & {
+    /**
+     * Field used as the unique availability identifier
+     */
+    idField: string;
+};
+export declare type ScopeModel = {
+    query: string;
+} | {
+    query?: string;
+    sourceIds: string[];
+};
+export interface CachedCatalogFieldStatsModel extends Updated {
+    /**
+     * List of field statistics
+     */
+    fieldStats: FieldStatsModel[];
+}
+export interface FieldStatsItemModel {
+    /**
+     * Number of objects in the catalog with this field
+     */
+    objectsWithField: number;
+    /**
+     * Number of objects in the catalog with this type
+     */
+    objectsWithType: number;
+}
+export interface FieldStatsModel {
+    /**
+     * Field name
+     */
+    fieldName: string;
+    /**
+     * The field stats for product structure
+     */
+    product: FieldStatsItemModel;
+    /**
+     * The field stats for variant structure
+     */
+    variant: FieldStatsItemModel;
+    /**
+     * The field stats for availability structure
+     */
+    availability: FieldStatsItemModel;
+}
+export interface CatalogFieldStatsOptions {
+    /**
+     * Wether we need to force a refresh of field statistics. Field statistics are cached and computed on a regular interval.
+     */
+    forceRefresh?: boolean;
+}
+export {};

package/dist/definitions/resources/Catalogs/ProductListing.d.ts

@@ -0,0 +1,14 @@
+import { New, PageModel } from '../BaseInterfaces';
+import Resource from '../Resource';
+import { ProductListingsListOptions, ProductListingModel, CatalogProductListingsGroupModel } from './ProductListingInterfaces';
+export default class ProductListing extends Resource {
+    static baseCatalogsUrl: string;
+    static baseProductListingsUrl: string;
+    list(catalogId: string, options?: ProductListingsListOptions): Promise<PageModel<ProductListingModel, "items">>;
+    create(catalogId: string, model: New<ProductListingModel>): Promise<ProductListingModel>;
+    delete(catalogId: string, productListingId: string): Promise<Record<string, unknown>>;
+    get(catalogId: string, productListingId: string): Promise<ProductListingModel>;
+    update(catalogId: string, model: ProductListingModel): Promise<ProductListingModel>;
+    getByCatalog(): Promise<PageModel<CatalogProductListingsGroupModel, "items">>;
+    getUrls(): Promise<string[]>;
+}