@sitecore/sc-contenthub-webclient-sdk 0.9.7

package/dist/clients/entities-client.d.ts

@@ -0,0 +1,201 @@
+import { Nullable, NullableResultPromise } from "../base-types";
+import { IEntity } from "../contracts/base/entity";
+import { IEntityIterator } from "../contracts/querying/entity-iterator";
+import { IEntityLoadConfiguration } from "../contracts/querying/entity-load-configuration";
+import { IEntityQueryResult } from "../contracts/querying/entity-query-result";
+import { IIdIterator } from "../contracts/querying/id-iterator";
+import { IIdQueryResult } from "../contracts/querying/id-query-result";
+import { Sorting } from "../contracts/querying/sorting";
+import { IExtendedContentHubClient } from "./extended-client";
+/**
+ * Interface for the client responsible for getting, saving and deleting entities.
+ *
+ * @remarks
+ * When possible, always include the specific properties and relations that are required when fetching entities.
+ */
+export interface IEntitiesClient {
+    /**
+     * Gets the {@link IEntity} instance with the specified `id`.
+     * @param id - The id of the entity to get
+     * @param loadConfiguration - The loading configuration for the entity
+     * @returns The entity or `null` when it was not found.
+     */
+    getAsync(id: number, loadConfiguration?: Nullable<IEntityLoadConfiguration>): NullableResultPromise<IEntity>;
+    /**
+     * Gets the {@link IEntity} instance with the specified `identifier`.
+     * @param identifier - The identifier of the entity to get
+     * @param loadConfiguration - The loading configuration for the entity
+     * @returns The entity or `null` when it was not found.
+     */
+    getAsync(identifier: string, loadConfiguration?: Nullable<IEntityLoadConfiguration>): NullableResultPromise<IEntity>;
+    /**
+     * Gets the {@link IEntity} instance with the specified `id` or `identifier`.
+     * @param param - The id or identifier of the entity to get
+     * @param loadConfiguration - The loading configuration for the entity
+     * @returns The entity or `null` when it was not found.
+     */
+    getAsync(param: number | string, loadConfiguration?: Nullable<IEntityLoadConfiguration>): NullableResultPromise<IEntity>;
+    /**
+     * Gets the {@link IEntity} instances with the specified `ids`.
+     *
+     * @remarks
+     * The returned list of entities can be empty or contain fewer items than the list of ids.
+     * The order of the entities in the returned list can be different than the order of the requested ids.
+     *
+     * @param ids - The ids of the entities to get
+     * @param loadConfiguration - The loading configuration for an entity
+     * @returns List of entities.
+     */
+    getManyAsync(ids: Array<number>, loadConfiguration?: Nullable<IEntityLoadConfiguration>): Promise<Array<IEntity>>;
+    /**
+     * Gets the {@link IEntity} instances with the specified `identifiers`.
+     *
+     * @remarks
+     * The returned list of entities can be empty or contain fewer items than the list of identifiers.
+     * The order of the entities in the returned list can be different than the order of the requested identifiers.
+     *
+     * @param identifiers - The identifiers of the entities to get
+     * @param loadConfiguration - The loading configuration for an entity
+     * @returns List of entities.
+     */
+    getManyAsync(identifiers: Array<string>, loadConfiguration?: Nullable<IEntityLoadConfiguration>): Promise<Array<IEntity>>;
+    /**
+     * Gets the {@link IEntity} instances with the specified `ids` or `identifiers`.
+     *
+     * @remarks
+     * The returned list of entities can be empty or contain fewer items than the list of identifiers.
+     * The order of the entities in the returned list can be different than the order of the requested identifiers.
+     *
+     * @param param - The ids or identifiers of the entities to get
+     * @param loadConfiguration - The loading configuration for an entity
+     * @returns List of entities.
+     */
+    getManyAsync(param: Array<number> | Array<string>, loadConfiguration?: Nullable<IEntityLoadConfiguration>): Promise<Array<IEntity>>;
+    /**
+     * Queries the {@link IEntity} instances for the specified `definitionName`.
+     *
+     * @param definitionName - The name of the definition to get entities for (case insensitive)
+     * @param loadConfiguration - The loading configuration for an entity
+     * @param skip - Skip the specified number of entities (optional)
+     * @param take - Take only the specified number of entities (optional, default: {@link ENTITIES.take})
+     * @param sorting - Sorting options
+     * @returns List of entities.
+     */
+    getByDefinitionAsync(definitionName: string, loadConfiguration?: Nullable<IEntityLoadConfiguration>, skip?: number, take?: number, sorting?: Array<Sorting>): Promise<IEntityQueryResult>;
+    /**
+     * Queries the {@link IEntity} ids for the specified `definitionName`.
+     *
+     * @param definitionName - The name of the definition to get entity ids for (case insensitive)
+     * @param skip - Skip the specified number of entities (optional)
+     * @param take - Take only the specified number of entities (optional, default: {@link ENTITIES.take})
+     * @returns List of entity ids.
+     */
+    getIdsByDefinitionAsync(definitionName: string, skip?: number, take?: number): Promise<IIdQueryResult>;
+    /**
+     * Creates an {@link IEntityIterator} instance for the specified definition that returns instances.
+     * Results are sorted ascending on creation date.
+     *
+     * @param definition - The name of the definition to get entities for
+     * @param loadConfiguration - Load configuration
+     * @returns The iterator.
+     */
+    getEntityIterator(definition: string, loadConfiguration?: Nullable<IEntityLoadConfiguration>): IEntityIterator;
+    /**
+     * Creates an {@link IIdIterator} instance for the specified definition that returns instances.
+     * Results are sorted ascending on creation date.
+     *
+     * @param definition - The name of the definition to get entity ids for
+     * @returns The iterator.
+     */
+    getEntityIdIterator(definition: string): IIdIterator;
+    /**
+     * Save the specified {@link IEntity}.
+     *
+     * @remarks
+     * The existing {@link IEntity} will not be updated in any way.
+     * If any information is needed that was generated on the server after persisting, the entity will need to be
+     * fetched again.
+     *
+     * @param entity - Entity to save
+     * @returns The id of the entity.
+     */
+    saveAsync(entity: IEntity): Promise<number>;
+    /**
+     * Deletes the {@link IEntity} with specified id.
+     *
+     * @param entityId - The id of the entity to delete
+     */
+    deleteAsync(entityId: number): Promise<void>;
+}
+/**
+ * The client responsible for getting, saving and deleting entities.
+ */
+export declare class EntitiesClient implements IEntitiesClient {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    /**
+     * Gets the {@link IEntity} instance with the specified `id` or `identifier`.
+     * @param param - The id or identifier of the entity to get
+     * @param loadConfiguration - The loading configuration for the entity
+     * @returns The entity or `null` when it was not found.
+     */
+    getAsync(param: string | number, loadConfiguration?: Nullable<IEntityLoadConfiguration>): NullableResultPromise<IEntity>;
+    /**
+     * Gets the {@link IEntity} instances with the specified `ids` or `identifiers`.
+     *
+     * @remarks
+     * The returned list of entities can be empty or contain fewer items than the list of identifiers.
+     * The order of the entities in the returned list can be different than the order of the requested identifiers.
+     *
+     * @param param - The ids or identifiers of the entities to get
+     * @param loadConfiguration - The loading configuration for an entity
+     * @returns List of entities.
+     */
+    getManyAsync(param: Array<number> | Array<string>, loadConfiguration?: Nullable<IEntityLoadConfiguration>): Promise<Array<IEntity>>;
+    /**
+     * {@inheritDoc}
+     */
+    getByDefinitionAsync(definitionName: string, loadConfiguration?: Nullable<IEntityLoadConfiguration>, skip?: number, take?: number, sorting?: Array<Sorting>): Promise<IEntityQueryResult>;
+    /**
+     * {@inheritDoc}
+     */
+    getIdsByDefinitionAsync(definitionName: string, skip?: number, take?: number): Promise<IIdQueryResult>;
+    /**
+     * {@inheritDoc}
+     */
+    getEntityIterator(definition: string, loadConfiguration?: Nullable<IEntityLoadConfiguration>): IEntityIterator;
+    /**
+     * {@inheritDoc}
+     */
+    getEntityIdIterator(definition: string): IIdIterator;
+    /**
+     * {@inheritDoc}
+     */
+    saveAsync(entity: IEntity): Promise<number>;
+    /**
+     * {@inheritDoc}
+     */
+    deleteAsync(entityId: number): Promise<void>;
+    /**
+     * Creates the specified {@link IEntity} in the system.
+     *
+     * @param entity - The entity to create/save in the system
+     */
+    private createEntityAsync;
+    /**
+     * Update the specified {@link IEntity}.
+     *
+     * @param entity - The entity to update
+     */
+    private updateEntityAsync;
+    /**
+     * Get an {@link IEntity} or `null` from the specified {@link IEntityQueryResult}.
+     *
+     * @remarks
+     * Throws an {@link InternalError} if multiple results where available.
+     *
+     * @param queryResult - The query result (should contain one or no items)
+     * @returns An {@link IEntity} or `null`.
+     */
+    private static single;
+}

