@nascentdigital/funnel-core 4.4.4

package/dist/schema/PageQuery.d.ts

@@ -0,0 +1,60 @@
+import { Language } from '../regionalization';
+import { RequiredBy } from '../types';
+import { Page } from './Page';
+import { Tag } from './Tag';
+export declare class PageQuery {
+    private readonly _query;
+    private constructor();
+    /**
+     * Start query
+     * @param data
+     */
+    static create(data?: PageQuery.Data): PageQuery;
+    /**
+     * Deserialize
+     * @param data
+     */
+    static from(data: PageQuery.Data): PageQuery;
+    type(type: Page.Type | Page.Type[] | undefined): PageQuery;
+    preview(preview: boolean): PageQuery;
+    brand(brand: string | undefined): PageQuery;
+    currentBrand(): PageQuery;
+    locale(region: string, language: Language): PageQuery;
+    exclude(ids: Page.Id | Page.Id[] | undefined): PageQuery;
+    withTags(tags: Tag.Data[] | Tag.Data | undefined, match?: PageQuery.TagsMatch): PageQuery;
+    withAnyTags(tags: Tag.Data[] | Tag.Data): PageQuery;
+    withAllTags(tags: Tag.Data[] | Tag.Data): PageQuery;
+    limit(amount: number): PageQuery;
+    sortBy(sort: PageQuery.Sort): PageQuery;
+    sortByLatest(): PageQuery;
+    sortByType(args: PageQuery.Sort.ByType[]): PageQuery;
+    /**
+     * Serialize
+     */
+    build(): PageQuery.Args;
+}
+export declare namespace PageQuery {
+    export type TagsMatch = 'any' | 'all';
+    export type Sort = Sort.ByType[] | 'latest';
+    export namespace Sort {
+        type ByType = {
+            type: Page.Type;
+            tags?: Tag.Data[];
+        };
+    }
+    export type Data = {
+        version?: Exclude<Page.State, 'unpublished'>;
+        excludeIds?: Page.Id[];
+        brand?: string;
+        types?: Page.Type[];
+        region?: string;
+        language?: Language;
+        tags?: Tag.Data[];
+        tagsMatch?: TagsMatch;
+        sort?: Sort;
+        limit?: number;
+    };
+    type RequiredArgs = 'version' | 'brand' | 'region' | 'language';
+    export type Args = RequiredBy<Data, RequiredArgs>;
+    export {};
+}

package/dist/schema/PageQuery.js

@@ -0,0 +1,116 @@
+"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.PageQuery = void 0;
+const app_1 = require("../app");
+const errors_1 = require("../errors");
+const utils_1 = require("../utils");
+// class
+class PageQuery {
+    constructor(baseQuery) {
+        this._query = baseQuery;
+    }
+    /**
+     * Start query
+     * @param data
+     */
+    static create(data = {}) {
+        return new PageQuery(data);
+    }
+    /**
+     * Deserialize
+     * @param data
+     */
+    static from(data) {
+        return new PageQuery(data);
+    }
+    type(type) {
+        this._query.types = type === undefined
+            ? undefined
+            : utils_1.ArrayUtils.coerce(type);
+        return this;
+    }
+    preview(preview) {
+        this._query.version = preview ? 'draft' : 'published';
+        return this;
+    }
+    brand(brand) {
+        this._query.brand = brand;
+        return this;
+    }
+    currentBrand() {
+        return this.brand(app_1.AppConfig.brand());
+    }
+    locale(region, language) {
+        this._query.region = region;
+        this._query.language = language;
+        return this;
+    }
+    exclude(ids) {
+        var _a;
+        // skip if no ids
+        if (!ids) {
+            return this;
+        }
+        // append ids
+        this._query.excludeIds = [
+            ...(_a = this._query.excludeIds) !== null && _a !== void 0 ? _a : [],
+            ...utils_1.ArrayUtils.coerce(ids)
+        ];
+        // allow chaining
+        return this;
+    }
+    withTags(tags, match) {
+        // skip if no tags
+        if (!tags) {
+            return this;
+        }
+        // update query and chain
+        this._query.tags = utils_1.ArrayUtils.coerce(tags);
+        this._query.tagsMatch = match;
+        return this;
+    }
+    withAnyTags(tags) {
+        return this.withTags(tags, 'any');
+    }
+    withAllTags(tags) {
+        return this.withTags(tags, 'all');
+    }
+    limit(amount) {
+        this._query.limit = amount;
+        return this;
+    }
+    sortBy(sort) {
+        this._query.sort = sort;
+        return this;
+    }
+    sortByLatest() {
+        return this.sortBy('latest');
+    }
+    sortByType(args) {
+        return this.sortBy(args);
+    }
+    /**
+     * Serialize
+     */
+    build() {
+        const _a = this._query, { version = app_1.AppConfig.get().version, brand, region, language } = _a, rest = __rest(_a, ["version", "brand", "region", "language"]);
+        // throw if required data is missing
+        if (brand === undefined || region === undefined || language === undefined) {
+            throw new errors_1.IllegalStateError('cannot build page query if brand, region, or language is not defined');
+        }
+        // return
+        return Object.assign({ version, brand, region, language }, rest);
+    }
+}
+exports.PageQuery = PageQuery;

