@coveo/platform-client 35.0.0

package/dist/definitions/resources/SecurityCache/SecurityCacheInterfaces.d.ts

@@ -0,0 +1,137 @@
+import { Paginated } from '../BaseInterfaces';
+import { PermissionIdentityType, ScheduleType, SecurityCacheStateOptions, SecurityProviderReferenceType, SecurityProviderType } from '../Enums';
+import { ParameterModel, UserIdentityModel } from '../Sources';
+export interface ScheduleModel {
+    enabled: boolean;
+    frequency?: ScheduleFrequency;
+    id: string;
+    organizationId?: string;
+    refreshType?: string;
+    resourceId?: string;
+    scheduleType?: string;
+}
+export interface SecurityCacheStatus {
+    currentStatus?: CurrentStatusModel;
+    statistics?: SecurityProviderStatisticsModel;
+}
+export interface SecurityCacheIdentityModel {
+    data?: string;
+    provider?: string;
+}
+export interface SecurityProviderModel {
+    cascadingSecurityProviders?: Record<string, CascadingSecurityProvider>;
+    caseSensitive?: boolean;
+    crawlingModuleId?: string;
+    displayName?: string;
+    id: string;
+    instanceId?: string;
+    name: string;
+    nodeRequired?: boolean;
+    nodeTypeName?: string;
+    onPremisesEnabled?: boolean;
+    organizationId?: string;
+    parameters?: ParameterModel;
+    referencedBy?: SecurityProviderReferenceModel[];
+    sourceTypeName?: string;
+    type?: SecurityProviderType;
+    userIdentities?: UserIdentityModel;
+}
+export interface SecurityProviderModelWithStatus extends Required<SecurityProviderModel> {
+    currentStatus: CurrentStatusModel;
+    lastRefreshOperation: LastRefreshOperation;
+    statistics: SecurityProviderStatisticsModel;
+}
+export interface CascadingSecurityProvider {
+    id: string;
+    name: string;
+    type?: SecurityProviderType;
+    typeName?: string;
+}
+export interface ScheduleFrequency {
+    hourMinute?: HourMinutePair;
+    monthDay?: number;
+    seed?: number;
+    type?: ScheduleType;
+    value?: number;
+    weekDays?: string[];
+}
+export interface HourMinutePair {
+    hour?: number;
+    minute?: number;
+}
+export interface LastRefreshOperation {
+    errorCode?: string;
+    id: string;
+    numberOfEntitiesProcessed?: number;
+    operationType?: string;
+    result?: string;
+    timestamp?: number;
+}
+export interface SecurityProviderReferenceModel {
+    attributes?: SecurityProviderReferenceModelAttributes;
+    id: string;
+    type?: SecurityProviderReferenceType;
+}
+export interface CurrentStatusModel {
+    numberOfEntitiesInError?: number;
+    numberOfEntitiesProcessed?: number;
+    refreshType?: string;
+    totalNumberOfEntities?: number;
+    type?: string;
+}
+export interface SecurityProviderStatisticsModel {
+    numberOfEntitiesByState?: {
+        DISABLED: number;
+        IN_ERROR: number;
+        NOT_UPDATED: number;
+        OUT_OF_DATE: number;
+        UP_TO_DATE: number;
+    };
+    numberOfEntitiesInError?: number;
+    numberOfPermissionModels?: number;
+    numberOfProviders?: number;
+    totalNumberOfEntities?: number;
+}
+export interface SecurityProviderReferenceModelAttributes {
+    crawlerInstanceType?: string;
+    id: string;
+    name: string;
+    onPremisesEnabled?: boolean;
+    pushEnabled?: boolean;
+    streamEnabled?: boolean;
+    sourceType?: string;
+}
+export interface SecurityCacheListOptions extends Paginated {
+    from?: string;
+    organisationId?: string;
+    securityProviderId?: string;
+    states?: SecurityCacheStateOptions;
+    to?: string;
+}
+export interface SecurityProviderIdentitiesFilters extends Paginated {
+    filterTerm?: string;
+    identityTypes?: PermissionIdentityType[];
+}
+export interface SecurityCacheListRelationshipsOptions extends Paginated {
+    recursive?: boolean;
+}
+export interface SecurityCacheMemberModel {
+    infos?: SecurityCacheMemberInfoModel[];
+    name: string;
+    provider?: string;
+    type?: PermissionIdentityType;
+}
+export interface DetailedSecurityCacheMemberModel extends SecurityCacheMemberModel {
+    lastUpdateDate?: number;
+    lastUpdateErrorDetail?: string;
+    lastUpdateResult?: string;
+    state?: string;
+}
+export interface SecurityCacheMemberInfoModel {
+    key: string;
+    value: string;
+}
+export interface SecurityProvider {
+    name?: string;
+    typeName?: string;
+}

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

