@coveo/platform-client 35.0.0

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

@@ -0,0 +1,5 @@
+import Resource from '../Resource';
+export default class Links extends Resource {
+    static baseUrl: string;
+    deleteAll(): Promise<Record<string, unknown>>;
+}

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

@@ -0,0 +1 @@
+export * from './Links';

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

@@ -0,0 +1,8 @@
+import Resource from '../Resource';
+import { FacetsModel, FacetsWithCountsModel, GetFacetsParams, GetLogsOrFacetsRequestBodyModel, GetLogsParams, LogsModel } from './LogsInterfaces';
+export default class Logs extends Resource {
+    static baseUrl: string;
+    get(params: GetLogsParams, options: GetLogsOrFacetsRequestBodyModel): Promise<LogsModel>;
+    getFacets(params: GetFacetsParams, options: GetLogsOrFacetsRequestBodyModel): Promise<FacetsModel>;
+    getFacetsStats(params: GetFacetsParams, options: GetLogsOrFacetsRequestBodyModel): Promise<FacetsWithCountsModel>;
+}

package/dist/definitions/resources/Logs/LogsInterfaces.d.ts

@@ -0,0 +1,47 @@
+import { Paginated } from '../BaseInterfaces';
+import { IndexingPipelineLogOperations, IndexingPipelineLogResults, IndexingPipelineLogTasks } from '../Enums';
+export interface GetLogsParams extends GetFacetsParams, Paginated {
+}
+export interface GetFacetsParams {
+    from: string;
+    to: string;
+    documentId?: string;
+}
+export interface GetLogsOrFacetsRequestBodyModel extends FacetsModel {
+    excludeOperations?: IndexingPipelineLogOperations[];
+    excludeResourceIds?: string[];
+    excludeResults?: IndexingPipelineLogResults[];
+    excludeSourceIds?: string[];
+    excludeTasks?: IndexingPipelineLogTasks[];
+}
+export interface FacetsModel {
+    operations?: IndexingPipelineLogOperations[];
+    resourceIds?: string[];
+    results?: IndexingPipelineLogResults[];
+    sourceIds?: string[];
+    tasks?: IndexingPipelineLogTasks[];
+}
+export interface LogsModel {
+    documentLogEntries: IndexingPipelineLogEntry[];
+    hasNextPage: boolean;
+}
+export interface IndexingPipelineLogEntry {
+    datetime: string;
+    guid: string;
+    id: string;
+    meta: Record<string, any>;
+    operation: IndexingPipelineLogOperations;
+    organizationId: string;
+    requestId: string;
+    resourceId: string;
+    result: IndexingPipelineLogResults;
+    sourceId: string;
+    task: IndexingPipelineLogTasks;
+}
+export interface FacetsWithCountsModel {
+    operations: Record<IndexingPipelineLogOperations, number>;
+    resourceIds: Record<string, number>;
+    results: Record<IndexingPipelineLogResults, number>;
+    sourceIds: Record<string, number>;
+    tasks: Record<IndexingPipelineLogTasks, number>;
+}

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

@@ -0,0 +1,2 @@
+export * from './Logs';
+export * from './LogsInterfaces';

package/dist/definitions/resources/MachineLearning/CaseClassificationConfiguration/CaseClassificationConfiguration.d.ts

@@ -0,0 +1,15 @@
+import { New } from '../../BaseInterfaces';
+import Resource from '../../Resource';
+import { CaseClassificationConfigurationModel, CaseClassificationContentFields, CaseClassificationContentFieldsParams, CaseClassificationDocumentGroupPreview, CaseClassificationDocumentGroupPreviewParams } from './CaseClassificationConfigurationInterfaces';
+export default class CaseClassificationConfiguration extends Resource {
+    static baseUrl: string;
+    static modelUrl: string;
+    static fieldsUrl: string;
+    static previewUrl: string;
+    create(configModel: New<CaseClassificationConfigurationModel, 'modelId'>): Promise<CaseClassificationConfigurationModel>;
+    delete(modelId: string): Promise<Record<string, unknown>>;
+    get(modelId: string): Promise<CaseClassificationConfigurationModel>;
+    update(configModel: CaseClassificationConfigurationModel): Promise<CaseClassificationConfigurationModel>;
+    fields(params: CaseClassificationContentFieldsParams): Promise<CaseClassificationContentFields>;
+    preview(params: CaseClassificationDocumentGroupPreviewParams): Promise<CaseClassificationDocumentGroupPreview>;
+}

