@sitecore/sc-contenthub-webclient-sdk 0.9.7

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

@@ -0,0 +1,56 @@
+import { IApiInfo } from "../api/api-info";
+import { ApiRoutesDictionary } from "../api/api-routes-dictionary";
+import { MapStringTo } from "../base-types";
+import Link from "../link";
+import { IExtendedContentHubClient } from "./extended-client";
+/**
+ * Contains functionality to get REST API information.
+ * It will also check for compatibility with the server REST API.
+ */
+export interface IApiClient {
+    /**
+     * Gets or sets whether compatibility checks should be disabled.
+     *
+     * @remarks
+     * The value is shared across all {@link IExtendedContentHubClient} instances.
+     */
+    disableCompatibilityChecks: boolean;
+    /**
+     * Gets the REST API information. The result will be cached.
+     *
+     * @returns The API information.
+     */
+    getApiInfoAsync(): Promise<IApiInfo>;
+    /**
+     * Gets the REST API routes. The result will be cached.
+     *
+     * @returns The REST API routes.
+     */
+    getApiRoutesAsync(): Promise<ApiRoutesDictionary>;
+    /**
+     * Forces a refresh of the cached REST API information.
+     */
+    refreshAsync(): Promise<void>;
+}
+export declare class ApiClient implements IApiClient {
+    private readonly _client;
+    private _api;
+    private static _disableCompatibilityChecks;
+    get disableCompatibilityChecks(): boolean;
+    set disableCompatibilityChecks(value: boolean);
+    constructor(client: IExtendedContentHubClient);
+    getApiInfoAsync(): Promise<IApiInfo>;
+    getApiRoutesAsync(): Promise<MapStringTo<Link>>;
+    refreshAsync(): Promise<void>;
+    /**
+     * Load the REST API information if absent.
+     */
+    private loadAsync;
+    /**
+     * Fetches the API information and checks if the server is running a compatible Content Hub version.
+     *
+     * @returns The API information.
+     */
+    private fetchApiInfoAsync;
+    private static isDebugVersion;
+}

package/dist/clients/api-client.js

@@ -0,0 +1,107 @@
+"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.ApiClient = void 0;
+const string_format_1 = __importDefault(require("string-format"));
+const ta_json_1 = require("ta-json");
+const api_info_resource_1 = require("../api/api-info-resource");
+const api_1 = require("../constants/api");
+const error_messages_1 = __importDefault(require("../error-messages"));
+const not_supported_error_1 = require("../errors/not-supported-error");
+const fileversion_1 = require("../fileversion");
+const guard_1 = __importDefault(require("../guard"));
+const api_resource_mapper_1 = require("../mappers/api-resource-mapper");
+class ApiClient {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client);
+        this._client = client;
+    }
+    get disableCompatibilityChecks() {
+        return ApiClient._disableCompatibilityChecks;
+    }
+    set disableCompatibilityChecks(value) {
+        ApiClient._disableCompatibilityChecks = value;
+    }
+    getApiInfoAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loadAsync();
+            return this._api;
+        });
+    }
+    getApiRoutesAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loadAsync();
+            return this._api.routes;
+        });
+    }
+    refreshAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._api = yield this.fetchApiInfoAsync();
+        });
+    }
+    /**
+     * Load the REST API information if absent.
+     */
+    loadAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._api) {
+                yield this.refreshAsync();
+            }
+        });
+    }
+    /**
+     * Fetches the API information and checks if the server is running a compatible Content Hub version.
+     *
+     * @returns The API information.
+     */
+    fetchApiInfoAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = {};
+            headers[api_1.HEADERS.apiVersion] = "2";
+            const response = yield this._client.raw.getAsync(api_1.API_ROOT, headers);
+            let resource;
+            try {
+                resource = ta_json_1.TaJson.deserialize(response && response.content, api_info_resource_1.ApiInfoResource);
+                if (resource === null ||
+                    resource.fileVersion === null ||
+                    resource.minimumSdkVersion === null ||
+                    resource.routes === null) {
+                    throw 0;
+                }
+            }
+            catch (ex) {
+                throw new not_supported_error_1.NotSupportedError(error_messages_1.default.ContentHubClient.IncompatibleVersionsPre3_0);
+            }
+            const sdkVersion = new fileversion_1.FileVersion(3, 0, 0); //TODO Load this from somewhere
+            const serverVersion = resource.fileVersion;
+            if (!this.disableCompatibilityChecks &&
+                !ApiClient.isDebugVersion(serverVersion) &&
+                !ApiClient.isDebugVersion(sdkVersion)) {
+                if (sdkVersion.smallerThan(resource.minimumSdkVersion)) {
+                    throw new not_supported_error_1.NotSupportedError(string_format_1.default(error_messages_1.default.ContentHubClient.IncompatibleMinimumVersion, sdkVersion, serverVersion, resource.minimumSdkVersion));
+                }
+                if (sdkVersion.major > serverVersion.major ||
+                    (sdkVersion.major === serverVersion.major && sdkVersion.minor > serverVersion.minor)) {
+                    throw new not_supported_error_1.NotSupportedError(string_format_1.default(error_messages_1.default.ContentHubClient.IncompatibleVersion, sdkVersion, serverVersion));
+                }
+            }
+            const apiInfo = api_resource_mapper_1.ApiResourceMapper.map(resource);
+            return apiInfo;
+        });
+    }
+    static isDebugVersion(version) {
+        return version.major <= 1;
+    }
+}
+exports.ApiClient = ApiClient;

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