package/dist/clients/entities-client.js

@@ -0,0 +1,271 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitiesClient = void 0;
+const ta_json_1 = require("ta-json");
+const api_1 = require("../constants/api");
+const defaults_1 = require("../constants/defaults");
+const entity_iterator_1 = require("../contracts/querying/entity-iterator");
+const entity_load_configuration_1 = require("../contracts/querying/entity-load-configuration");
+const filters_1 = require("../contracts/querying/filters");
+const id_iterator_1 = require("../contracts/querying/id-iterator");
+const query_1 = require("../contracts/querying/query");
+const error_messages_1 = __importDefault(require("../error-messages"));
+const internal_error_1 = require("../errors/internal-error");
+const web_api_error_1 = require("../errors/web-api-error");
+const guard_1 = __importDefault(require("../guard"));
+const link_1 = __importDefault(require("../link"));
+const type_guards_1 = require("../type-guards");
+const response_handler_1 = require("./response-handler");
+/**
+ * The client responsible for getting, saving and deleting entities.
+ */
+class EntitiesClient {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client);
+        this._client = client;
+    }
+    /**
+     * Gets the {@link IEntity} instance with the specified `id` or `identifier`.
+     * @param param - The id or identifier of the entity to get
+     * @param loadConfiguration - The loading configuration for the entity
+     * @returns The entity or `null` when it was not found.
+     */
+    getAsync(param, loadConfiguration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let query;
+            if (typeof param === "string") {
+                guard_1.default.stringNotNullOrEmpty(param);
+                query = new query_1.Query({
+                    filter: new filters_1.IdentifierQueryFilter({
+                        operator: filters_1.ComparisonOperator.Equals,
+                        value: param,
+                    }),
+                });
+            }
+            else {
+                guard_1.default.validId(param);
+                query = new query_1.Query({
+                    filter: new filters_1.IdQueryFilter({
+                        operator: filters_1.ComparisonOperator.Equals,
+                        value: param,
+                    }),
+                });
+            }
+            const result = yield this._client.querying.queryAsync(query, loadConfiguration || null);
+            const entity = EntitiesClient.single(result);
+            return entity;
+        });
+    }
+    /**
+     * Gets the {@link IEntity} instances with the specified `ids` or `identifiers`.
+     *
+     * @remarks
+     * The returned list of entities can be empty or contain fewer items than the list of identifiers.
+     * The order of the entities in the returned list can be different than the order of the requested identifiers.
+     *
+     * @param param - The ids or identifiers of the entities to get
+     * @param loadConfiguration - The loading configuration for an entity
+     * @returns List of entities.
+     */
+    getManyAsync(param, loadConfiguration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (param == null || param.length === 0)
+                return [];
+            let query;
+            if (type_guards_1.TypeGuards.isStringArray(param)) {
+                const identifiers = param;
+                guard_1.default.arrayNoneNullOrEmptyString(identifiers);
+                query = new query_1.Query({
+                    filter: new filters_1.IdentifierQueryFilter({
+                        operator: filters_1.ComparisonOperator.Equals,
+                        values: identifiers,
+                    }),
+                });
+            }
+            else {
+                const ids = param;
+                guard_1.default.arrayNoneNullOrUndefined(ids);
+                guard_1.default.validIds(ids);
+                query = new query_1.Query({
+                    filter: new filters_1.IdQueryFilter({
+                        operator: filters_1.ComparisonOperator.Equals,
+                        values: ids,
+                    }),
+                });
+            }
+            const result = yield this._client.querying.queryAsync(query, loadConfiguration || null);
+            return result.items;
+        });
+    }
+    /**
+     * {@inheritDoc}
+     */
+    getByDefinitionAsync(definitionName, loadConfiguration, skip = defaults_1.ENTITIES.skip, take = defaults_1.ENTITIES.take, sorting) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(definitionName);
+            guard_1.default.notNegative(skip);
+            guard_1.default.notNegative(take);
+            const query = new query_1.Query({
+                filter: new filters_1.DefinitionQueryFilter({
+                    name: definitionName,
+                    operator: filters_1.ComparisonOperator.Equals,
+                }),
+                skip: skip,
+                take: take,
+                sorting: sorting,
+            });
+            return this._client.querying.queryAsync(query, loadConfiguration);
+        });
+    }
+    /**
+     * {@inheritDoc}
+     */
+    getIdsByDefinitionAsync(definitionName, skip, take) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(definitionName);
+            if (skip != null)
+                guard_1.default.notNegative(skip);
+            if (take != null)
+                guard_1.default.notNegative(take);
+            const query = new query_1.Query({
+                filter: new filters_1.DefinitionQueryFilter({
+                    name: definitionName,
+                    operator: filters_1.ComparisonOperator.Equals,
+                }),
+                skip: skip,
+                take: take,
+            });
+            const result = yield this._client.querying.queryIdsAsync(query);
+            return result;
+        });
+    }
+    /**
+     * {@inheritDoc}
+     */
+    getEntityIterator(definition, loadConfiguration) {
+        guard_1.default.stringNotNullOrEmpty(definition);
+        loadConfiguration = loadConfiguration || entity_load_configuration_1.EntityLoadConfiguration.Default;
+        const query = new query_1.Query({
+            filter: new filters_1.DefinitionQueryFilter({
+                name: definition,
+                operator: filters_1.ComparisonOperator.Equals,
+            }),
+        });
+        return new entity_iterator_1.EntityIterator(this._client, query, loadConfiguration);
+    }
+    /**
+     * {@inheritDoc}
+     */
+    getEntityIdIterator(definition) {
+        guard_1.default.stringNotNullOrEmpty(definition);
+        const query = new query_1.Query({
+            filter: new filters_1.DefinitionQueryFilter({
+                name: definition,
+                operator: filters_1.ComparisonOperator.Equals,
+            }),
+        });
+        return new id_iterator_1.EntityIdIterator(this._client, query);
+    }
+    /**
+     * {@inheritDoc}
+     */
+    saveAsync(entity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(entity);
+            let id;
+            if (entity.isNew) {
+                id = yield this.createEntityAsync(entity);
+            }
+            else {
+                yield this.updateEntityAsync(entity);
+                id = entity.id;
+            }
+            entity.markClean();
+            return id;
+        });
+    }
+    /**
+     * {@inheritDoc}
+     */
+    deleteAsync(entityId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(entityId);
+            const link = yield this._client.linkHelper.entityToLinkAsync(entityId);
+            const response = yield this._client.raw.deleteAsync(link.href);
+            response_handler_1.ResponseHandler.handleErrors(response);
+        });
+    }
+    /**
+     * Creates the specified {@link IEntity} in the system.
+     *
+     * @param entity - The entity to create/save in the system
+     */
+    createEntityAsync(entity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const link = yield this._client.linkHelper.entitiesLinkAsync();
+            const resource = yield this._client.entityMapper.toResourceAsync(entity);
+            const response = yield this._client.raw.postAsync(link.href, ta_json_1.TaJson.serialize(resource));
+            response_handler_1.ResponseHandler.handleErrors(response);
+            const href = response.responseHeaders[api_1.HEADERS.location];
+            if (!href) {
+                throw new web_api_error_1.WebApiError(error_messages_1.default.EntitiesClient.UnableToExtractLocationHeaderFromResponse, response.statusCode, response);
+            }
+            const id = yield this._client.linkHelper.idFromEntityAsync(new link_1.default(href));
+            if (id === null || id === 0) {
+                throw new internal_error_1.InternalError(error_messages_1.default.EntitiesClient.UnableToExtractEntityIdFromHeader);
+            }
+            return id;
+        });
+    }
+    /**
+     * Update the specified {@link IEntity}.
+     *
+     * @param entity - The entity to update
+     */
+    updateEntityAsync(entity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check if the entity is loaded in only one culture to improve save performance.
+            let culture = null;
+            if (entity.cultures.length === 1) {
+                culture = entity.cultures[0];
+            }
+            const link = yield this._client.linkHelper.entityToLinkAsync(entity.id, culture !== null && culture !== void 0 ? culture : undefined);
+            const resource = yield this._client.entityMapper.mapDirtiesToResourceAsync(entity);
+            const response = yield this._client.raw.putAsync(link.href, ta_json_1.TaJson.serialize(resource));
+            response_handler_1.ResponseHandler.handleErrors(response);
+        });
+    }
+    /**
+     * Get an {@link IEntity} or `null` from the specified {@link IEntityQueryResult}.
+     *
+     * @remarks
+     * Throws an {@link InternalError} if multiple results where available.
+     *
+     * @param queryResult - The query result (should contain one or no items)
+     * @returns An {@link IEntity} or `null`.
+     */
+    static single(queryResult) {
+        if (queryResult.totalNumberOfResults === 0) {
+            return null;
+        }
+        else if (queryResult.totalNumberOfResults === 1) {
+            return queryResult.items[0];
+        }
+        else {
+            throw new internal_error_1.InternalError(error_messages_1.default.QueryingClient.MultipleResultsWhenOneExpected);
+        }
+    }
+}
+exports.EntitiesClient = EntitiesClient;