package/dist/definitions/resources/MachineLearning/CaseClassificationConfiguration/CaseClassificationConfigurationInterfaces.d.ts

@@ -0,0 +1,147 @@
+import { FilterConditions } from '../FilterConditions';
+export declare enum Operator {
+    Equals = "EQUALS",
+    NotEquals = "NOT_EQUALS"
+}
+export declare type CaseClassificationDocumentRequirementStatus = 'OK' | 'INSUFFICIENT_DOCUMENTS';
+export interface DateField {
+    /**
+     * The field to use as date.
+     */
+    dateField?: string;
+}
+export interface FixedExtractionPeriod {
+    /**
+     * Date in milliseconds that indicates the beginning of the time interval to include cases.
+     * The date format is the difference, measured in milliseconds, between the current time and midnight, January 1, 1970 UTC.
+     */
+    startTime: number;
+    /**
+     * Date in milliseconds that indicates the end of the time interval to include cases.
+     * The date format is the difference, measured in milliseconds, between the current time and midnight, January 1, 1970 UTC.
+     */
+    endTime: number;
+}
+export interface IntervalExtractionPeriod {
+    /**
+     * The period to export data from. The exportPeriod uses the moment when the model was generated as a base.
+     * Must be in the ISO8601 period format (i.e., PyYmMwWdDThHmMsS).
+     * Example: P3Y6M4DT12H30M5S Represents a duration of three years, six months, four days, twelve hours, thirty minutes, and five seconds.
+     */
+    exportPeriod: string;
+}
+export declare type ExtractionPeriod = DateField & (FixedExtractionPeriod | IntervalExtractionPeriod);
+export interface CaseClassificationConfigurationModel {
+    /**
+     * The unique ID of the model.
+     */
+    modelId: string;
+    /**
+     * The model name to display.
+     * Example: My First Model
+     */
+    modelDisplayName: string;
+    /**
+     * The names of the sources containing the cases to use for model building.
+     */
+    sources: string[];
+    /**
+     * An array of filtering conditions.
+     */
+    caseFilterConditions?: FilterConditions[];
+    /**
+     * The field containing the case ID
+     * Example: sfid
+     */
+    caseIdField: string;
+    /**
+     * The time period for which to extract cases for model building.
+     * Must contain an export period or a start time and end time.
+     */
+    caseExtractionPeriod?: ExtractionPeriod;
+    /**
+     * The case fields to use for model training.
+     * Example: [subject, reason, category]
+     */
+    fieldsForModelTraining: string[];
+    /**
+     * The case fields the model should predict.
+     * Example: [subject, reason, category]
+     */
+    fieldsToPredict: string[];
+    /**
+     * The field value to use as language.
+     */
+    languageField?: string;
+}
+export interface CaseClassificationDocumentGroupPreviewParams {
+    /**
+     * The time period for which to extract cases for model building.
+     * Must contain an export period or a start time and end time.
+     */
+    caseExtractionPeriod: ExtractionPeriod;
+    /**
+     * An array of filtering conditions.
+     */
+    caseFilterConditions: FilterConditions[];
+    /**
+     * The field value to use as language.
+     */
+    languageField: string;
+    /**
+     * The names of the sources containing the cases to use for model building.
+     */
+    sources: string[];
+}
+export interface CaseClassificationDocumentGroupPreview {
+    /**
+     * The query that was used to fetch document information.
+     */
+    query: string;
+    /**
+     * Status indicating whether there are enough candidates for learning.
+     */
+    documentRequirementStatus: CaseClassificationDocumentRequirementStatus;
+    /**
+     * The total number of documents in all sources.
+     */
+    numberOfDocuments: number;
+    /**
+     * The number of documents matching the configured conditions.
+     */
+    numberOfDocumentsMatchingConditions: number;
+    /**
+     * The number of English documents matching the configured conditions.
+     */
+    numberOfDocumentsMatchingConditionsAndInEnglish: number;
+    /**
+     * The number of documents that are candidates for learning.
+     */
+    numberOfValidDocuments: number;
+}
+export interface CaseClassificationContentFieldsParams {
+    /**
+     * The time period for which to extract cases for model building.
+     * Must contain an export period or a start time and end time.
+     */
+    caseExtractionPeriod: ExtractionPeriod;
+    /**
+     * An array of filtering conditions.
+     */
+    caseFilterConditions: FilterConditions[];
+    /**
+     * The field value to use as language.
+     */
+    languageField: string;
+    /**
+     * The names of the sources containing the cases to use for model building.
+     */
+    sources: string[];
+}
+export interface CaseClassificationContentField {
+    name: string;
+}
+export interface CaseClassificationContentFields {
+    fields: CaseClassificationContentField[];
+    query: string;
+}