@@ -0,0 +1,16 @@
+import { IExtendedContentHubClient } from "./extended-client";
+export interface ICommandsClient {
+    /**
+     * Executes a Content Hub command.
+     * @param namespace - The name of the folder containing the command
+     * @param command - The name of the command
+     * @param args - The arguments of the command or null/undefined if the command has no arguments
+     * @returns The result of the command. If the command has no result, null is returned.
+     */
+    executeCommandAsync(namespace: string, command: string, args?: unknown): Promise<unknown>;
+}
+export declare class CommandsClient implements ICommandsClient {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    executeCommandAsync(namespace: string, command: string, args?: unknown): Promise<unknown>;
+}

package/dist/clients/commands-client.js

@@ -0,0 +1,40 @@
+"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.CommandsClient = void 0;
+const ta_json_1 = require("ta-json");
+const guard_1 = __importDefault(require("../guard"));
+const response_handler_1 = require("./response-handler");
+class CommandsClient {
+    constructor(client) {
+        guard_1.default.notNull(client);
+        this._client = client;
+    }
+    executeCommandAsync(namespace, command, args = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(namespace);
+            guard_1.default.stringNotNullOrEmpty(command);
+            const link = yield this._client.linkHelper.commandToLinkAsync(namespace, command);
+            const content = ta_json_1.TaJson.serialize(args !== null && args !== void 0 ? args : {});
+            const response = yield this._client.raw.postAsync(link.href, content);
+            response_handler_1.ResponseHandler.handleErrors(response);
+            let result = null;
+            if (response.content != null) {
+                result = response.content;
+            }
+            return result;
+        });
+    }
+}
+exports.CommandsClient = CommandsClient;

package/dist/clients/content-hub-client.d.ts

