@nascentdigital/funnel-cms 4.4.4

package/dist/api/PageClient.d.ts

@@ -0,0 +1,264 @@
+import { Language, RequiredBy, Schema } from '@nascentdigital/funnel-core';
+import { Environment, Pagination } from '../models';
+/**
+ * Provides access to (and management of) {@link Page} related models.
+ */
+export interface PageClient {
+    /**
+     * Provides a high-level overview of the available pages for a site.
+     */
+    getOverview(args: PageClient.GetOverview.Args): Promise<PageClient.GetOverview.Result>;
+    /**
+     * Fetches a summary of all page content for a given brand.
+     */
+    getSummaries(args: PageClient.GetSummaries.Args): Promise<PageClient.GetSummaries.Result>;
+    /**
+     * Fetches a summary of all page content for a given brand.
+     */
+    getPreviews(args: PageClient.GetPreviews.Args): Promise<PageClient.GetPreviews.Result>;
+    /**
+     * Searches for pages, returning links to the pages.
+     */
+    search(args: PageClient.Search.Args): Promise<PageClient.Search.Result>;
+    /**
+     * Query page previews with customizable sorting.
+     */
+    query(args: PageClient.Query.Args): Promise<PageClient.Query.Result>;
+    /**
+     * Find pages based on query
+     */
+    find(args: PageClient.Find.Args): Promise<PageClient.Find.Result>;
+    /**
+     * Fetches the details for a specific page, including a group of all related pages (if any) for the same
+     * target (brand, type, region, and optional slug), OR `undefined` if no pages exist for the target.
+     */
+    getGroup(args: PageClient.GetGroup.Args): Promise<PageClient.GetGroup.Result>;
+    /**
+     * Fetches the details for a specific page for a given brand
+     */
+    get(args: PageClient.Get.Args): Promise<PageClient.Get.Result>;
+    /**
+     * Create a new page.
+     */
+    create(args: PageClient.Create.Args): Promise<PageClient.Create.Result>;
+    /**
+     * Duplicate page or page's language
+     */
+    duplicate(args: PageClient.Duplicate.Args): Promise<PageClient.Duplicate.Result>;
+    /**
+     * Updates an existing page.
+     */
+    update(args: PageClient.Update.Args): Promise<PageClient.Update.Result>;
+    /**
+     * Replaces an existing page with a new value - paves over the existing page.
+     */
+    replace(args: PageClient.Replace.Args): Promise<PageClient.Replace.Result>;
+    /**
+     * Touches an existing page - used for migrations to simply load/save a page (also support direct updates to
+     * "published" content).
+     */
+    touch(args: PageClient.Touch.Args): Promise<PageClient.Touch.Result>;
+    /**
+     * Unpublishes a page
+     */
+    unpublish(args: PageClient.Unpublish.Args): Promise<PageClient.Unpublish.Result>;
+    /**
+     * Fetch items that depend on a page
+     */
+    getDependants(args: PageClient.GetDependants.Args): Promise<PageClient.GetDependants.Result>;
+    /**
+     * Fetch items that a page has dependencies on
+     */
+    getDependencies(args: PageClient.GetDependencies.Args): Promise<PageClient.GetDependencies.Result>;
+    /**
+     * Check slug format and availability
+     */
+    validateSlug(args: PageClient.ValidateSlug.Args): Promise<PageClient.ValidateSlug.Result>;
+}
+export declare namespace PageClient {
+    namespace Query {
+        export type Paginated = Base & Criteria & WithPagination;
+        export type By<TCriteria extends Criteria.Key> = Base & RequiredBy<Criteria, TCriteria>;
+        export type PaginatedBy<TCriteria extends Criteria.Key> = By<TCriteria> & WithPagination;
+        export type ByDetails = Omit<By<'brand' | 'region' | 'language'>, 'type'> & {
+            type: Schema.Page.Type;
+        };
+        export type PaginatedByDetails = ByDetails & WithPagination;
+        export type ById = Base & {
+            id: Schema.Page.Id;
+        };
+        export type PaginatedById = ById & WithPagination;
+        export type ByGroupId = Base & {
+            groupId: Schema.Page.GroupId;
+        };
+        export type PaginatedByGroupId = ByGroupId & WithPagination;
+        export type ByBrand = Base & {
+            brand: string;
+        };
+        export type ByBrandAndRegion = ByBrand & {
+            region: string;
+        };
+        export type TagsMatch = 'any' | 'all';
+        type Base = {
+            version: Environment;
+        };
+        type WithPagination = {
+            pagination: Pagination;
+        };
+        export type Criteria = {
+            groupId?: Schema.Page.GroupId;
+            brand?: string;
+            type?: Schema.Page.Type | Schema.Page.Type[];
+            slug?: string;
+            name?: string;
+            language?: Language;
+            region?: string;
+            tags?: Schema.Tag.Data[];
+            tagsMatch?: TagsMatch;
+        };
+        export namespace Criteria {
+            type Key = keyof Criteria;
+        }
+        export {};
+    }
+    type Update = {
+        id: Schema.Page.Id;
+        slug?: string;
+        publication?: number | null;
+        errors: boolean;
+        updates: ReadonlyArray<Schema.Page.Update>;
+    };
+    namespace GetOverview {
+        type Args = Query.ByBrandAndRegion;
+        type Result = {
+            static: StaticPage[];
+            dynamic: DynamicPage[];
+        };
+        type StaticPage = {
+            type: Schema.Page.Type;
+            refs: Record<Language, Schema.Page.Data.AsLink>;
+        };
+        type DynamicPage = {
+            type: Schema.Page.Type;
+            count: number;
+        };
+    }
+    namespace GetSummaries {
+        type Args = Query.By<'brand'> & {
+            ids?: Schema.Page.Id[];
+        };
+        type Result = Schema.Page.Data.AsLink[];
+    }
+    namespace GetPreviews {
+        type Args = Query.PaginatedBy<'brand' | 'type'>;
+        type Result = Pagination.Paginated<Schema.Page.Data.AsPreview>;
+    }
+    namespace Search {
+        type Args = Query.Paginated;
+        type Result = Pagination.Paginated<Schema.Page.Data.AsLink>;
+    }
+    namespace Query {
+        type Args = Query.PaginatedBy<'brand' | 'region' | 'language'> & {
+            sort?: Schema.PageQuery.Sort;
+            excludeIds?: Schema.Page.Id[];
+        };
+        type Result = Pagination.Paginated<Schema.Page.Data.AsPreview>;
+    }
+    namespace Find {
+        type Args = Query.Paginated;
+        type Result = Pagination.Paginated<Schema.Page.Data>;
+    }
+    namespace GetGroup {
+        type Args = Query.ByDetails;
+        type Result = Schema.Page.Data.AsGroup;
+    }
+    namespace Get {
+        type Args = Query.ById | Query.ByDetails;
+        type Result = Schema.Page.Data | undefined;
+    }
+    namespace Create {
+        type Args = NewArgs | NewLanguageArgs;
+        type NewArgs = Schema.Page.Data.AsNew;
+        type NewLanguageArgs = Schema.Page.Data.AsNewLanguage;
+        type Result = Schema.Page.Data.AsGroup;
+    }
+    namespace Duplicate {
+        type CurrentArgs = {
+            source: Schema.Page.Id;
+            targetPage: 'current';
+            targetLanguage: Language;
+            targetSlug?: string;
+        };
+        type NewArgs = {
+            source: Schema.Page.Id;
+            targetPage: 'new';
+            targetLanguage: Language;
+            targetSlug: string;
+        };
+        type Args = CurrentArgs | NewArgs;
+        type Result = Schema.Page.Data.AsGroup;
+    }
+    namespace Touch {
+        type Args = {
+            id: Schema.Page.Id;
+            version: Environment;
+        };
+        type Result = Schema.Page.Data.AsLink;
+    }
+    namespace Update {
+        type Args = Update;
+        type Result = Schema.Page.Data;
+    }
+    namespace Replace {
+        type Args = {
+            page: Schema.Page.Data;
+            version: Environment;
+            skipSync?: boolean;
+        };
+        type Result = Schema.Page.Data;
+    }
+    namespace Unpublish {
+        type Args = Schema.Page.Id;
+        type Result = boolean;
+    }
+    namespace GetDependants {
+        type Args = {
+            id: Schema.Page.Id;
+            version: Environment;
+        };
+        type Result = {
+            pages: Schema.Page.Data.AsLink[];
+        };
+    }
+    namespace GetDependencies {
+        type Args = {
+            id: Schema.Page.Id;
+            version: Environment;
+        };
+        type Result = {
+            pages: Schema.Page.Data.AsLink[];
+            collections: Schema.Collection.Data.AsLink[];
+        };
+    }
+    namespace ValidateSlug {
+        type Args = {
+            brand: string;
+            type: Schema.Page.Type;
+            region: string;
+            slug: string;
+            groupId?: Schema.Page.GroupId;
+        };
+        type InvalidResult = {
+            status: 'invalid';
+            message: string;
+        };
+        type AvailableResult = {
+            status: 'available';
+        };
+        type UnavailableResult = {
+            status: 'unavailable';
+            takenBy: Schema.Page.Data.AsLink;
+        };
+        type Result = InvalidResult | AvailableResult | UnavailableResult;
+    }
+}

