@coveo/platform-client 35.0.0

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

@@ -0,0 +1,60 @@
+import API from '../../APICore';
+import Ressource from '../Resource';
+import { New } from '../BaseInterfaces';
+import { SchemaEntities, SchemaServiceQueryParams, SchemaServiceSource, CreateSchemaSourceModel, CreateSchemaSourceOptions, ObjectsToGet, SchemaEntityFields, SimpleSchemaEntity, GetEntitiesQueryParams, GetEntityQueryParams } from './SchemaServiceInterfaces';
+import { SourceType } from '../Enums';
+export default class SchemaService extends Ressource {
+    protected api: API;
+    protected serverlessApi: API;
+    static baseUrl: string;
+    constructor(api: API, serverlessApi: API);
+    /**
+     * Retrieve entities from the targeted instance
+     * (can be matches of a given query)
+     *
+     * @param {SourceType} sourceType
+     * @param {GetEntitiesQueryParams} [parameters]
+     * @return {SchemaEntities} schemaEntities
+     * @memberof SchemaService
+     */
+    getEntities(sourceType: SourceType, parameters?: GetEntitiesQueryParams): Promise<SchemaEntities>;
+    /**
+     * Retrieve the entity of matching ID from the targeted instance
+     *
+     * @param {SourceType} sourceType
+     * @param {string} entityId
+     * @param {GetEntityQueryParams} [parameters]
+     * @return {SimpleSchemaEntity} simpleSchemaEntity
+     * @memberof SchemaService
+     */
+    getEntity(sourceType: SourceType, entityId: string, parameters?: GetEntityQueryParams): Promise<SimpleSchemaEntity>;
+    /**
+     * Retrieve the fields of the given entity from the targeted instance
+     *
+     * @param {SourceType} sourceType
+     * @param {string} entityId
+     * @param {SchemaServiceQueryParams} [parameters]
+     * @return {SchemaEntityFields} schemaEntityFields
+     * @memberof SchemaService
+     */
+    getFields(sourceType: SourceType, entityId: string, parameters?: SchemaServiceQueryParams): Promise<SchemaEntityFields>;
+    delete(sourceId: string): Promise<Record<string, unknown>>;
+    get(sourceId: string): Promise<SchemaServiceSource>;
+    update(sourceId: string, source: CreateSchemaSourceModel, options?: CreateSchemaSourceOptions): Promise<{
+        id: string;
+    }>;
+    create(source: New<CreateSchemaSourceModel, 'resourceId'>, options?: CreateSchemaSourceOptions): Promise<{
+        id: string;
+    }>;
+    translateToSpecificObjectsToGet(sourceType: SourceType, genericObjectsToGet: ObjectsToGet): Promise<any>;
+    translateToSpecificObjectsToGetWithFields(sourceType: SourceType, genericObjectsToGet: ObjectsToGet, parameters?: SchemaServiceQueryParams): Promise<any>;
+    translateToGenericObjectsToGet(sourceType: SourceType, specificObjectsToGet: any): Promise<ObjectsToGet>;
+    /**
+     * Retrieve the default objectsToGet of the given sourceType
+     *
+     * @param {string} sourceType
+     * @return {ObjectsToGet} ObjectsToGet
+     * @memberof SchemaService
+     */
+    getDefaultObjectsToGet(sourceType: string): Promise<ObjectsToGet>;
+}

package/dist/definitions/resources/SchemaService/SchemaServiceInterfaces.d.ts