@@ -0,0 +1,2 @@
+export * from './SecurityCache';
+export * from './SecurityCacheInterfaces';

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

@@ -0,0 +1,67 @@
+import API from '../../APICore';
+import { New, PageModel } from '../BaseInterfaces';
+import { ActivityOperation } from '../Enums';
+import Resource from '../Resource';
+import { ScheduleModel } from '../SecurityCache';
+import SourcesDatasets from './SourcesDatasets/SourcesDatasets';
+import SourcesFields from './SourcesFields/SourcesFields';
+import { CreateSourceModel, CreateSourceOptions, LightSourceModel, ListOperationalStatusSourcesParams, ListSourcesParams, RawSourceConfig, SourceModel } from './SourcesInterfaces';
+import SourcesMappings from './SourcesMappings/SourcesMappings';
+import SourcesMetadata from './SourcesMetadata/SourcesMetadata';
+export default class Sources extends Resource {
+    protected api: API;
+    protected serverlessApi: API;
+    static baseUrl: string;
+    field: SourcesFields;
+    mappings: SourcesMappings;
+    datasets: SourcesDatasets;
+    metadata: SourcesMetadata;
+    constructor(api: API, serverlessApi: API);
+    create(source: New<CreateSourceModel, 'resourceId'>, options?: CreateSourceOptions): Promise<{
+        id: string;
+    }>;
+    list(params?: ListSourcesParams): Promise<PageModel<SourceModel, "sourceModels">>;
+    /**
+     * @description New API resource for the list of sources
+     * @experimental
+     */
+    listOperationalStatus(params?: ListOperationalStatusSourcesParams): Promise<PageModel<SourceModel, "sourceModels">>;
+    createFromRaw(rawSourceConfig: RawSourceConfig, options?: CreateSourceOptions): Promise<{
+        id: string;
+    }>;
+    delete(sourceId: string): Promise<Record<string, unknown>>;
+    get(sourceId: string): Promise<SourceModel>;
+    update(sourceId: string, source: CreateSourceModel, options?: CreateSourceOptions): Promise<{
+        id: string;
+    }>;
+    applyChanges(sourceId: string): Promise<Record<string, unknown>>;
+    isDedicated(sourceId: string): Promise<{
+        value: boolean;
+    }>;
+    setDedicated(sourceId: string, enabled?: boolean): Promise<Record<string, unknown>>;
+    dumpRefresh(sourceId: string): Promise<{
+        value: boolean;
+    }>;
+    duplicate(sourceId: string, newSourceName: string, logicalIndexId?: string): Promise<SourceModel>;
+    evictCachedCrawlerConfig(sourceId: string): Promise<Record<string, unknown>>;
+    fullRefresh(sourceId: string): Promise<SourceModel>;
+    incrementalRefresh(sourceId: string): Promise<SourceModel>;
+    listSourceItemTypes(sourceId: string): Promise<string[]>;
+    getLightSource(sourceId: string): Promise<LightSourceModel>;
+    pauseRefresh(sourceId: string): Promise<SourceModel>;
+    setPushRefreshStatus(sourceId: string, activityOperation: ActivityOperation): Promise<Record<string, unknown>>;
+    getRawSource(sourceId: string): Promise<RawSourceConfig>;
+    updateRawSource(sourceId: string, platformSourceConfig: RawSourceConfig, options?: CreateSourceOptions): Promise<{
+        id: string;
+    }>;
+    rebuild(sourceId: string): Promise<SourceModel>;
+    resumeRefresh(sourceId: string): Promise<SourceModel>;
+    retryCreation(sourceId: string): Promise<SourceModel>;
+    listSchedules(sourceId: string): Promise<ScheduleModel[]>;
+    createSchedule(sourceId: string, sourceSchedule: ScheduleModel): Promise<ScheduleModel>;
+    deleteSchedule(sourceId: string, scheduleId: string): Promise<Record<string, unknown>>;
+    updateSchedule(sourceId: string, scheduleId: string, sourceSchedule: ScheduleModel): Promise<ScheduleModel>;
+    startRefresh(sourceId: string): Promise<SourceModel>;
+    stopRefresh(sourceId: string): Promise<SourceModel>;
+    abortTaskForActivity(sourceId: string, activityId: string): Promise<Record<string, unknown>>;
+}