package/dist/definitions/resources/MachineLearning/CaseClassificationConfiguration/index.d.ts

@@ -0,0 +1,2 @@
+export * from './CaseClassificationConfiguration';
+export * from './CaseClassificationConfigurationInterfaces';

package/dist/definitions/resources/MachineLearning/DNEConfiguration/DNEConfiguration.d.ts

@@ -0,0 +1,15 @@
+import { PageModel } from '../../BaseInterfaces';
+import Resource from '../../Resource';
+import { AutoSelectionFieldCandidateModel, DNEConfigurationModel, DNENewConfigurationModel, DocumentExtractionPreviewModel, DocumentExtractionPreviewParams, DocumentExtractionQueryModel, ListCandidateFieldsParams } from './DNEConfigurationInterfaces';
+export default class DNEConfiguration extends Resource {
+    static baseUrl: string;
+    listFields(params?: ListCandidateFieldsParams): Promise<PageModel<AutoSelectionFieldCandidateModel, "items">>;
+    getDocumentExtractionPreview(params?: DocumentExtractionPreviewParams): Promise<DocumentExtractionPreviewModel>;
+    getDocumentExtractionQuery(model: DocumentExtractionQueryModel): Promise<string>;
+    parseDocumentExtractionQuery(query: string): Promise<DocumentExtractionQueryModel>;
+    createWithoutQuery(newModel: DNENewConfigurationModel, documentExtractionQueryModel: DocumentExtractionQueryModel): Promise<DNEConfigurationModel>;
+    createWithQuery(newModel: DNENewConfigurationModel): Promise<DNEConfigurationModel>;
+    delete(modelId: string): Promise<void>;
+    get(modelId: string): Promise<DNEConfigurationModel>;
+    update(modelId: string, modelConfig: DNEConfigurationModel): Promise<DNEConfigurationModel>;
+}

package/dist/definitions/resources/MachineLearning/DNEConfiguration/DNEConfigurationInterfaces.d.ts