@@ -0,0 +1,155 @@
+import { SourceModel, CreateSourceModel, CreateSourceOptions } from '../Sources/SourcesInterfaces';
+export interface SimpleSchemaEntity {
+    /**
+     * The id of the entity
+     * (equivalent to ServiceNow Name column)
+     */
+    id: string;
+    /**
+     * The name to be displayed of the entity
+     * (equivalent to ServiceNow Label column)
+     */
+    displayName: string;
+    /**
+     * The number of records that this entity represents
+     * This can be based on the filter sent to the schema-service
+     */
+    recordCount?: number;
+}
+export interface SchemaEntities {
+    /**
+     * A Record containing SimpleSchemaEntities, indexed by their id
+     */
+    entities: Record<string, SimpleSchemaEntity>;
+    /**
+     * The number of entities contained in the query ServiceNow instance
+     */
+    entitiesCount?: number;
+}
+export interface SchemaEntityField {
+    /**
+     * The id of the field
+     * (equivalent to the ServiceNow Label column)
+     */
+    id: string;
+    /**
+     * The name to be displayed of the field
+     * (equivalent to ServiceNow Label column)
+     */
+    displayName: string;
+    /**
+     * The Coveo type of the field
+     */
+    type: string;
+    /**
+     * The id of the entity this field references
+     */
+    reference?: string;
+    /**
+     * Marks fields indexed by default by the connector
+     */
+    isAlwaysIndexed?: boolean;
+}
+export interface SchemaEntityFields {
+    /**
+     * A Record containing SchemaEntityFields, indexed by their id
+     */
+    fields: Record<string, SchemaEntityField>;
+    /**
+     * The number of fields contained in the given entity
+     */
+    fieldsCount: number;
+}
+export interface SchemaServiceQueryParams {
+    instanceUrl: string;
+    username?: string;
+    passwordGuid?: string;
+    clientId?: string;
+    clientSecretGuid?: string;
+    oauthRefreshTokenGuid?: string;
+}
+export interface GetEntitiesQueryParams extends SchemaServiceQueryParams {
+    /**
+     * The offset from which to start retrieving entities
+     * (used for server-side pagination)
+     */
+    offset?: number;
+    /**
+     * The number of entities to fetch
+     * (used for server-side pagination)
+     */
+    limit?: number;
+    /**
+     * A query to fetch matching entity names and ids
+     */
+    query?: string;
+    /**
+     * IDs of the entities to retrieve, as a comma-separated list
+     */
+    entityIds?: string;
+}
+export interface GetEntityQueryParams extends SchemaServiceQueryParams {
+    /**
+     * A filter used to fetch the correct amount of records
+     */
+    filter?: string;
+}
+/**
+ * The object fields to be indexed
+ */
+export interface GenericObjectField {
+    name?: string;
+}
+/**
+ * The fields from other objects that have a junction relation to this one
+ */
+export interface GenericObjectRelation {
+    name?: string;
+    fields?: string[];
+    fromField?: string;
+    toField?: string;
+    toObject?: string;
+}
+/**
+ * The conditions that must be satisfied in order for the object to be indexed
+ */
+export interface GenericObjectCondition {
+    field?: string;
+    operator?: string;
+    type?: string;
+    values?: string[];
+}
+/**
+ * The generic format for a source's entity/object/table
+ */
+export interface GenericObject {
+    name?: string;
+    conditions?: GenericObjectCondition[];
+    fields?: GenericObjectField[];
+    relations?: GenericObjectRelation[];
+    /**
+     * The attachment field name
+     */
+    attachment?: string;
+    /**
+     * The filter applied to the records of the object
+     */
+    filter?: string;
+}
+export interface ObjectsToGet {
+    /**
+     * The list of objects/entities/tables to be indexed
+     */
+    objects?: GenericObject[];
+}
+export interface SchemaServiceSource extends SourceModel {
+    objectsToGet?: ObjectsToGet;
+}
+export interface CreateSchemaSourceModel extends CreateSourceModel {
+    /**
+     * A stringified version of the objectsToGet of a source
+     */
+    objectsToGetConfiguration?: string;
+}
+export interface CreateSchemaSourceOptions extends CreateSourceOptions {
+}

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

@@ -0,0 +1,2 @@
+export * from './SchemaService';
+export * from './SchemaServiceInterfaces';

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

@@ -0,0 +1,10 @@
+import { ListFieldValuesBodyQueryParams, PostSearchQuerySuggestBodyParams } from '.';
+import Ressource from '../Resource';
+import { RestQueryParams, RestTokenParams, TokenModel } from './SearchInterfaces';
+export default class Search extends Ressource {
+    static baseUrl: string;
+    createToken(tokenParams: RestTokenParams): Promise<TokenModel>;
+    getFieldValues(fieldName: string, params?: ListFieldValuesBodyQueryParams): Promise<any>;
+    query(restQueryParameters: RestQueryParams & any): Promise<any>;
+    querySuggestPost(restQuerySuggestParameters: PostSearchQuerySuggestBodyParams): Promise<any>;
+}