@nascentdigital/funnel-core 4.4.4

package/dist/schema/LinkedData.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedData = void 0;
+const app_1 = require("../app");
+const utils_1 = require("../utils");
+const Asset_1 = require("./Asset");
+const Collection_1 = require("./Collection");
+const field_1 = require("./field");
+const Page_1 = require("./Page");
+// namespace
+var LinkedData;
+(function (LinkedData) {
+    /**
+     * Link data, only resolving static links
+     */
+    function resolveStatic(args) {
+        // base transform (only static linking)
+        const { data } = baseTransform(args);
+        // return statically linked data
+        return data;
+    }
+    LinkedData.resolveStatic = resolveStatic;
+    /**
+     * Link data, resolving static and dynamic links
+     */
+    async function resolve(args) {
+        // base transform (only static linking)
+        const { data, unlinkedReferences } = baseTransform(args);
+        // resolve dynamic links (mutates data)
+        await resolveDynamicLinks({ unlinkedReferences, resolvers: args.resolvers });
+        // return linked data
+        return data;
+    }
+    LinkedData.resolve = resolve;
+    // base transform
+    function baseTransform(args) {
+        // clone unlinked data (this will be mutated)
+        const unlinkedData = utils_1.ObjectUtils.clone(args.unlinkedData);
+        // resolve persona values (mutates data)
+        resolvePersonas({ data: unlinkedData, persona: args.persona });
+        // find all references in data
+        const references = findReferences(unlinkedData);
+        // load references from store (mutates references)
+        if (args.stores) {
+            loadStores({ stores: args.stores, references });
+        }
+        // find all unlinked references
+        const unlinkedReferences = findUnlinkedReferences(unlinkedData);
+        // resolve static links (mutates data)
+        resolveStaticLinks({ references, unlinkedReferences });
+        // return
+        return {
+            references, unlinkedReferences, data: unlinkedData
+        };
+    }
+    // load stores
+    function loadStores({ stores, references }) {
+        const { assets = [], collections = [] } = stores;
+        // load assets
+        assets.forEach(asset => {
+            references.assets.set(asset.value.id, asset);
+        });
+        // load collections
+        collections.forEach(collection => {
+            references.collections.set(collection.id, collection);
+        });
+    }
+    // find references
+    function findReferences(unlinkedData) {
+        // create empty references
+        const pages = new Map();
+        const collections = new Map();
+        const assets = new Map();
+        // walk unlinked data
+        utils_1.ObjectUtils.walk(unlinkedData, ({ value }) => {
+            // page data
+            if (Page_1.Page.Data.filter(value)) {
+                if (!pages.has(value.id)) {
+                    pages.set(value.id, value);
+                }
+                if ('snapshots' in value) {
+                    delete value.snapshots;
+                }
+                // pages can have other page/collection data
+                return true;
+            }
+            // collection data
+            else if (Collection_1.Collection.Data.filter(value)) {
+                if (!collections.has(value.id)) {
+                    collections.set(value.id, value);
+                }
+                if ('snapshots' in value) {
+                    delete value.snapshots;
+                }
+                // collections can have other page/collection data
+                return true;
+            }
+            // asset data
+            else if (Asset_1.Asset.Linked.filter(value)) {
+                // replace system setting in videos
+                const assetValue = value.value;
+                if (field_1.AssetField.LinkedValue.Video.filter(assetValue) && assetValue.metadata.accessible === 'system') {
+                    assetValue.metadata.accessible = app_1.AppConfig.get().accessible;
+                }
+                const assetId = Asset_1.Asset.getId(value);
+                if (!assets.has(assetId)) {
+                    assets.set(assetId, value);
+                }
+                // assets don't have any nested data
+                return false;
+            }
+            // otherwise just keep walking
+            return true;
+        });
+        // return references
+        return { pages, collections, assets };
+    }
+    // find unlinked references
+    function findUnlinkedReferences(unlinkedData) {
+        // create empty unlinked references
+        const pageRefs = new Map();
+        const collectionRefs = new Map();
+        const assetRefs = new Map();
+        const dynamicPages = [];
+        // helper
+        const upsertRef = (id, value, map) => {
+            const refs = map.get(id);
+            if (refs) {
+                refs.push(value);
+            }
+            else {
+                map.set(id, [value]);
+            }
+        };
+        // walk unlinked data
+        utils_1.ObjectUtils.walk(unlinkedData, ({ value }) => {
+            // page ref
+            if (field_1.Field.Data.Page.filter(value)) {
+                const pageId = field_1.Field.Data.Page.getId(value);
+                upsertRef(pageId, value, pageRefs);
+                return false;
+            }
+            // collection ref
+            else if (field_1.Field.Data.Collection.Ref.filter(value)) {
+                const collectionId = field_1.Field.Data.Collection.Ref.getId(value);
+                upsertRef(collectionId, value, collectionRefs);
+                return false;
+            }
+            // asset ref
+            else if (Asset_1.Asset.filter(value)) {
+                const assetId = Asset_1.Asset.getId(value);
+                upsertRef(assetId, value, assetRefs);
+                return false;
+            }
+            // dynamic ref
+            else if (field_1.Field.Data.DynamicPages.filter(value)) {
+                dynamicPages.push(value);
+                return true;
+            }
+            // otherwise just keep walking
+            return true;
+        });
+        // return unlinked references
+        return { pageRefs, collectionRefs, assetRefs, dynamicPages };
+    }
+    // resolve static links
+    function resolveStaticLinks({ references, unlinkedReferences }) {
+        // setup
+        const { pages, collections, assets } = references;
+        const { pageRefs, collectionRefs, assetRefs } = unlinkedReferences;
+        // resolve page refs
+        pageRefs.forEach((refs, id) => {
+            const pageData = pages.get(id);
+            // for each reference, fill in the data
+            refs.forEach(ref => {
+                ref.value = pageData
+                    ? field_1.PageField.Value.toLinked(ref.value, pageData) // pageData is now linked
+                    : ref.value;
+                // @ts-expect-error no longer a ref
+                delete ref.__ref;
+            });
+        });
+        // resolve collection refs
+        collectionRefs.forEach((refs, id) => {
+            const collectionData = collections.get(id);
+            // for each reference, fill in the data
+            refs.forEach(ref => {
+                ref.value = Object.assign(Object.assign({}, ref.value), collectionData);
+                // @ts-expect-error no longer a ref
+                delete ref.__ref;
+            });
+        });
+        // resolve asset refs
+        assetRefs.forEach((refs, id) => {
+            const assetData = assets.get(id);
+            // for each reference, fill in the data
+            refs.forEach(ref => {
+                ref.value = assetData
+                    ? field_1.AssetField.Value.toLinked(ref.value, assetData)
+                    : ref.value;
+                // @ts-expect-error no longer a ref
+                delete ref.__ref;
+            });
+        });
+    }
+    function resolvePersonas({ data, persona }) {
+        var _a;
+        // guard to test fields with personas
+        function fieldWithPersonaValues(value) {
+            return !!value
+                && utils_1.Value.typeOf(value) === 'object'
+                && 'type' in value
+                && 'value' in value
+                && 'personas' in value
+                && utils_1.Value.typeOf(value.personas) === 'object';
+        }
+        // keep track of all fields with persona data
+        const unresolvedFields = [];
+        // find all fields with persona values
+        utils_1.ObjectUtils.walk(data, ({ value }) => {
+            // track field
+            if (fieldWithPersonaValues(value)) {
+                unresolvedFields.push(value);
+            }
+            // always recurse
+            return true;
+        });
+        // resolve each field
+        for (const field of unresolvedFields) {
+            field.value = persona
+                ? (_a = field.personas[persona]) !== null && _a !== void 0 ? _a : field.value
+                : field.value;
+            // @ts-expect-error no longer needed
+            delete field.personas;
+        }
+    }
+    // resolve dynamic links
+    async function resolveDynamicLinks({ unlinkedReferences, resolvers: { page: pageResolver } }) {
+        // TODO: get limit from some meta data in content, assuming 3 for now
+        const TEMP_LIMIT = 3;
+        // setup
+        const { dynamicPages } = unlinkedReferences;
+        // go through each dynamic ref and resolve query
+        await Promise.all(dynamicPages.map(async (dynamicPages) => {
+            const { types, sort, staticPages: staticPagesRaw = [] } = dynamicPages.value;
+            const staticPages = staticPagesRaw.map(item => item.value);
+            // if we have enough static items, linked value becomes static values
+            // TODO: remove hardcoded schema in value
+            if (staticPages.length >= TEMP_LIMIT) {
+                dynamicPages.value = {
+                    // @ts-expect-error changing type on purpose
+                    __schema: {
+                        types: ['case-study'],
+                        size: TEMP_LIMIT
+                    },
+                    pages: staticPages
+                };
+            }
+            // otherwise we need to fetch items, combining
+            else {
+                // get ids to exclude
+                const excludeIds = staticPages.map(page => page.id);
+                // fetch only needed amount
+                const limit = TEMP_LIMIT - staticPages.length;
+                // fetch dynamic items
+                const resolvedPages = await pageResolver({ types, excludeIds, sort, limit });
+                const linkedResolvedPages = resolveStatic({
+                    unlinkedData: resolvedPages
+                });
+                console.debug('[LinkData] dynamic pages', resolvedPages);
+                // stitch static and dynamic items
+                // TODO: remove hardcoded schema in value
+                dynamicPages.value = {
+                    // @ts-expect-error changing type on purpose
+                    __schema: {
+                        types: ['case-study'],
+                        size: TEMP_LIMIT
+                    },
+                    pages: [
+                        ...staticPages,
+                        ...linkedResolvedPages
+                    ]
+                };
+                console.debug('[LinkData] final value', dynamicPages.value);
+            }
+        }));
+    }
+})(LinkedData || (exports.LinkedData = LinkedData = {}));