package/dist/api/PageClient.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/SiteClient.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Provides access to (and management of) {@link Site} related models.
+ */
+export interface SiteClient {
+    /**
+     * Fetches the details for a specific Site for a given brand
+     */
+    get(args: SiteClient.Get.Args): Promise<SiteClient.Get.Result>;
+    /**
+     * Updates an existing site.
+     */
+    update(args: SiteClient.Update.Args): Promise<SiteClient.Update.Result>;
+}
+export declare namespace SiteClient {
+    namespace Get {
+        type Args = {};
+        type Result = {};
+    }
+    namespace Get {
+        type Args = {};
+        type Result = {};
+    }
+}

package/dist/api/SiteClient.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/SiteConfigClient.d.ts

@@ -0,0 +1,26 @@
+import { SiteConfig } from '../models';
+/**
+ * Provides access to (and management of) {@link SiteConfigClient} related models.
+ */
+export interface SiteConfigClient {
+    /**
+     * Fetches the details for a specific Site for a given brand
+     */
+    get(args: SiteConfigClient.Get.Args): Promise<SiteConfigClient.Get.Result>;
+    /**
+     * Updates an existing site.
+     */
+    update(args: SiteConfigClient.Update.Args): Promise<SiteConfigClient.Update.Result>;
+}
+export declare namespace SiteConfigClient {
+    namespace Get {
+        type Args = {
+            brand: string;
+        };
+        type Result = SiteConfig.Data;
+    }
+    namespace Update {
+        type Args = SiteConfig.Data.Update;
+        type Result = SiteConfig.Data | undefined;
+    }
+}