@@ -0,0 +1,41 @@
+import { Paginated } from '../../BaseInterfaces';
+import { IntervalUnit } from '../../Enums';
+export interface AutoSelectionFieldCandidateModel {
+    name?: string;
+    description?: string;
+}
+export interface ListCandidateFieldsParams extends Paginated {
+    filter?: string;
+}
+export interface DocumentExtractionPreviewModel {
+    numberOfDocuments?: number;
+    recommendedNumberOfDocuments?: number;
+    sources?: DocumentSourceModel[];
+}
+export interface DocumentSourceModel {
+    name?: string;
+    numberOfDocuments?: number;
+}
+export interface DocumentExtractionPreviewParams {
+    fields?: string[];
+    maximumNumberOfSources?: number;
+}
+export interface DocumentExtractionQueryModel {
+    fields?: string[];
+    sources?: string[];
+}
+export interface DNEConfigurationModel extends DNENewConfigurationModel {
+    documentGroupId?: string;
+    modelId?: string;
+}
+export interface DNENewConfigurationModel {
+    commonFilter?: string;
+    documentExtractionQuery?: string;
+    exportPeriod?: string;
+    fieldsToAutoSelect?: string[];
+    intervalTime?: number;
+    intervalUnit?: IntervalUnit;
+    modelDisplayName: string;
+    searchEventFilter?: string;
+    viewAllContent?: boolean;
+}

package/dist/definitions/resources/MachineLearning/DNEConfiguration/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DNEConfiguration';
+export * from './DNEConfigurationInterfaces';

package/dist/definitions/resources/MachineLearning/FilterConditions.d.ts

@@ -0,0 +1,18 @@
+import { Operator } from './CaseClassificationConfiguration';
+export interface FilterConditions {
+    /**
+     * The name of the field.
+     * Example: status
+     */
+    field: string;
+    /**
+     * The operator to use to evaluate the condition.
+     * Must be EQUALS or NOT_EQUALS
+     */
+    operator: Operator;
+    /**
+     * The value to use for the condition.
+     * Example: completed
+     */
+    value: string;
+}

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

@@ -0,0 +1,26 @@
+import API from '../../APICore';
+import Resource from '../Resource';
+import CaseClassificationConfiguration from './CaseClassificationConfiguration/CaseClassificationConfiguration';
+import DNEConfiguration from './DNEConfiguration/DNEConfiguration';
+import SmartSnippetsConfiguration from './SmartSnippetsConfiguration/SmartSnippetsConfiguration';
+import { MLModelCreated, RegistrationModel } from './MachineLearningInterfaces';
+import ModelConfiguration from './ModelConfiguration/ModelConfiguration';
+import ModelInformation from './ModelInformation/ModelInformation';
+import Models from './Models/Models';
+import PQSConfiguration from './PQSConfiguration/PQSConfiguration';
+import UserActionHistoryConfiguration from './UserActionHistoryConfiguration/UserActionHistoryConfiguration';
+export default class MachineLearning extends Resource {
+    protected api: API;
+    protected serverlessApi: API;
+    static baseUrl: string;
+    models: Models;
+    modelInfo: ModelInformation;
+    modelConfig: ModelConfiguration;
+    dneConfig: DNEConfiguration;
+    caseClassificationConfig: CaseClassificationConfiguration;
+    smartSnippetsConfig: SmartSnippetsConfiguration;
+    userActionHistoryConfig: UserActionHistoryConfiguration;
+    pqsConfig: PQSConfiguration;
+    constructor(api: API, serverlessApi: API);
+    register(registration: RegistrationModel): Promise<MLModelCreated>;
+}

package/dist/definitions/resources/MachineLearning/MachineLearningInterfaces.d.ts