package/dist/definitions/resources/Sources/SourcesDatasets/SourcesDatasets.d.ts

@@ -0,0 +1,8 @@
+import { DatasetImportProgressModel, DatasetModel, DatasetType } from './SourcesDatasetsInterfaces';
+import Resource from '../../Resource';
+export default class SourcesDatasets extends Resource {
+    static baseUrl: string;
+    list(): Promise<DatasetModel>;
+    import(datasetName: DatasetType, withContent?: boolean): Promise<string>;
+    progress(requestId: string): Promise<DatasetImportProgressModel>;
+}

package/dist/definitions/resources/Sources/SourcesDatasets/SourcesDatasetsInterfaces.d.ts

@@ -0,0 +1,24 @@
+export interface DatasetModel {
+    hasStaticContent: boolean;
+    name: string;
+    note: string;
+}
+export declare enum DatasetType {
+    web = "WEB",
+    ecommerce = "ecommerce"
+}
+export declare enum DatasetResult {
+    error = "ERROR",
+    success = "SUCCESS"
+}
+export declare enum DatasetStatus {
+    completed = "COMPLETED",
+    inProgress = "IN_PROGRESS",
+    pending = "PENDING"
+}
+export interface DatasetImportProgressModel {
+    errorCode: string;
+    requestId: string;
+    result: DatasetResult;
+    status: DatasetStatus;
+}

package/dist/definitions/resources/Sources/SourcesDatasets/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SourcesDatasets';
+export * from './SourcesDatasetsInterfaces';

package/dist/definitions/resources/Sources/SourcesFields/SourcesFields.d.ts

@@ -0,0 +1,10 @@
+import { PageModel } from '../../BaseInterfaces';
+import Resource from '../../Resource';
+import { ListSourcesFieldsParams, SourceFieldModel } from './SourcesFieldsInterfaces';
+export default class SourcesFields extends Resource {
+    static baseUrl: string;
+    list(params?: ListSourcesFieldsParams): Promise<PageModel<SourceFieldModel, "items">>;
+    get(fieldId: string, includeMappings?: boolean): Promise<SourceFieldModel>;
+    create(fieldModel: SourceFieldModel): Promise<Record<string, unknown>>;
+    update(fieldId: string, fieldModel: SourceFieldModel): Promise<Record<string, unknown>>;
+}

package/dist/definitions/resources/Sources/SourcesFields/SourcesFieldsInterfaces.d.ts

@@ -0,0 +1,15 @@
+import { FieldModel, ListFieldsParams } from '../../Fields';
+import { LightSourceModel } from '../SourcesInterfaces';
+import { MappingModel } from '../SourcesMappings';
+export interface ListSourcesFieldsParams extends ListFieldsParams {
+    includeMappings?: boolean;
+}
+export interface SourceFieldModel extends FieldModel {
+    sources?: LightSourceModel[];
+    mappings?: FieldMappingModel[];
+}
+export interface FieldMappingModel {
+    mappings: MappingModel[];
+    sourceId: string;
+    sourceName: string;
+}

package/dist/definitions/resources/Sources/SourcesFields/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SourcesFields';
+export * from './SourcesFieldsInterfaces';

package/dist/definitions/resources/Sources/SourcesInterfaces.d.ts