package/dist/schema/LinkedPageModel.d.ts

@@ -0,0 +1,11 @@
+import { LinkedData } from './LinkedData';
+import { Page } from './Page';
+/**
+ * Page model with refs resolved to values
+ */
+export declare class LinkedPageModel<TPage extends Page> {
+    readonly data: Page.LinkedData<TPage>;
+    constructor(data: Page.LinkedData<TPage>);
+    get seo(): import("./Seo").Seo.LinkedData;
+    static fromPageData<TPage extends Page>(unlinkedData: Page.Data<TPage> | Page.Data.AsPreview<TPage>, resolvers: LinkedData.DynamicResolvers): Promise<LinkedPageModel<TPage>>;
+}

package/dist/schema/LinkedPageModel.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedPageModel = void 0;
+const LinkedData_1 = require("./LinkedData");
+/**
+ * Page model with refs resolved to values
+ */
+class LinkedPageModel {
+    constructor(data) {
+        this.data = data;
+    }
+    get seo() {
+        var _a;
+        return (_a = this.data.discover) === null || _a === void 0 ? void 0 : _a.seo;
+    }
+    static async fromPageData(unlinkedData, resolvers) {
+        // transform
+        const linkedData = await LinkedData_1.LinkedData.resolve({
+            unlinkedData,
+            resolvers
+        });
+        // return linked page model
+        return new LinkedPageModel(linkedData);
+    }
+}
+exports.LinkedPageModel = LinkedPageModel;