@@ -0,0 +1,65 @@
+import { GranularResource } from '../BaseInterfaces';
+import { IntervalUnit } from '../Enums';
+import { MLModel } from './Models';
+export interface RegistrationModel extends GranularResource {
+    engineId: string;
+    modelName: string;
+    modelDisplayName?: string;
+    /**
+     * The period to export data from. Unless an exportOffset is specified, the exportPeriod uses the moment when the model was generated as a base.
+     * Must be in the ISO8601 period format (i.e., PyYmMwWdDThHmMsS)
+     */
+    exportPeriod: string;
+    intervalTime: number;
+    intervalUnit: IntervalUnit;
+    /**
+     * The offset period to apply to the export.
+     * An undefined exportOffset means that the exportPeriod is based on the moment when the model was generated.
+     * An exportOffset of P1W means that the exportPeriod is based on the moment one week before the model was generated.
+     * If specified, must be in the ISO8601 period format (i.e., PyYmMwWdDThHmMsS)
+     */
+    exportOffset?: string;
+    commandLineParameters?: string[];
+    extraConfig?: {
+        [key: string]: any;
+    };
+    /**
+     * The filter to apply to the common event dimensions (shared by all event types) in the export.
+     * Multiple filter parameters are joined with the AND operator
+     */
+    commonFilter?: string;
+    /**
+     * The filter to apply to the custom event dimensions in the export.
+     * Multiple filter parameters are joined with the AND operator
+     */
+    customEventFilter?: string;
+    /**
+     * The filter to apply to the click and search event dimensions in the export.
+     * Multiple filter parameters are joined with the AND operator
+     */
+    searchEventFilter?: string;
+    /**
+     * The filter to apply to the view event dimensions (shared by all event types) in the export.
+     * Multiple filter parameters are joined with the AND operator
+     */
+    viewEventFilter?: string;
+    /**
+     * The version matcher to select the valid drills.
+     * See the documentation https://github.com/zafarkhaja/jsemver/#external-dsl
+     */
+    versionMatcher?: string;
+}
+export interface MLModelCreated extends MLModel {
+    modelId?: string;
+    /**
+     * The epoch date when the schedule will end.
+     * If there is no end date, the schedule will last forever.
+     */
+    endTime?: number;
+    /**
+     * A timestamp indicating when to begin the first job (in milliseconds since UNIX epoch format).
+     * If no start date is specified, the job starts immediately
+     */
+    startTime?: number;
+    resourceId?: string;
+}

package/dist/definitions/resources/MachineLearning/ModelConfiguration/ModelConfiguration.d.ts

@@ -0,0 +1,7 @@
+import Resource from '../../Resource';
+import { AdvancedRegistrationConfigFile, AdvancedRegistrationConfigFileCreationResponse } from './ModelConfigurationInterfaces';
+export default class ModelConfiguration extends Resource {
+    static getBaseUrl: (modelId: string) => string;
+    getAdvancedConfig(modelId: string): Promise<AdvancedRegistrationConfigFile>;
+    updateAdvancedConfig(modelId: string, modelConfigFileContents: string): Promise<AdvancedRegistrationConfigFileCreationResponse>;
+}

package/dist/definitions/resources/MachineLearning/ModelConfiguration/ModelConfigurationInterfaces.d.ts

@@ -0,0 +1,10 @@
+export interface AdvancedRegistrationConfigFile {
+    fileContents?: string;
+    lastModified?: string;
+    modelId?: string;
+    orgId?: string;
+}
+export interface AdvancedRegistrationConfigFileCreationResponse {
+    filePath?: string;
+    modelId?: string;
+}

package/dist/definitions/resources/MachineLearning/ModelConfiguration/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ModelConfiguration';
+export * from './ModelConfigurationInterfaces';

package/dist/definitions/resources/MachineLearning/ModelInformation/ModelInformation.d.ts

@@ -0,0 +1,10 @@
+import Resource from '../../Resource';
+import { RegistrationModel } from '../MachineLearningInterfaces';
+import { MLModelInfo, MLModelTypeInfo } from './ModelInformationInterfaces';
+import { MLModel } from '../Models';
+export default class ModelInformation extends Resource {
+    static getBaseUrl: (engineId: string, modelName: string) => string;
+    get<T extends MLModelTypeInfo>(engineId: string, modelName: string): Promise<MLModelInfo<T>>;
+    delete(engineId: string, modelName: string): Promise<Record<string, unknown>>;
+    update(engineId: string, modelName: string, modelInformation: RegistrationModel): Promise<Partial<MLModel<never>>>;
+}