@@ -0,0 +1,114 @@
+import { GranularResource, Paginated } from '../BaseInterfaces';
+import { FilterHostType, FilterLastOperationResultType, FilterLastOperationType, FilterStatusType, SortingOrder, SortingType, SourceOperationalStatus, SourceSecurityOption, SourceType, SourceVisibility } from '../Enums';
+import { SecurityProvider, SecurityProviderModel } from '../SecurityCache/SecurityCacheInterfaces';
+import * as SourcesSubInterface from './SourcesSubInterfaces';
+import { MappingModel } from './SourcesMappings';
+export * from './SourcesSubInterfaces';
+interface ListParams extends Paginated {
+    filter?: string;
+    sortingOrder?: SortingOrder;
+    sortingType?: SortingType;
+    writeAccessOnly?: boolean;
+}
+export interface ListOperationalStatusSourcesParams extends ListParams {
+    sourceOperationalStatus: SourceOperationalStatus;
+}
+export interface ListSourcesParams extends ListParams {
+    filterHostType?: FilterHostType;
+    filterLastOperationResultType?: FilterLastOperationResultType;
+    filterLastOperationType?: FilterLastOperationType;
+    filterStatusType?: FilterStatusType;
+}
+export interface ExtendedConfig {
+    addressPatterns?: SourcesSubInterface.AddressPattern[];
+    authenticationForms?: Record<string, SourcesSubInterface.FormAuthentication>;
+    caseSensitivePatterns?: boolean;
+    dataFiles?: Record<string, SourcesSubInterface.DataFile>;
+    dbConnectionString?: string;
+    documentConfig?: SourcesSubInterface.DocumentConfig;
+    documentConsumerURI?: string;
+    extendedDataFiles?: Record<string, SourcesSubInterface.ExtendedDataFile>;
+    indexIdentifier?: string;
+    metricsEnabled?: boolean;
+    parameters?: Record<string, SourcesSubInterface.ParameterModel>;
+    permissions?: SourcesSubInterface.PermissionLevel[];
+    securityProviders?: Record<string, SecurityProvider>;
+    sourceInformation?: SourcesSubInterface.SourceInformation;
+    sourceSecurityOption?: SourceSecurityOption;
+    startingAddresses?: string[];
+    userIdentities?: Record<string, SourcesSubInterface.UserIdentityModel>;
+}
+export interface RawSourceConfig extends GranularResource {
+    additionalComments?: string;
+    additionalInfos?: any;
+    configuration?: ExtendedConfig;
+    crawlerInstanceType?: string;
+    crawlingModuleId?: string;
+    fromRaw?: boolean;
+    id?: string;
+    logicalIndex?: string;
+    mappings?: MappingModel[];
+    name?: string;
+    onPremisesEnabled?: boolean;
+    owner?: string;
+    postConversionExtensions?: SourcesSubInterface.SourceExtensionModel[];
+    preConversionExtensions?: SourcesSubInterface.SourceExtensionModel[];
+    pushEnabled?: boolean;
+    streamEnabled?: boolean;
+    resourceId?: string;
+    securityProviderReferences?: string[];
+    securityProviders?: SecurityProviderModel[];
+    sourceType?: SourceType;
+}
+export interface SourceModel extends GranularResource {
+    alwaysTrustCertificates?: boolean;
+    configurationError?: SourcesSubInterface.ConfigurationError;
+    crawlingModuleId?: string;
+    customParameters?: Record<string, string>;
+    formAuthenticationConfig?: SourcesSubInterface.FormAuthenticationConfig;
+    id?: string;
+    information?: SourcesSubInterface.SourceInformation;
+    logicalIndex?: string;
+    mappings?: MappingModel[];
+    name?: string;
+    ocrFileTypes?: string[];
+    onPremisesEnabled?: boolean;
+    owner?: string;
+    password?: string;
+    pendingCrawlingModuleId?: string;
+    permissions?: SourcesSubInterface.DocumentPermissionModel;
+    postConversionExtensions?: SourcesSubInterface.SourceExtensionModel[];
+    preConversionExtensions?: SourcesSubInterface.SourceExtensionModel[];
+    pushEnabled?: boolean;
+    resourceId?: string;
+    securityProviderReferences?: string[];
+    sourceType?: SourceType;
+    sourceVisibility?: SourceVisibility;
+    streamEnabled?: boolean;
+    urlFilters?: SourcesSubInterface.UrlFilter[];
+    username?: string;
+}
+export interface LightSourceModel {
+    crawlerInstanceType?: string;
+    id?: string;
+    name?: string;
+    onPremisesEnabled?: boolean;
+    pushEnabled?: boolean;
+    streamEnabled?: boolean;
+    sourceType?: SourceType;
+}
+export interface CreateSourceModel extends SourceModel, SourcesSubInterface.SourceInformation {
+    AutomaticFormAuth?: string;
+    FormAuth?: string;
+    authentication?: string;
+    ocrType?: string;
+    passwordInputName?: string;
+    passwordInputValue?: string;
+    usernameInputName?: string;
+    usernameInputValue?: string;
+    [key: string]: any;
+}
+export interface CreateSourceOptions {
+    rebuild?: boolean;
+    updateSecurityProviders?: boolean;
+}