@@ -0,0 +1,75 @@
+import URI = require("urijs");
+import OAuthPasswordGrant from "../authentication/oauth-password-grant";
+import OAuthRefreshTokenGrant from "../authentication/oauth-refreshtoken-grant";
+import { Nullable } from "../base-types";
+import { IEntityFactory } from "../factories/entity-factory";
+import { IOptionListFactory } from "../factories/option-list-factory";
+import { IRelationFactory } from "../factories/relation-factory";
+import { ILinkHelper } from "../link-helper";
+import { ILogger } from "../logging/logger";
+import { EntityDefinitionMapper } from "../mappers/entity-definition-mapper";
+import { EntityMapper } from "../mappers/entity-mapper";
+import { IApiClient } from "./api-client";
+import { ICommandsClient } from "./commands-client";
+import { ICultureClient } from "./culture-client";
+import { IEntitiesClient } from "./entities-client";
+import { IEntityDefinitionsClient } from "./entity-definitions-client";
+import { IExtendedContentHubClient } from "./extended-client";
+import { IInternalClient } from "./internal-client";
+import { INotificationsClient } from "./notifications-client";
+import { IOptionListClient } from "./option-list-client";
+import { IPagesClient } from "./pages-client";
+import { IPoliciesClient } from "./policies-client";
+import { IQueryingClient } from "./querying-client";
+import { IRawClient } from "./raw-client";
+import { ISearchClient } from "./search-client";
+import { ISettingsClient } from "./settings-client";
+import { IUsersClient } from "./users-client";
+/**
+ * Client for the Content Hub.
+ */
+export interface IContentHubClient {
+    logger: ILogger;
+    readonly api: IApiClient;
+    readonly commands: ICommandsClient;
+    readonly cultures: ICultureClient;
+    readonly entities: IEntitiesClient;
+    readonly entityDefinitions: IEntityDefinitionsClient;
+    readonly notifications: INotificationsClient;
+    readonly optionLists: IOptionListClient;
+    readonly policies: IPoliciesClient;
+    readonly querying: IQueryingClient;
+    readonly raw: IRawClient;
+    readonly settings: ISettingsClient;
+    readonly users: IUsersClient;
+    readonly pages: IPagesClient;
+    readonly entityFactory: IEntityFactory;
+    readonly optionListFactory: IOptionListFactory;
+}
+export declare class ContentHubClient implements IExtendedContentHubClient {
+    logger: ILogger;
+    baseUri: URI;
+    readonly internalClient: IInternalClient;
+    readonly api: IApiClient;
+    readonly commands: ICommandsClient;
+    readonly cultures: ICultureClient;
+    readonly entities: IEntitiesClient;
+    readonly entityDefinitions: IEntityDefinitionsClient;
+    readonly notifications: INotificationsClient;
+    readonly optionLists: IOptionListClient;
+    readonly policies: IPoliciesClient;
+    readonly querying: IQueryingClient;
+    readonly raw: IRawClient;
+    readonly settings: ISettingsClient;
+    readonly users: IUsersClient;
+    readonly pages: IPagesClient;
+    readonly search: ISearchClient;
+    readonly entityFactory: IEntityFactory;
+    readonly optionListFactory: IOptionListFactory;
+    readonly relationFactory: IRelationFactory;
+    readonly entityMapper: EntityMapper;
+    readonly entityDefinitionMapper: EntityDefinitionMapper;
+    readonly linkHelper: ILinkHelper;
+    impersonatedUsername: Nullable<string>;
+    constructor(baseUri: URI | string, oauthGrant?: OAuthPasswordGrant | OAuthRefreshTokenGrant, logger?: ILogger);
+}

package/dist/clients/content-hub-client.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentHubClient = void 0;
+const entity_factory_1 = require("../factories/entity-factory");
+const option_list_factory_1 = require("../factories/option-list-factory");
+const relation_factory_1 = require("../factories/relation-factory");
+const guard_1 = __importDefault(require("../guard"));
+const link_helper_1 = require("../link-helper");
+const null_logger_1 = __importDefault(require("../logging/null-logger"));
+const entity_definition_mapper_1 = require("../mappers/entity-definition-mapper");
+const entity_mapper_1 = require("../mappers/entity-mapper");
+const typed_entity_creator_1 = require("../mappers/typed-entity-creator");
+const api_client_1 = require("./api-client");
+const commands_client_1 = require("./commands-client");
+const culture_client_1 = require("./culture-client");
+const culture_loader_1 = require("./culture-loader");
+const entities_client_1 = require("./entities-client");
+const entity_definitions_client_1 = require("./entity-definitions-client");
+const internal_client_1 = require("./internal-client");
+const notifications_client_1 = require("./notifications-client");
+const option_list_client_1 = require("./option-list-client");
+const pages_client_1 = require("./pages-client");
+const policies_client_1 = require("./policies-client");
+const querying_client_1 = require("./querying-client");
+const raw_client_1 = require("./raw-client");
+const search_client_1 = require("./search-client");
+const settings_client_1 = require("./settings-client");
+const users_client_1 = require("./users-client");
+class ContentHubClient {
+    constructor(baseUri, oauthGrant, logger = new null_logger_1.default()) {
+        this.impersonatedUsername = null;
+        guard_1.default.notNullOrUndefined(baseUri);
+        guard_1.default.notNull(oauthGrant);
+        const baseUrl = typeof baseUri === "string" ? baseUri : baseUri.href();
+        guard_1.default.stringNotNullOrEmpty(baseUrl);
+        this.logger = logger;
+        this.internalClient = new internal_client_1.InternalClient(baseUri, oauthGrant);
+        this.api = new api_client_1.ApiClient(this);
+        this.commands = new commands_client_1.CommandsClient(this);
+        this.entities = new entities_client_1.EntitiesClient(this);
+        this.entityDefinitions = new entity_definitions_client_1.EntityDefinitionsClient(this);
+        this.notifications = new notifications_client_1.NotificationsClient(this);
+        this.notifications = new notifications_client_1.NotificationsClient(this);
+        this.optionLists = new option_list_client_1.OptionListClient(this);
+        this.pages = new pages_client_1.PagesClient(this);
+        this.policies = new policies_client_1.PoliciesClient(this);
+        this.querying = new querying_client_1.QueryingClient(this);
+        this.raw = new raw_client_1.RawClient(this);
+        this.search = new search_client_1.SearchClient(this);
+        this.settings = new settings_client_1.SettingsClient(this);
+        this.users = new users_client_1.UsersClient(this);
+        const cultureLoader = new culture_loader_1.CultureLoader(this);
+        this.cultures = new culture_client_1.CultureClient(cultureLoader);
+        this.relationFactory = new relation_factory_1.RelationFactory(this);
+        const typedEntityCreator = new typed_entity_creator_1.TypedEntityCreator(this);
+        this.entityFactory = new entity_factory_1.EntityFactory(this, this.relationFactory, cultureLoader, typedEntityCreator);
+        this.optionListFactory = new option_list_factory_1.OptionListFactory();
+        this.entityMapper = new entity_mapper_1.EntityMapper(this);
+        this.entityDefinitionMapper = new entity_definition_mapper_1.EntityDefinitionMapper(this);
+        this.linkHelper = new link_helper_1.LinkHelper(this);
+    }
+}
+exports.ContentHubClient = ContentHubClient;

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