package/dist/schema/Optional.d.ts

@@ -0,0 +1,23 @@
+import { Block } from './Block';
+import { Field } from './field';
+export declare class Optional<T extends Optional.Content = Optional.Content> {
+    readonly type = "optional";
+    readonly schema: T;
+    constructor(schema: T);
+    get name(): string;
+    get required(): boolean;
+    unwrap(): T;
+    require(): T;
+}
+export declare namespace Optional {
+    type Content = Field.Type | Block;
+    type Maybe<T extends Content> = T | Optional<T>;
+    type InnerType<T extends Content | Optional<Content>> = T extends Optional<Content> ? T['schema'] : T;
+    function unwrap<T extends Content = any>(maybeOptional: Maybe<T>): unwrap.Result<T>;
+    namespace unwrap {
+        type Result<T extends Content = any> = {
+            isOptional: boolean;
+            schema: T;
+        };
+    }
+}

package/dist/schema/Optional.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Optional = void 0;
+// class
+class Optional {
+    constructor(schema) {
+        this.type = 'optional';
+        // initialize instance variables
+        this.schema = schema.modify({ required: false });
+    }
+    get name() {
+        return this.schema.name;
+    }
+    get required() {
+        return false;
+    }
+    unwrap() {
+        return this.schema;
+    }
+    require() {
+        return this.schema.modify({ required: true });
+    }
+}
+exports.Optional = Optional;
+// extension
+(function (Optional) {
+    // helpers
+    function unwrap(maybeOptional) {
+        return maybeOptional instanceof Optional
+            ? { isOptional: maybeOptional.schema.required !== true, schema: maybeOptional.schema }
+            : { isOptional: false, schema: maybeOptional };
+    }
+    Optional.unwrap = unwrap;
+})(Optional || (exports.Optional = Optional = {}));