package/dist/clients/entity-definitions-client.d.ts

@@ -0,0 +1,87 @@
+import { MapNumberTo, MapStringTo, NullableResultPromise } from "../base-types";
+import { IEntityDefinition } from "../contracts/base/entity-definition";
+import { IEntityDefinitionIterator } from "../contracts/querying/entity-definition-iterator";
+import { IEntityDefinitionQueryResult } from "../contracts/querying/entity-definition-query-result";
+import { IIdIterator } from "../contracts/querying/id-iterator";
+import { IIdQueryResult } from "../contracts/querying/id-query-result";
+import { IExtendedContentHubClient } from "./extended-client";
+export interface IEntityDefinitionsClient {
+    /**
+     * Get the {@link IEntityDefinition} instance by the specified name.
+     * @param name - The name of the definition
+     * @returns Promise which resolves to an {@link IEntityDefinition} or null.
+     */
+    getAsync(name: string): NullableResultPromise<IEntityDefinition>;
+    /**
+     * Get the {@link IEntityDefinition} instance by the specified id.
+     * @param id - The id of the definition
+     * @returns Promise which resolves to an {@link IEntityDefinition} or null.
+     */
+    getAsync(id: number): NullableResultPromise<IEntityDefinition>;
+    /**
+     * Get all the {@link IEntityDefinition}s
+     * @returns Promise which resolved to an array of {@link IEntityDefinition}s.
+     */
+    getAllAsync(): Promise<Array<IEntityDefinition>>;
+    /**
+     * Get all the {@link IEntityDefinition}s (cached).
+     * @returns Promise which resolved to an array of {@link IEntityDefinition}s.
+     */
+    getAllCachedAsync(): Promise<Array<IEntityDefinition>>;
+    /**
+     * Get the cached {@link IEntityDefinition} instance by the specified name.
+     * @param name - The name of the definition
+     * @returns Promise which resolves to an {@link IEntityDefinition} or null.
+     */
+    getCachedAsync(name: string): NullableResultPromise<IEntityDefinition>;
+    getCachedAsync(id: number): NullableResultPromise<IEntityDefinition>;
+    getNameAsync(id: number): NullableResultPromise<string>;
+    getNameCachedAsync(id: number): NullableResultPromise<string>;
+    getIdAsync(name: string): NullableResultPromise<number>;
+    getIdCachedAsync(name: string): NullableResultPromise<number>;
+    getManyAsync(names: Array<string>): Promise<Array<IEntityDefinition>>;
+    getManyAsync(ids: Array<number>): Promise<Array<IEntityDefinition>>;
+    getManyCachedAsync(names: Array<string>): Promise<Array<IEntityDefinition>>;
+    getManyCachedAsync(ids: Array<number>): Promise<Array<IEntityDefinition>>;
+    getNamesAsync(ids: Array<number>): Promise<MapNumberTo<string>>;
+    getNamesCachedAsync(ids: Array<number>): Promise<MapNumberTo<string>>;
+    getIdsAsync(names: Array<string>): Promise<MapStringTo<number>>;
+    getIdsCachedAsync(names: Array<string>): Promise<MapStringTo<number>>;
+    saveAsync(definition: IEntityDefinition): Promise<number>;
+    deleteAsync(name: string): Promise<void>;
+    deleteAsync(id: number): Promise<void>;
+    getRangeAsync(skip: number, take: number): Promise<IEntityDefinitionQueryResult>;
+    getRangeIdsAsync(skip: number, take: number): Promise<IIdQueryResult>;
+    createEntityDefinitionIterator(pageSize: number): IEntityDefinitionIterator;
+    createEntityDefinitionIdIterator(pageSize: number): IIdIterator;
+}
+export declare class EntityDefinitionsClient implements IEntityDefinitionsClient {
+    private static _batchSize;
+    private readonly _client;
+    private readonly _cache;
+    constructor(client: IExtendedContentHubClient);
+    getAllCachedAsync(): Promise<Array<IEntityDefinition>>;
+    getAllAsync(): Promise<Array<IEntityDefinition>>;
+    getAsync(param: string | number): NullableResultPromise<IEntityDefinition>;
+    getCachedAsync(param: string | number): NullableResultPromise<IEntityDefinition>;
+    getNameAsync(id: number): NullableResultPromise<string>;
+    getNameCachedAsync(id: number): NullableResultPromise<string>;
+    getIdAsync(name: string): NullableResultPromise<number>;
+    getIdCachedAsync(name: string): NullableResultPromise<number>;
+    getManyAsync(param: Array<string> | Array<number>): Promise<Array<IEntityDefinition>>;
+    getManyCachedAsync(param: Array<string> | Array<number>): Promise<Array<IEntityDefinition>>;
+    getNamesAsync(ids: Array<number>): Promise<MapNumberTo<string>>;
+    getNamesCachedAsync(ids: Array<number>): Promise<MapNumberTo<string>>;
+    getIdsAsync(names: Array<string>): Promise<MapStringTo<number>>;
+    getIdsCachedAsync(names: Array<string>): Promise<MapStringTo<number>>;
+    saveAsync(definition: IEntityDefinition): Promise<number>;
+    deleteAsync(param: string | number): Promise<void>;
+    getRangeAsync(skip: number, take: number): Promise<IEntityDefinitionQueryResult>;
+    getRangeIdsAsync(skip: number, take: number): Promise<IIdQueryResult>;
+    createEntityDefinitionIterator(pageSize: number): IEntityDefinitionIterator;
+    createEntityDefinitionIdIterator(pageSize: number): IIdIterator;
+    private getDefinitionsSkipTake;
+    private getDefinitionAsync;
+    private getDefinitionsBatchedAsync;
+    private getAllBatchedAsync;
+}