package/dist/api/SiteConfigClient.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/UpgradeClient.d.ts

@@ -0,0 +1,16 @@
+import { Upgrade } from '../models';
+/**
+ * Provides management of CMS versioning.
+ */
+export interface UpgradeClient {
+    status(): Promise<Upgrade.Status>;
+    upgrade(): Promise<Upgrade.Status>;
+}
+export declare namespace UpgradeClient {
+    namespace GetStatus {
+        type Result = Upgrade.Status;
+    }
+    namespace ExecuteUpgrade {
+        type Result = Upgrade.Status;
+    }
+}

package/dist/api/UpgradeClient.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/UserClient.d.ts

@@ -0,0 +1,46 @@
+import type { User } from '../models';
+/**
+ * Provides management of {@link User} models
+ */
+export interface UserClient {
+    me(): Promise<UserClient.Me.Result>;
+    getUsers(args?: UserClient.GetUsers.Args): Promise<UserClient.GetUsers.Result>;
+    getUser(args: UserClient.GetUser.Args): Promise<UserClient.GetUser.Result>;
+    createUser(args: UserClient.CreateUser.Args): Promise<UserClient.CreateUser.Result>;
+    updateUser(args: UserClient.UpdateUser.Args): Promise<UserClient.UpdateUser.Result>;
+    resetUser(args: UserClient.ResetUser.Args): Promise<UserClient.ResetUser.Result>;
+    deleteUser(args: UserClient.DeleteUser.Args): Promise<UserClient.DeleteUser.Result>;
+}
+export declare namespace UserClient {
+    namespace Me {
+        type Result = User.Data | undefined;
+    }
+    namespace GetUsers {
+        type Args = {
+            brand?: string;
+        };
+        type Result = User.Data[];
+    }
+    namespace GetUser {
+        type Args = User.Id;
+        type Result = User.Data | undefined;
+    }
+    namespace CreateUser {
+        type Args = User.Data.Create;
+        type Result = User.Data;
+    }
+    namespace UpdateUser {
+        type Args = User.Data.Update;
+        type Result = User.Data;
+    }
+    namespace ResetUser {
+        type Args = {
+            email: string;
+        };
+        type Result = void;
+    }
+    namespace DeleteUser {
+        type Args = User.Id;
+        type Result = boolean;
+    }
+}

package/dist/api/UserClient.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/index.d.ts

@@ -0,0 +1,11 @@
+export * from './AssetClient';
+export * from './AssetUploadClient';
+export * from './AuthClient';
+export * from './ChangeSetClient';
+export * from './CollectionClient';
+export * from './ContentClient';
+export * from './IAssetApiClient';
+export * from './PageClient';
+export * from './SiteConfigClient';
+export * from './UpgradeClient';
+export * from './UserClient';