package/dist/schema/Page.d.ts

@@ -0,0 +1,299 @@
+import { StringKeyOf, Tagged } from 'type-fest';
+import { Language, Localized } from '../regionalization';
+import { PartialBy } from '../types';
+import { Asset } from './Asset';
+import { Block } from './Block';
+import type { ChangeSet } from './ChangeSet';
+import { Collection } from './Collection';
+import { Field, ListField, ObjectField } from './field';
+import { Fields } from './Fields';
+import { Optional } from './Optional';
+import { PageRoute } from './PageRoute';
+import type { PageSnapshot } from './PageSnapshot';
+import { Section } from './Section';
+import type { Seo } from './Seo';
+import { TagGroup } from './TagGroup';
+export declare class Page<TContent extends Page.Content = Page.Content, TPreview extends Page.PreviewTarget<TContent> = Page.PreviewTarget<TContent>> {
+    private _type?;
+    readonly variant: Page.Variant;
+    readonly route: Localized.Maybe<PageRoute>;
+    readonly tags: ReadonlyArray<TagGroup>;
+    readonly name: string;
+    readonly description?: string;
+    readonly displayName?: Page.DisplayName<TContent>;
+    readonly optional: boolean;
+    readonly preview?: TPreview;
+    readonly content: TContent;
+    readonly parent?: string;
+    private constructor();
+    get type(): Page.Type;
+    bind(type: Page.Type): void;
+    static static<TContent extends Page.Content, TPreview extends Page.PreviewTarget<TContent>>({ route, ...args }: Page.FactoryArgs.Static<TContent, TPreview>): Page<TContent, TPreview>;
+    static dynamic<TContent extends Page.Content, TPreview extends Page.PreviewTarget<TContent>>(args: Page.FactoryArgs.Dynamic<TContent, TPreview>): Page<TContent, TPreview>;
+}
+export declare namespace Page {
+    type Content = Record<string, Content.Item>;
+    namespace Content {
+        type Item = Optional.Maybe<Block> | Section;
+        type Blocks<TContent extends Content = Content> = {
+            [TKey in StringKeyOf<TContent>]: TContent[TKey] extends Block ? TContent[TKey] : never;
+        };
+    }
+    type PreviewTarget<TContent extends Content = Content> = StringKeyOf<Content.Blocks<TContent>>;
+    type DisplayName<TContent extends Content = Content> = DisplayName.For<TContent>;
+    namespace DisplayName {
+        type For<TContent extends Content> = {
+            [TKey in StringKeyOf<Content.Blocks<TContent>>]: TContent[TKey] extends Block<infer TId, infer TFields> ? `${TKey}.${keyof Fields.TextLikeFields<TFields>}` : never;
+        }[StringKeyOf<Content.Blocks<TContent>>];
+    }
+    type Update = Update.Tags | Update.BlockCreate | Update.BlockDelete | Update.SectionInsert | Update.SectionDelete | Update.SectionReorder | Update.SectionBlockName | Update.ObjectInsert | Update.ArrayInsert | Update.ArrayDelete | Update.ArrayReorder | Update.Value;
+    namespace Update {
+        type Tags = {
+            type: 'tags';
+            tags: TagGroup.Data;
+        };
+        type BlockCreate = {
+            type: 'block.create';
+            path: [string, string];
+            block: Block.Data;
+        };
+        type BlockDelete = {
+            type: 'block.delete';
+            path: [string, string];
+        };
+        type Value = {
+            type: 'value';
+            path: string[];
+            value: Field.Data | ListField.Value.ForItem;
+            persona?: string;
+        };
+        type ObjectInsert = {
+            type: 'object.insert';
+            path: string[];
+            value: Field.Data<ObjectField>;
+        };
+        type ArrayInsert = {
+            type: 'array.insert';
+            path: string[];
+            index: number;
+            id: string;
+            value: ListField.Value.ForItem;
+        };
+        type ArrayDelete = {
+            type: 'array.delete';
+            path: string[];
+            id: string;
+        };
+        type ArrayReorder = {
+            type: 'array.reorder';
+            path: string[];
+            ids: string[];
+        };
+        type SectionInsert = {
+            type: 'section.insert';
+            path: string[];
+            index: number;
+            section: Omit<Section.Data, 'blocks'>;
+            block: Section.Data.ForBlock;
+        };
+        type SectionDelete = {
+            type: 'section.delete';
+            path: string[];
+            id: string;
+        };
+        type SectionReorder = {
+            type: 'section.reorder';
+            path: string[];
+            ids: string[];
+        };
+        type SectionBlockName = {
+            type: 'section.blockName';
+            path: string[];
+            id: string;
+            value: string | null;
+        };
+    }
+    type Data<TPage extends Page = Page, TRegion extends string = string> = {
+        __root: 'page';
+        id: Id;
+        groupId: GroupId;
+        brand: string;
+        type: Type;
+        tags: TagGroup.Data;
+        slug?: string;
+        url: string;
+        region: TRegion;
+        language: Language;
+        name: string;
+        discover: Data.Discover;
+        preview?: Data.Preview<TPage>;
+        content: Data.Content<TPage>;
+        files: Asset.Linked[];
+        pages: Data.AsPreview[];
+        collections: Collection.Data[];
+        state: State;
+        errors: boolean;
+        changeSetId?: ChangeSet.Id;
+        snapshotId?: PageSnapshot.Id;
+        snapshot?: PageSnapshot;
+        createdOn: number;
+        updatedOn: number;
+        publishedOn?: number;
+        publication?: number;
+    };
+    namespace Data {
+        namespace Props {
+            type Id = Extract<All, 'id' | 'groupId' | 'brand' | 'type' | 'tags' | 'region' | 'language' | 'slug' | 'url' | 'name'>;
+            const id: ReadonlyArray<Id>;
+            type Content = Extract<All, 'discover' | 'preview' | 'content'>;
+            const content: ReadonlyArray<Content>;
+            type Links = Extract<All, 'files' | 'pages' | 'collections'>;
+            const links: ReadonlyArray<Links>;
+            type Audit = Extract<All, 'state' | 'errors' | 'changeSetId' | 'snapshotId' | 'createdOn' | 'updatedOn' | 'publishedOn' | 'publication'>;
+            const audit: ReadonlyArray<Audit>;
+            type Backup = Extract<All, 'snapshot'>;
+            const backup: ReadonlyArray<Backup>;
+            type All = keyof Data;
+            const all: ReadonlyArray<All>;
+        }
+        type AsDraft<TPage extends Page = Page, TRegion extends string = string> = PartialBy<Pick<Data<TPage, TRegion>, AsDraft.Prop | 'discover'>, 'discover'>;
+        namespace AsDraft {
+            type Prop = Exclude<Props.Id, 'id'> | Extract<Props.Audit, 'changeSetId'>;
+            const props: ReadonlyArray<Prop>;
+        }
+        type AsNew<TPage extends Page = Page, TRegion extends string = string> = Pick<Data<TPage, TRegion>, AsNew.Prop>;
+        namespace AsNew {
+            type Prop = Exclude<Props.Id, 'id' | 'groupId' | 'url'> | Extract<Props.Audit, 'changeSetId'>;
+            const props: ReadonlyArray<Prop>;
+        }
+        type AsNewLanguage<TPage extends Page = Page, TRegion extends string = string> = Pick<Data<TPage, TRegion>, AsNewLanguage.Prop>;
+        namespace AsNewLanguage {
+            type Prop = Extract<Props.Id, 'brand' | 'groupId' | 'slug' | 'language'>;
+            const props: ReadonlyArray<Prop>;
+            function filter<TPage extends Page = Page, TRegion extends string = string>(page: AsNew<TPage, TRegion> | AsNewLanguage<TPage, TRegion>): page is AsNewLanguage<TPage, TRegion>;
+        }
+        type AsRef<TPage extends Page = Page, TRegion extends string = string> = Pick<Data<TPage, TRegion>, AsRef.Prop>;
+        namespace AsRef {
+            type Prop = Extract<Props.Id, 'id' | 'url'>;
+            const props: ReadonlyArray<Prop>;
+        }
+        type AsLink<TPage extends Page = Page, TRegion extends string = string> = Pick<Data<TPage, TRegion>, AsLink.Prop>;
+        namespace AsLink {
+            type Prop = Props.Id | Props.Audit;
+            const props: ReadonlyArray<Prop>;
+            function from(data: Data): AsLink;
+        }
+        type AsPreview<TPage extends Page = Page, TRegion extends string = string> = Pick<Data<TPage, TRegion>, AsPreview.Prop>;
+        namespace AsPreview {
+            type Prop = Props.Id | Extract<Props.Content, 'preview'> | Props.Links | Props.Audit;
+            const props: ReadonlyArray<Prop>;
+            function from(data: Data): AsPreview;
+            function filter(data: Data | AsPreview): data is Preview;
+        }
+        type AsGroup<TPage extends Page = Page, TRegion extends string = string> = {
+            group: {
+                groupId: GroupId;
+                brand: string;
+                region: TRegion;
+                type: Type;
+                slug?: string;
+                preset?: string;
+                instances: AsGroup.Instance[];
+            };
+            page?: Data<TPage, TRegion>;
+        };
+        namespace AsGroup {
+            type Instance<TPage extends Page = Page, TRegion extends string = string> = Pick<Data<TPage, TRegion>, Instance.Prop>;
+            namespace Instance {
+                type Prop = Extract<Props.Id, 'id' | 'name' | 'language' | 'url' | 'slug' | 'tags'> | Exclude<Props.Audit, 'publication'>;
+                const props: ReadonlyArray<Prop>;
+            }
+        }
+        type Discover = {
+            seo: Seo.Data;
+        };
+        type Preview<TPage extends Page = Page> = Content<TPage>[Exclude<TPage['preview'], undefined>];
+        type Content<TPage extends Page = Page<any>> = {
+            [key in keyof TPage['content']]: TPage['content'][key] extends Section ? Section.Data<TPage['content'][key]> : TPage['content'][key] extends Optional.Maybe<Block> ? Block.Data.ForOptional<TPage['content'][key]> : never;
+        };
+        function filter(value: any): value is Data;
+    }
+    type LinkedData<TPage extends Page = Page> = Omit<Data<TPage>, 'discover' | 'preview' | 'content' | 'snapshots'> & {
+        discover: LinkedData.Discover;
+        preview?: LinkedData.Preview<TPage>;
+        content: LinkedData.Content<TPage>;
+    };
+    namespace LinkedData {
+        type Discover = {
+            seo: Seo.LinkedData;
+        };
+        type Preview<TPage extends Page = Page> = Content<TPage>[Exclude<TPage['preview'], undefined>];
+        type Content<TPage extends Page = Page<any>> = {
+            [key in keyof TPage['content']]: TPage['content'][key] extends Section ? Section.LinkedData<TPage['content'][key]> : TPage['content'][key] extends Optional.Maybe<Block> ? Block.LinkedData.ForOptional<TPage['content'][key]> : never;
+        };
+        type AsLink<TPage extends Page = Page> = Pick<LinkedData<TPage>, Data.AsLink.Prop>;
+        namespace AsLink {
+            function from(data: LinkedData): AsLink;
+        }
+        type AsPreview<TPage extends Page = Page> = Pick<LinkedData<TPage>, Data.AsPreview.Prop>;
+        namespace AsPreview {
+            function from(data: LinkedData): AsPreview;
+        }
+    }
+    type Id = Tagged<string, 'funnel.Page.Id'> | Id.Draft;
+    namespace Id {
+        type Draft = '__draft.id__';
+        const draft: Draft;
+    }
+    type Type = Tagged<string, 'funnel.Page.Type'> | Type.Unknown;
+    namespace Type {
+        type Unknown = '__unknown.type__';
+        const unknown: Unknown;
+    }
+    type GroupId = Tagged<string, 'funnel.Page.GroupId'> | GroupId.Empty;
+    namespace GroupId {
+        type Empty = '__draft.group__';
+        const empty: Empty;
+    }
+    type Variant = 'static' | 'dynamic';
+    type State = 'draft' | 'published' | 'unpublished';
+    namespace State {
+        const values: ReadonlyArray<State>;
+        function coerce(value: string | undefined): State;
+        function coerceLive(value: string | undefined): Exclude<State, 'unpublished'>;
+    }
+    type ConstructorArgs<TContent extends Content = Content, TPreview extends PreviewTarget<TContent> = PreviewTarget<TContent>> = ConstructorArgs.Static<TContent, TPreview> | ConstructorArgs.Dynamic<TContent, TPreview>;
+    namespace ConstructorArgs {
+        type Base<TContent extends Content = Content, TPreview extends PreviewTarget<TContent> = PreviewTarget<TContent>> = {
+            route: Localized.Maybe<PageRoute>;
+            tags?: ReadonlyArray<TagGroup>;
+            name: string;
+            description?: string;
+            displayName?: DisplayName<TContent>;
+            optional?: boolean;
+            preview?: TPreview;
+            content: TContent;
+        };
+        type Static<TContent extends Content = Content, TPreview extends PreviewTarget<TContent> = PreviewTarget<TContent>> = Base<TContent, TPreview> & {
+            variant: Extract<Variant, 'static'>;
+        };
+        namespace Static {
+            function filter<TContent extends Content, TPreview extends PreviewTarget<TContent>>(args: ConstructorArgs<TContent, TPreview>): args is Static<TContent, TPreview>;
+        }
+        type Dynamic<TContent extends Content = Content, TPreview extends PreviewTarget<TContent> = PreviewTarget<TContent>> = Base<TContent, TPreview> & {
+            variant: Extract<Variant, 'dynamic'>;
+            parent?: string;
+        };
+        namespace Dynamic {
+            function filter<TContent extends Content, TPreview extends PreviewTarget<TContent>>(args: ConstructorArgs<TContent, TPreview>): args is Dynamic<TContent, TPreview>;
+        }
+    }
+    namespace FactoryArgs {
+        type Base<TContent extends Content, TPreview extends PreviewTarget<TContent>> = Omit<ConstructorArgs.Base<TContent, TPreview>, 'route'> & {
+            route: Localized.Maybe<string>;
+        };
+        export type Static<TContent extends Content, TPreview extends PreviewTarget<TContent>> = Base<TContent, TPreview>;
+        export type Dynamic<TContent extends Content, TPreview extends PreviewTarget<TContent>> = Base<TContent, TPreview> & Pick<ConstructorArgs.Dynamic<TContent, TPreview>, 'parent'>;
+        export {};
+    }
+}