package/dist/schema/PageRoute.d.ts

@@ -0,0 +1,7 @@
+import { Tagged } from 'type-fest';
+export type PageRoute = Tagged<string, 'funnel.PageRoute'>;
+export declare namespace PageRoute {
+    function filter(value: string): value is PageRoute;
+    function getParams(path: PageRoute): Set<string>;
+    function toUrl<TParam extends string>(path: PageRoute, params: Record<TParam, string>): string;
+}

package/dist/schema/PageRoute.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageRoute = void 0;
+// extension
+var PageRoute;
+(function (PageRoute) {
+    // matcher
+    const matcher = /^(\/(([\w\-._~:?#[\]@!$&'()*+,;=%]+)|(\{slug\})|(\{(discover|preview|content)(\.[a-zA-Z]\w*)+\})))+$/;
+    // guard
+    function filter(value) {
+        return matcher.test(value);
+    }
+    PageRoute.filter = filter;
+    // helpers
+    function getParams(path) {
+        // create set
+        const params = new Set();
+        // extract params
+        path.split('/').forEach(component => {
+            if (component.startsWith('{')) {
+                params.add(component.substring(1, component.length - 1));
+            }
+        });
+        // return params
+        return params;
+    }
+    PageRoute.getParams = getParams;
+    function toUrl(path, params) {
+        // break path into components
+        let components = path.split('/');
+        // replace path components
+        components = components.map(component => {
+            var _a;
+            // replace path components
+            if (component.startsWith('{')) {
+                const param = component.substring(1, component.length - 1);
+                return (_a = params[param]) !== null && _a !== void 0 ? _a : 'undefined';
+            }
+            // or return standard component
+            else {
+                return component;
+            }
+        });
+        // re-join components into url
+        return components.join('/');
+    }
+    PageRoute.toUrl = toUrl;
+})(PageRoute || (exports.PageRoute = PageRoute = {}));

package/dist/schema/PageSnapshot.d.ts

@@ -0,0 +1,11 @@
+import { Tagged } from 'type-fest';
+import { RequiredBy } from '../types';
+import type { Page } from './Page';
+export type PageSnapshot = RequiredBy<Pick<Page.Data, Exclude<Page.Data.Props.Id, 'id'> | Page.Data.Props.Content | 'createdOn' | 'updatedOn' | 'changeSetId' | 'publication'>, 'changeSetId'> & {
+    id: PageSnapshot.Id;
+};
+export declare namespace PageSnapshot {
+    type Id = Tagged<string, 'PageSnapshot.Id'>;
+    type Prop = keyof PageSnapshot;
+    const props: ReadonlyArray<Prop>;
+}

package/dist/schema/PageSnapshot.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageSnapshot = void 0;
+// extension
+var PageSnapshot;
+(function (PageSnapshot) {
+    PageSnapshot.props = [
+        'id', 'groupId', 'type', 'brand', 'region', 'language', 'slug', 'name', 'tags', 'url',
+        'discover', 'preview', 'content',
+        'changeSetId', 'publication', 'createdOn', 'updatedOn'
+    ];
+})(PageSnapshot || (exports.PageSnapshot = PageSnapshot = {}));

package/dist/schema/Section.d.ts

@@ -0,0 +1,71 @@
+import { StringKeyOf } from 'type-fest';
+import { Block } from './Block';
+export declare class Section<TBlocks extends Section.Blocks = Section.Blocks, TUnion extends boolean = false> {
+    readonly type = "section";
+    readonly name: string;
+    readonly version: number;
+    readonly blocks: TBlocks;
+    readonly preset: Section.Preset<TBlocks>;
+    readonly ordered: boolean;
+    readonly min: number;
+    readonly max: number;
+    private readonly _union;
+    private constructor();
+    unwrap(): this;
+    rename(name: string): Section<TBlocks, TUnion>;
+    modify(args: Section.ModifyArgs<TBlocks, TUnion>): Section<TBlocks, TUnion>;
+    static ordered<TBlocks extends Section.Blocks>(args: Section.BaseFactoryArgs<TBlocks>): Section<TBlocks>;
+    static oneOf<TBlocks extends Section.Blocks>(args: Section.SingleBlockFactoryArgs<TBlocks>): Section<TBlocks, true>;
+    static unordered<TBlocks extends Section.Blocks>(args: Section.BaseFactoryArgs<TBlocks>): Section<TBlocks>;
+}
+export declare namespace Section {
+    type Blocks<TBlock extends Block = Block> = Record<string, TBlock>;
+    type Preset<TBlocks extends Blocks = Blocks> = Array<StringKeyOf<TBlocks>>;
+    type Data<TSection extends Section = Section> = {
+        type: 'section';
+        version: number;
+        blocks: Data.ForBlock<TSection>[];
+    };
+    namespace Data {
+        type BlockInSection<TBlock extends Block = Block, TBlockKey extends string = string> = Block.Data<TBlock> & {
+            section: {
+                id: string;
+                block: TBlockKey;
+            };
+        };
+        export type ForBlock<TSection extends Section = Section> = {
+            [TBlockKey in StringKeyOf<TSection['blocks']>]: BlockInSection<TSection['blocks'][TBlockKey], TBlockKey>;
+        }[StringKeyOf<TSection['blocks']>];
+        export {};
+    }
+    type LinkedData<TSection extends Section = Section> = {
+        type: 'section';
+        version: number;
+        blocks: LinkedData.ForBlock<TSection>[];
+    };
+    namespace LinkedData {
+        type BlockInSection<TBlock extends Block = Block, TBlockKey extends string = string> = Block.LinkedData<TBlock> & {
+            section: {
+                id: string;
+                block: TBlockKey;
+            };
+        };
+        export type ForBlock<TSection extends Section = Section> = {
+            [TBlockKey in StringKeyOf<TSection['blocks']>]: BlockInSection<TSection['blocks'][TBlockKey], TBlockKey>;
+        }[StringKeyOf<TSection['blocks']>];
+        export {};
+    }
+    type ConstructorArgs<TBlocks extends Blocks = Blocks, TUnion extends boolean = false> = {
+        name: string;
+        version: number;
+        blocks: TBlocks;
+        preset: Preset<TBlocks>;
+        ordered: boolean;
+        min: number;
+        max: number;
+        union: TUnion;
+    };
+    type BaseFactoryArgs<TBlocks extends Blocks> = Omit<ConstructorArgs<TBlocks>, 'ordered' | 'union'>;
+    type SingleBlockFactoryArgs<TBlocks extends Blocks> = Omit<BaseFactoryArgs<TBlocks>, 'min' | 'max'>;
+    type ModifyArgs<TBlocks extends Blocks, TUnion extends boolean> = Partial<Omit<ConstructorArgs<TBlocks, TUnion>, 'blocks' | 'union'>>;
+}

package/dist/schema/Section.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Section = void 0;
+class Section {
+    constructor(args) {
+        this.type = 'section';
+        this.name = args.name;
+        this.version = args.version;
+        this.blocks = args.blocks;
+        this.preset = args.preset;
+        this.ordered = args.ordered;
+        this.min = args.min;
+        this.max = args.max;
+        this._union = args.union;
+    }
+    unwrap() {
+        return this;
+    }
+    rename(name) {
+        return this.modify({ name });
+    }
+    modify(args) {
+        return new Section(Object.assign({ name: this.name, version: this.version, blocks: this.blocks, preset: this.preset, ordered: this.ordered, min: this.min, max: this.max, union: this._union }, args));
+    }
+    static ordered(args) {
+        return new Section(Object.assign(Object.assign({}, args), { ordered: true, union: false }));
+    }
+    static oneOf(args) {
+        return new Section(Object.assign(Object.assign({}, args), { min: 1, max: 1, ordered: true, union: true }));
+    }
+    static unordered(args) {
+        return new Section(Object.assign(Object.assign({}, args), { ordered: false, union: false }));
+    }
+}
+exports.Section = Section;

package/dist/schema/Seo.d.ts

@@ -0,0 +1,13 @@
+import { Block } from './Block';
+export declare const Seo: Block<"_nd-seo", {
+    title: import("./field").TextField;
+    description: import("./field").TextField;
+    keywords: import("./Optional").Optional<import("./field").ListField<{
+        keyword: import("./field").TextField;
+    }>>;
+    image: import("./Optional").Optional<import("./field").AssetField<import("./field").AssetField.LinkedValue.Image>>;
+}, Block.Config>;
+export declare namespace Seo {
+    type Data = Block.Data<typeof Seo>;
+    type LinkedData = Block.LinkedData<typeof Seo>;
+}

package/dist/schema/Seo.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Seo = void 0;
+const Block_1 = require("./Block");
+const field_1 = require("./field");
+// block
+exports.Seo = Block_1.Block.create({
+    id: '_nd-seo',
+    name: 'SEO',
+    version: 1,
+    fields: {
+        title: field_1.Field.text({ name: 'Title' }),
+        description: field_1.Field.text({ name: 'Description', semantics: 'long' }),
+        keywords: field_1.Field.list({
+            name: 'Keywords',
+            hint: 'Add keywords to improve your search engine scores.',
+            min: 1,
+            max: 20,
+            itemTypes: {
+                keyword: field_1.Field.text({ name: 'Keyword', hint: 'Enter a search term', minLength: 2, maxLength: 40, required: true })
+            }
+        }).optional(),
+        image: field_1.Field.image({ name: 'Image' }).optional()
+    }
+});

package/dist/schema/Site.d.ts

@@ -0,0 +1,40 @@
+import { Localized } from '../regionalization';
+import { Collection } from './Collection';
+import { Page } from './Page';
+import { PageRoute } from './PageRoute';
+import { SiteModel } from './SiteModel';
+export declare class Site<TRegions extends Site.Regions = Site.Regions> {
+    private static _site?;
+    readonly regions: TRegions;
+    readonly collections: ReadonlyArray<Collection>;
+    private constructor();
+    toData(): Site.Data;
+    static create<TRegions extends Site.Regions>(regions: Site.CreateArgs<TRegions>, collections?: ReadonlyArray<Collection>): Site<TRegions>;
+    static current<TRegions extends Site.Regions>(): Site<TRegions>;
+    static getPage(type: Page.Type, region: string): Page;
+    static getCollection(type: Collection.Type): Collection;
+}
+export declare namespace Site {
+    type ConstructorArgs<TRegions extends Regions> = {
+        regions: TRegions;
+        collections: ReadonlyArray<Collection>;
+    };
+    type CreateArgs<TRegions extends Regions> = ConstructorArgs<TRegions>['regions'];
+    type Regions<TRegion extends string = string> = Record<TRegion, Pages>;
+    type Pages = Record<string, Page>;
+    type Data = Record<string, Data.Pages>;
+    namespace Data {
+        type Pages = Record<Page.Type, Page>;
+        type Page = {
+            variant: Page.Variant;
+            route: Localized.Maybe<PageRoute>;
+            name: string;
+        };
+        type Collections = Record<Collection.Type, Collection>;
+        type Collection = {
+            name: string;
+        };
+        function forSite(site: Site): Data;
+        function toSiteModel(data: Data): SiteModel;
+    }
+}

package/dist/schema/Site.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Site = void 0;
+const errors_1 = require("../errors");
+const SiteModel_1 = require("./SiteModel");
+// class
+class Site {
+    constructor(args) {
+        // initialize instance variables
+        this.regions = args.regions;
+        this.collections = args.collections;
+        // bind pages within each region
+        Object.values(this.regions).forEach(region => Object.entries(region).forEach(([pageType, page]) => page.bind(pageType)));
+    }
+    toData() {
+        return Site.Data.forSite(this);
+    }
+    static create(regions, collections = []) {
+        // create new Site
+        const site = new Site({ regions, collections });
+        // bind site
+        this._site = site;
+        // return site
+        return site;
+    }
+    static current() {
+        // throw if not initialized
+        const { _site } = this;
+        if (!_site) {
+            throw new errors_1.IllegalStateError('Attempt to access site schema before initial create()');
+        }
+        // return site
+        return _site;
+    }
+    static getPage(type, region) {
+        // throw if page isn't found
+        const site = Site.current();
+        const pages = site.regions[region];
+        const schema = pages[type];
+        if (!schema) {
+            throw new errors_1.IllegalStateError(`Unable to resolve Page schema for "${type}"`);
+        }
+        // or return it
+        return schema;
+    }
+    static getCollection(type) {
+        // throw if collection isn't found
+        const schemas = Site.current().collections;
+        const schema = schemas.find(schema => schema.type === type);
+        if (!schema) {
+            throw new errors_1.IllegalStateError(`Unable to resolve Collection schema for "${type}"`);
+        }
+        // or return it
+        return schema;
+    }
+}
+exports.Site = Site;
+// extension
+(function (Site) {
+    let Data;
+    (function (Data) {
+        // helpers
+        function forSite(site) {
+            // create region by walking site
+            return Object.entries(site.regions).reduce((siteData, [region, pages]) => {
+                // reduce pages in region
+                siteData[region] = Object.entries(pages).reduce((pagesData, [pageType, page]) => {
+                    // map page
+                    pagesData[pageType] = {
+                        variant: page.variant,
+                        route: page.route,
+                        name: page.name
+                    };
+                    // keep reducing
+                    return pagesData;
+                }, {});
+                // keep reducing
+                return siteData;
+            }, {});
+        }
+        Data.forSite = forSite;
+        function toSiteModel(data) {
+            return new SiteModel_1.SiteModel(data);
+        }
+        Data.toSiteModel = toSiteModel;
+    })(Data = Site.Data || (Site.Data = {}));
+})(Site || (exports.Site = Site = {}));

package/dist/schema/SiteModel.d.ts

@@ -0,0 +1,5 @@
+import { Site } from './Site';
+export declare class SiteModel {
+    readonly data: Site.Data;
+    constructor(data: Site.Data);
+}

package/dist/schema/SiteModel.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SiteModel = void 0;
+// class
+class SiteModel {
+    constructor(data) {
+        this.data = data;
+    }
+}
+exports.SiteModel = SiteModel;

package/dist/schema/Tag.d.ts

@@ -0,0 +1,28 @@
+import { StringKeyOf } from 'type-fest';
+import { TagGroup } from './TagGroup';
+export declare class Tag<TGroupId extends string = string, TId extends string = string> {
+    readonly groupId: TGroupId;
+    readonly id: TId;
+    readonly name: string;
+    readonly data: Tag.Data<TGroupId, TId>;
+    constructor(args: Tag.ConstructorArgs<TGroupId, TId>);
+}
+export declare namespace Tag {
+    const separator: "/";
+    type Data<TGroupId extends string = string, TId extends string = string> = `${TGroupId}/${TId}`;
+    namespace Data {
+        type ForGroup<TGroup extends TagGroup> = Data<TGroup['id'], StringKeyOf<TGroup['tags']>>;
+        type Components = {
+            tagGroupId: string;
+            tagId: string;
+        };
+        function parse(data: Tag.Data): Components | undefined;
+    }
+    type ConstructorArgs<TGroupId extends string = string, TId extends string = string> = {
+        groupId: TGroupId;
+        id: TId;
+        name: string;
+    };
+    function toData<TGroupId extends string = string, TId extends string = string>(tag: Tag<TGroupId, TId>): Data<TGroupId, TId>;
+    function validateComponent(component: string, componentName: string): void;
+}

package/dist/schema/Tag.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tag = void 0;
+const errors_1 = require("../errors");
+// schema
+class Tag {
+    constructor(args) {
+        // throw if id isn't valid
+        Tag.validateComponent(args.id, 'Tag.id');
+        // initialize instance variables
+        this.groupId = args.groupId;
+        this.id = args.id;
+        this.name = args.name;
+        this.data = Tag.toData(this);
+    }
+}
+exports.Tag = Tag;
+// extension
+(function (Tag) {
+    // constants
+    Tag.separator = '/';
+    let Data;
+    (function (Data) {
+        // helpers
+        function parse(data) {
+            // parse component (or fail if invalid)
+            const components = data.split('/');
+            if (components.length !== 2) {
+                return undefined;
+            }
+            // return components
+            const [tagGroupId, tagId] = components;
+            return tagGroupId && tagId
+                ? { tagGroupId, tagId }
+                : undefined;
+        }
+        Data.parse = parse;
+    })(Data = Tag.Data || (Tag.Data = {}));
+    // helpers
+    function toData(tag) {
+        return `${tag.groupId}/${tag.id}`;
+    }
+    Tag.toData = toData;
+    function validateComponent(component, componentName) {
+        // fail if it's empty
+        if (!component) {
+            throw new errors_1.ArgumentError(`Tag components can't be empty`, componentName);
+        }
+        // fail if it includes a separator
+        else if (component.includes(Tag.separator)) {
+            throw new errors_1.ArgumentError(`Tag components cannot include '${Tag.separator}' character`, componentName);
+        }
+        // fail if there's whitespace
+        else if (/\s/.test(component)) {
+            throw new errors_1.ArgumentError(`Tag components cannot contain whitespace`, componentName);
+        }
+    }
+    Tag.validateComponent = validateComponent;
+})(Tag || (exports.Tag = Tag = {}));

package/dist/schema/TagGroup.d.ts

@@ -0,0 +1,26 @@
+import { StringKeyOf } from 'type-fest';
+import { Transform } from '../types';
+import { Tag } from './Tag';
+export declare class TagGroup<TId extends string = string, TTagId extends string = string> {
+    readonly id: TId;
+    readonly name: string;
+    readonly tags: Readonly<Record<TTagId, Tag<TId, TTagId>>>;
+    private constructor();
+    get tagIds(): TTagId[];
+    get(tagId: TTagId): Tag<TId, TTagId> | undefined;
+    extract(...tagIds: TTagId[]): Tag<TId, TTagId>[];
+    map<T>(mapper: Transform<Tag<TId, TTagId>, T>): T[];
+    parse(data: TagGroup.Data): Tag<TId, TTagId>[];
+    static create<TId extends string, TTagId extends string>(args: TagGroup.ConstructorArgs<TId, TTagId>): TagGroup<TId, TTagId>;
+}
+export declare namespace TagGroup {
+    type Data<TGroup extends TagGroup = TagGroup> = Tag.Data.ForGroup<TGroup>[];
+    type ConstructorArgs<TId extends string = string, TTagId extends string = string> = {
+        id: TId;
+        name: string;
+        tags: Readonly<Record<TTagId, string>>;
+    };
+    type CreateArgs<TId extends string, TTagId extends string> = ConstructorArgs<TId, TTagId>;
+    type Keys<TGroup extends TagGroup> = StringKeyOf<TGroup['tags']>;
+    type Tags<TGroup extends TagGroup> = Tag<TGroup['id'], Keys<TGroup>>;
+}