package/dist/api/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AssetClient"), exports);
+__exportStar(require("./AssetUploadClient"), exports);
+__exportStar(require("./AuthClient"), exports);
+__exportStar(require("./ChangeSetClient"), exports);
+__exportStar(require("./CollectionClient"), exports);
+__exportStar(require("./ContentClient"), exports);
+__exportStar(require("./IAssetApiClient"), exports);
+__exportStar(require("./PageClient"), exports);
+__exportStar(require("./SiteConfigClient"), exports);
+__exportStar(require("./UpgradeClient"), exports);
+__exportStar(require("./UserClient"), exports);

package/dist/errors/CMSError.d.ts

@@ -0,0 +1,8 @@
+import { IsometricError, IsometricErrorModule } from '@nascentdigital/funnel-core';
+export declare class CMSError extends IsometricError {
+    constructor(args: CMSError.ConstructorArgs);
+}
+export declare namespace CMSError {
+    const moduleId: IsometricErrorModule.Id;
+    type ConstructorArgs = IsometricError.ConstructorArgs.WithoutModuleId;
+}

package/dist/errors/CMSError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CMSError = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// class
+class CMSError extends funnel_core_1.IsometricError {
+    constructor(args) {
+        // construct base
+        super(Object.assign(Object.assign({}, args), { moduleId: CMSError.moduleId }));
+    }
+}
+exports.CMSError = CMSError;
+// extension
+(function (CMSError) {
+    // constants
+    CMSError.moduleId = 'cms';
+})(CMSError || (exports.CMSError = CMSError = {}));

package/dist/errors/CMSErrors.d.ts

@@ -0,0 +1,5 @@
+import { IsometricError, IsometricErrorModule, SerializedIsometricError } from '@nascentdigital/funnel-core';
+export declare class CMSErrors implements IsometricErrorModule {
+    readonly id: IsometricErrorModule.Id;
+    deserialize(data: SerializedIsometricError): IsometricError | undefined;
+}

package/dist/errors/CMSErrors.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CMSErrors = void 0;
+const CMSError_1 = require("./CMSError");
+const LinkedDependantsError_1 = require("./LinkedDependantsError");
+const LockdownError_1 = require("./LockdownError");
+const SlugValidationError_1 = require("./SlugValidationError");
+const TranslateReferencesError_1 = require("./TranslateReferencesError");
+// module
+class CMSErrors {
+    constructor() {
+        this.id = CMSError_1.CMSError.moduleId;
+    }
+    deserialize(data) {
+        // skip if module doesn't match
+        if (data.moduleId !== this.id) {
+            return undefined;
+        }
+        // convert
+        switch (data.name) {
+            // re-hydrate error
+            case LinkedDependantsError_1.LinkedDependantsError.name:
+                return new LinkedDependantsError_1.LinkedDependantsError(data);
+            case LockdownError_1.LockdownError.name:
+                return new LockdownError_1.LockdownError(data);
+            case TranslateReferencesError_1.TranslateReferencesError.name:
+                return new TranslateReferencesError_1.TranslateReferencesError(data);
+            case SlugValidationError_1.SlugValidationError.name:
+                return new SlugValidationError_1.SlugValidationError(data);
+            // or ignore if not matching
+            default:
+                return undefined;
+        }
+    }
+}
+exports.CMSErrors = CMSErrors;

package/dist/errors/LinkedDependantsError.d.ts

@@ -0,0 +1,21 @@
+import { Schema, SerializedIsometricError } from '@nascentdigital/funnel-core';
+import type { PageClient } from '../api';
+import { CMSError } from './CMSError';
+export declare class LinkedDependantsError extends CMSError {
+    readonly pages: ReadonlyArray<Schema.Page.Data.AsLink>;
+    readonly collections: ReadonlyArray<Schema.Collection.Data.AsLink>;
+    constructor({ message, pages, collections, ...args }: LinkedDependantsError.ConstructorArgs);
+    serialize(): LinkedDependantsError.Serialized;
+}
+export declare namespace LinkedDependantsError {
+    type Reason = PageClient.ValidateSlug.InvalidResult | PageClient.ValidateSlug.UnavailableResult;
+    type ConstructorArgs = Omit<CMSError.ConstructorArgs, 'message'> & {
+        message?: string;
+        pages?: ReadonlyArray<Schema.Page.Data.AsLink>;
+        collections?: ReadonlyArray<Schema.Collection.Data.AsLink>;
+    };
+    type Serialized = SerializedIsometricError & {
+        pages: Schema.Page.Data.AsLink[];
+        collections: Schema.Collection.Data.AsLink[];
+    };
+}