package/dist/definitions/resources/Sources/SourcesMappings/SourcesMappings.d.ts

@@ -0,0 +1,7 @@
+import Resource from '../../Resource';
+import { MappingsConfiguration, UpdateMappingsConfiguration } from './SourcesMappingsInterfaces';
+export default class SourcesMappings extends Resource {
+    static baseUrl: string;
+    get(sourceId: string): Promise<MappingsConfiguration>;
+    update(sourceId: string, mappingsConfiguration: UpdateMappingsConfiguration, rebuild?: boolean): Promise<Record<string, unknown>>;
+}

package/dist/definitions/resources/Sources/SourcesMappings/SourcesMappingsInterfaces.d.ts

@@ -0,0 +1,72 @@
+import { FieldTypes, MappingModelKind } from '../../Enums';
+export interface MappingSettingsModel {
+    /**
+     * The [mapping](https://docs.coveo.com/en/217/) rules.
+     * See [Mapping Rule Syntax Reference](https://docs.coveo.com/en/1839/).
+     */
+    rules: MappingRule[];
+}
+export interface UpdateTypedMappingSettingsModel extends MappingSettingsModel {
+    /**
+     * The unique identifier of the mapping.
+     * Note: Typically matches the type value.
+     * Example: Video
+     */
+    type: string;
+}
+export interface TypedMappingSettingsModel extends UpdateTypedMappingSettingsModel {
+    /**
+     * The [type](https://docs.coveo.com/en/210/) of item for which the mapping applies.
+     * Example: Video
+     */
+    id: string;
+}
+export interface MappingsConfiguration {
+    common: MappingSettingsModel;
+    types: TypedMappingSettingsModel[];
+}
+export interface UpdateMappingsConfiguration {
+    /**
+     * The common [mappings](https://docs.coveo.com/en/217/)
+     * (i.e., the mappings that apply to all [item](https://docs.coveo.com/en/210/) types).
+     */
+    common: MappingSettingsModel;
+    /**
+     * The specific [mappings](The specific mappings (i.e., the mappings that apply only to specified item types).)
+     * (i.e., the mappings that apply only to specified [item](https://docs.coveo.com/en/210/) types).
+     */
+    types: UpdateTypedMappingSettingsModel[];
+}
+export interface MappingModel {
+    content?: string;
+    extractionMethod?: string;
+    fieldName?: string;
+    fieldTypeHint?: FieldTypes;
+    id?: string;
+    kind?: MappingModelKind;
+    type?: string;
+    literalContent?: string;
+    metadataContent?: string;
+}
+export interface UpdateMappingRule {
+    /**
+     *
+     * The mapping rule statements.
+     * Example: ["%[internal_rating]"]
+     * See [Mapping Rule Syntax Reference](https://docs.coveo.com/en/1839/).
+     */
+    content: string[];
+    /**
+     * The name of the target [field](https://docs.coveo.com/en/200/) to populate with
+     * the first non-null value yielded by a mapping rule statement from the content array.
+     * Example: rating
+     */
+    field: string;
+}
+export interface MappingRule extends UpdateMappingRule {
+    /**
+     * The unique identifier of the mapping rule.
+     * Example: q5dpywnbpb3ul7xpyodh3e2j7i
+     */
+    id: string;
+}