@@ -0,0 +1,36 @@
+import { NullableResultPromise } from "../base-types";
+import CultureInfo from "../culture-info";
+import { ICultureLoader } from "./culture-loader";
+/**
+ * Allows fetching culture information.
+ */
+export interface ICultureClient {
+    /**
+     * Gets the default culture.
+     * @returns The default culture.
+     */
+    getDefaultCultureAsync(): NullableResultPromise<CultureInfo>;
+    /**
+     * Gets the cached default culture.
+     * @returns The default culture.
+     */
+    getDefaultCultureCachedAsync(): NullableResultPromise<CultureInfo>;
+    /**
+     * Gets all installed cultures.
+     * @returns All installed cultures.
+     */
+    getAllCulturesAsync(): Promise<Array<CultureInfo>>;
+    /**
+     * Gets all cached installed cultures.
+     * @returns All cached installed cultures.
+     */
+    getAllCulturesCachedAsync(): Promise<Array<CultureInfo>>;
+}
+export declare class CultureClient implements ICultureClient {
+    private readonly _cultureLoader;
+    constructor(cultureLoader: ICultureLoader);
+    getAllCulturesAsync(): Promise<Array<CultureInfo>>;
+    getAllCulturesCachedAsync(): Promise<Array<CultureInfo>>;
+    getDefaultCultureAsync(): NullableResultPromise<CultureInfo>;
+    getDefaultCultureCachedAsync(): NullableResultPromise<CultureInfo>;
+}

package/dist/clients/culture-client.js

@@ -0,0 +1,43 @@
+"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.CultureClient = void 0;
+const guard_1 = __importDefault(require("../guard"));
+class CultureClient {
+    constructor(cultureLoader) {
+        guard_1.default.notNullOrUndefined(cultureLoader);
+        this._cultureLoader = cultureLoader;
+    }
+    getAllCulturesAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._cultureLoader.getAllCulturesAsync();
+        });
+    }
+    getAllCulturesCachedAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._cultureLoader.getAllCulturesCachedAsync();
+        });
+    }
+    getDefaultCultureAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._cultureLoader.getDefaultCultureAsync();
+        });
+    }
+    getDefaultCultureCachedAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._cultureLoader.getDefaultCultureCachedAsync();
+        });
+    }
+}
+exports.CultureClient = CultureClient;

package/dist/clients/culture-loader.d.ts

@@ -0,0 +1,41 @@
+import { NullableResultPromise } from "../base-types";
+import CultureInfo from "../culture-info";
+import { IExtendedContentHubClient } from "./extended-client";
+/**
+ * Allows fetching culture information.
+ */
+export interface ICultureLoader {
+    /**
+     * Gets the default culture.
+     * @returns The default culture.
+     */
+    getDefaultCultureAsync(): NullableResultPromise<CultureInfo>;
+    /**
+     * Gets the default culture (cached).
+     * @returns The default cached culture.
+     */
+    getDefaultCultureCachedAsync(): NullableResultPromise<CultureInfo>;
+    /**
+     * Gets all installed cultures (cached).
+     * @returns All cached cultures.
+     */
+    getAllCulturesCachedAsync(): Promise<Array<CultureInfo>>;
+    /**
+     * Gets all installed cultures.
+     * @returns All cultures.
+     */
+    getAllCulturesAsync(): Promise<Array<CultureInfo>>;
+}
+export declare class CultureLoader implements ICultureLoader {
+    private readonly _client;
+    private readonly _cultureCache;
+    private static readonly _loadConfig;
+    private static readonly _query;
+    constructor(client: IExtendedContentHubClient);
+    getDefaultCultureAsync(): NullableResultPromise<CultureInfo>;
+    getDefaultCultureCachedAsync(): NullableResultPromise<CultureInfo>;
+    getAllCulturesAsync(): Promise<Array<CultureInfo>>;
+    getAllCulturesCachedAsync(): Promise<Array<CultureInfo>>;
+    private queryCultureAsync;
+    private static extractDefaultCulture;
+}