package/dist/errors/LinkedDependantsError.js

@@ -0,0 +1,31 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedDependantsError = void 0;
+const CMSError_1 = require("./CMSError");
+// class
+class LinkedDependantsError extends CMSError_1.CMSError {
+    constructor(_a) {
+        var { message = 'This operation cannot be completed because it would break dependencies.', pages = [], collections = [] } = _a, args = __rest(_a, ["message", "pages", "collections"]);
+        // construct base
+        super(Object.assign(Object.assign({}, args), { message }));
+        // initialize instance variables
+        this.pages = pages;
+        this.collections = collections;
+    }
+    serialize() {
+        const { pages, collections } = this;
+        return Object.assign(Object.assign({}, super.serialize()), { pages: JSON.parse(JSON.stringify(pages)), collections: JSON.parse(JSON.stringify(collections)) });
+    }
+}
+exports.LinkedDependantsError = LinkedDependantsError;

package/dist/errors/LockdownError.d.ts

@@ -0,0 +1,4 @@
+import { CMSError } from './CMSError';
+export declare class LockdownError extends CMSError {
+    constructor(args: CMSError.ConstructorArgs);
+}

package/dist/errors/LockdownError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockdownError = void 0;
+const CMSError_1 = require("./CMSError");
+// class
+class LockdownError extends CMSError_1.CMSError {
+    constructor(args) {
+        // construct base
+        super(args);
+    }
+}
+exports.LockdownError = LockdownError;

package/dist/errors/SlugValidationError.d.ts

@@ -0,0 +1,21 @@
+import { SerializedIsometricError } from '@nascentdigital/funnel-core';
+import type { PageClient } from '../api';
+import { CMSError } from './CMSError';
+export declare class SlugValidationError extends CMSError {
+    readonly slug: string;
+    readonly reason: SlugValidationError.Reason;
+    constructor(args: SlugValidationError.ConstructorArgs);
+    serialize(): SlugValidationError.Serialized;
+}
+export declare namespace SlugValidationError {
+    type Reason = PageClient.ValidateSlug.InvalidResult | PageClient.ValidateSlug.UnavailableResult;
+    type ConstructorArgs = Omit<CMSError.ConstructorArgs, 'message'> & {
+        slug: string;
+        reason: Reason;
+        message?: string;
+    };
+    type Serialized = SerializedIsometricError & {
+        slug: string;
+        reason: Reason;
+    };
+}

package/dist/errors/SlugValidationError.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlugValidationError = void 0;
+const CMSError_1 = require("./CMSError");
+// class
+class SlugValidationError extends CMSError_1.CMSError {
+    constructor(args) {
+        var _a;
+        // construct base
+        super(Object.assign(Object.assign({}, args), { message: (_a = args.message) !== null && _a !== void 0 ? _a : (args.reason.status === 'invalid'
+                ? `invalid format for slug "${args.slug}"`
+                : `slug "${args.slug}" is not available`) }));
+        // initialize instance variables
+        this.slug = args.slug;
+        this.reason = args.reason;
+    }
+    serialize() {
+        const { slug, reason } = this;
+        return Object.assign(Object.assign({}, super.serialize()), { slug,
+            reason });
+    }
+}
+exports.SlugValidationError = SlugValidationError;

package/dist/errors/TranslateReferencesError.d.ts

@@ -0,0 +1,21 @@
+import { Language, Schema, SerializedIsometricError } from '@nascentdigital/funnel-core';
+import { CMSError } from './CMSError';
+export declare class TranslateReferencesError extends CMSError {
+    readonly targetLanguage: Language;
+    readonly untranslatedPages: Schema.Page.Data.AsLink[];
+    readonly untranslatedCollections: Schema.Collection.Data.AsRef[];
+    constructor(args: TranslateReferencesError.ConstructorArgs);
+    serialize(): TranslateReferencesError.Serialized;
+}
+export declare namespace TranslateReferencesError {
+    type ConstructorArgs = CMSError.ConstructorArgs & {
+        targetLanguage: Language;
+        untranslatedPages: Schema.Page.Data.AsLink[];
+        untranslatedCollections: Schema.Collection.Data.AsRef[];
+    };
+    type Serialized = SerializedIsometricError & {
+        targetLanguage: Language;
+        untranslatedPages: Schema.Page.Data.AsLink[];
+        untranslatedCollections: Schema.Collection.Data.AsRef[];
+    };
+}