package/dist/definitions/resources/Sources/SourcesMappings/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SourcesMappings';
+export * from './SourcesMappingsInterfaces';

package/dist/definitions/resources/Sources/SourcesMetadata/SourcesMetadata.d.ts

@@ -0,0 +1,9 @@
+import Resource from '../../Resource';
+import { Paginated } from '../../BaseInterfaces';
+import { MetadataPageModel, MetadataReportStatus } from './SourcesMetadataInterfaces';
+export default class SourcesMetadata extends Resource {
+    static baseUrl: string;
+    generateReport(sourceId: string): Promise<void>;
+    getReport(sourceId: string, params?: Paginated): Promise<MetadataPageModel>;
+    getReportStatus(sourceId: string): Promise<MetadataReportStatus>;
+}

package/dist/definitions/resources/Sources/SourcesMetadata/SourcesMetadataInterfaces.d.ts

@@ -0,0 +1,55 @@
+import { PageModel } from '../../BaseInterfaces';
+export interface MetadataPageModel extends PageModel {
+    items: Metadata[];
+    creationDate: number;
+    expirationDate: number;
+    sampledDocumentCount: number;
+    documentErrorCount: number;
+}
+export interface MetadataValue {
+    /**
+     * The metadata value
+     */
+    metadataValue: any;
+    /**
+     * The number of time the value has been seen on documents
+     */
+    count: number;
+}
+export interface Metadata {
+    /**
+     * The key for a metadata.
+     */
+    key: string;
+    /**
+     * The frequency in % at which this metadata has been seen on documents.
+     */
+    frequency: number;
+    /**
+     * Subset of sample values for the metadata.
+     */
+    values: MetadataValue[];
+    /**
+     * The origin of the metadata.
+     */
+    origin: string;
+    /**
+     * Whether the origin is mapped or not.
+     */
+    isMapped: boolean;
+}
+export interface MetadataReportStatus {
+    /**
+     * Indicates that a report is being generated.
+     */
+    reportGenerationInProgress: boolean;
+    /**
+     * Indicates if a report is available.
+     */
+    reportAvailable: boolean;
+    /**
+     * Indicates if the source has documents sampled.
+     * If false, reports cannot be generated.
+     */
+    sampleAvailable: boolean;
+}

package/dist/definitions/resources/Sources/SourcesMetadata/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SourcesMetadata';
+export * from './SourcesMetadataInterfaces';

package/dist/definitions/resources/Sources/SourcesSubInterfaces/Address.d.ts

@@ -0,0 +1,6 @@
+import { PatternType } from '../../Enums';
+export interface AddressPattern {
+    allowed?: boolean;
+    expression?: string;
+    patternType?: PatternType;
+}

package/dist/definitions/resources/Sources/SourcesSubInterfaces/Authentification.d.ts

@@ -0,0 +1,37 @@
+import { AuthenticationActionMethod, AuthenticationInputType, FormAuthenticationFailedMethod, FormInputType } from '../../Enums';
+export interface FormAuthenticationFailedConfiguration {
+    method: FormAuthenticationFailedMethod;
+    values: string[];
+}
+export interface FormInput {
+    name: string;
+    value?: string;
+    inputType: FormInputType;
+}
+export interface FormAuthenticationConfig {
+    actionMethod?: string;
+    actionUrl?: string;
+    addFoundInputs?: boolean;
+    authenticationFailed?: FormAuthenticationFailedConfiguration;
+    enableJavaScript?: boolean;
+    forceLogin?: boolean;
+    formContentType?: string;
+    formId?: string;
+    formUrl?: string;
+    inputs?: FormInput[];
+    javaScriptLoadingDelayInMilliseconds?: number;
+    customLoginSequence?: any;
+}
+export interface FormAuthenticationInput {
+    name?: string;
+    type?: AuthenticationInputType;
+    value?: string;
+}
+export interface FormAuthentication {
+    actionMethod?: AuthenticationActionMethod;
+    actionURL?: string;
+    formURL?: string;
+    inputs?: FormAuthenticationInput[];
+    reauthenticate?: boolean;
+    secureURL?: string;
+}