package/dist/clients/culture-loader.js

@@ -0,0 +1,103 @@
+"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.CultureLoader = void 0;
+const culture_cache_1 = require("../caches/culture-cache");
+const constants_1 = require("../constants");
+const culture_load_option_1 = require("../contracts/querying/culture-load-option");
+const entity_load_configuration_1 = require("../contracts/querying/entity-load-configuration");
+const filters_1 = require("../contracts/querying/filters");
+const member_load_option_1 = require("../contracts/querying/member-load-option");
+const property_load_option_1 = require("../contracts/querying/property-load-option");
+const query_1 = require("../contracts/querying/query");
+const relation_load_option_1 = require("../contracts/querying/relation-load-option");
+const error_messages_1 = __importDefault(require("../error-messages"));
+const internal_error_1 = require("../errors/internal-error");
+const guard_1 = __importDefault(require("../guard"));
+class CultureLoader {
+    constructor(client) {
+        guard_1.default.notNull(client);
+        this._client = client;
+        this._cultureCache = new culture_cache_1.CultureCache();
+    }
+    getDefaultCultureAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cultures = yield this.getAllCulturesAsync();
+            return CultureLoader.extractDefaultCulture(cultures);
+        });
+    }
+    getDefaultCultureCachedAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cultures = yield this.getAllCulturesCachedAsync();
+            return CultureLoader.extractDefaultCulture(cultures);
+        });
+    }
+    getAllCulturesAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cultures = yield this.queryCultureAsync();
+            this._cultureCache.loadCache(cultures);
+            return cultures;
+        });
+    }
+    getAllCulturesCachedAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let cultures = this._cultureCache.getCachedCultures();
+            if (cultures == null) {
+                cultures = yield this.getAllCulturesAsync();
+            }
+            return cultures;
+        });
+    }
+    //#region Private methods
+    queryCultureAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._client.querying.singleAsync(CultureLoader._query, CultureLoader._loadConfig);
+            if (result == null) {
+                throw new internal_error_1.InternalError(error_messages_1.default.CultureLoader.CouldNotFindCultures);
+            }
+            const token = yield result.getPropertyValueAsync(constants_1.DEFINITIONS["Setting"].value, member_load_option_1.MemberLoadOption.LazyLoading);
+            if (token == null) {
+                throw new internal_error_1.InternalError(error_messages_1.default.CultureLoader.CouldNotFindCultures);
+            }
+            const cultures = token instanceof Array ? token : typeof token === "string" ? JSON.parse(token) : [];
+            return cultures;
+        });
+    }
+    static extractDefaultCulture(cultures) {
+        if (cultures == null || cultures.length === 0) {
+            return null;
+        }
+        return cultures[0];
+    }
+}
+exports.CultureLoader = CultureLoader;
+CultureLoader._loadConfig = new entity_load_configuration_1.EntityLoadConfiguration(culture_load_option_1.CultureLoadOption.None, new property_load_option_1.PropertyLoadOption(constants_1.DEFINITIONS["Setting"].value), relation_load_option_1.RelationLoadOption.None);
+CultureLoader._query = new query_1.Query({
+    filter: new filters_1.CompositeQueryFilter({
+        combineMethod: filters_1.CompositeFilterOperator.And,
+        children: [
+            new filters_1.DefinitionQueryFilter({
+                name: constants_1.DEFINITIONS["Setting"].definitionName,
+                operator: filters_1.ComparisonOperator.Equals,
+            }),
+            new filters_1.PropertyQueryFilter({
+                operator: filters_1.ComparisonOperator.Equals,
+                dataType: filters_1.FilterDataType.String,
+                property: constants_1.DEFINITIONS["Setting"].name,
+                value: constants_1.DEFINITIONS["Setting"].CultureSetting.name,
+            }),
+        ],
+    }),
+    take: 1,
+});