@nascentdigital/funnel-core 4.4.4

package/dist/schema/TagGroup.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagGroup = void 0;
+const utils_1 = require("../utils");
+const Tag_1 = require("./Tag");
+// schema
+class TagGroup {
+    constructor(args) {
+        // throw if id isn't valid
+        Tag_1.Tag.validateComponent(args.id, 'TagGroup.id');
+        // initialize instance variables
+        this.id = args.id;
+        this.name = args.name;
+        this.tags = Object.entries(args.tags)
+            .reduce((tags, [tagIdRaw, name]) => {
+            // bind tag
+            const tagId = tagIdRaw;
+            tags[tagId] = new Tag_1.Tag({
+                groupId: args.id,
+                id: tagId,
+                name
+            });
+            // keep reducing
+            return tags;
+        }, {});
+    }
+    get tagIds() {
+        return Object.values(this.tags).map(tag => tag.id);
+    }
+    get(tagId) {
+        return this.tags[tagId];
+    }
+    extract(...tagIds) {
+        const { tags } = this;
+        return tagIds.map(tagId => tags[tagId])
+            .filter(utils_1.Value.isDefined);
+    }
+    map(mapper) {
+        return Object.values(this.tags).map(mapper);
+    }
+    parse(data) {
+        const { id, tags } = this;
+        return data
+            .map(tagData => {
+            // skip if it's not valid
+            const components = Tag_1.Tag.Data.parse(tagData);
+            if (!components) {
+                return undefined;
+            }
+            // or if it's not this group
+            const { tagGroupId, tagId } = components;
+            if (tagGroupId !== id) {
+                return undefined;
+            }
+            // otherwise, return tag (if it exists)
+            return tags[tagId];
+        })
+            .filter(utils_1.Value.isDefined);
+    }
+    static create(args) {
+        return new TagGroup(args);
+    }
+}
+exports.TagGroup = TagGroup;

package/dist/schema/field/Field.d.ts

@@ -0,0 +1,179 @@
+import type { RequiredBy } from '../../types';
+import { Collection as CollectionType } from '../Collection';
+import { Optional } from '../Optional';
+import type { Page as PageType } from '../Page';
+import { AssetField, BooleanField, CollectionField, DateField, DynamicPagesField, EmbeddedVideoField, EnumField, FormField, LinkField, ListField, ObjectField, PageField, RichTextField, TextField, TimestampField } from './';
+export declare abstract class Field<TChild extends Field.Type = Field.Type> {
+    readonly name: string;
+    readonly hint?: string;
+    readonly description?: string;
+    readonly required: boolean;
+    protected constructor(args: Field.ConstructorArgs);
+    optional(): Optional<TChild>;
+    unwrap(): this;
+    abstract modify(args: Field.ModifyArgs): TChild;
+    rename(name: string): TChild;
+    require(): TChild;
+}
+export declare namespace Field {
+    type ConstructorArgs = {
+        name: string;
+        hint?: string;
+        description?: string;
+        required?: boolean;
+    };
+    type ModifyArgs = Partial<ConstructorArgs>;
+    type Type = Type.Simple | Type.Composite;
+    namespace Type {
+        type Id = Simple.Id | Composite.Id;
+        type Simple = Simple.NonAggregate | Simple.Aggregate;
+        namespace Simple {
+            type Id = Simple['type'];
+            type Text = TextField | RichTextField | EnumField;
+            type Complex = LinkField | FormField | EmbeddedVideoField | AssetField | CollectionField | PageField;
+            type Ref = AssetField | PageField;
+            type MaybeRef = CollectionField;
+            type NonAggregate = Text | BooleanField | DateField | TimestampField | DynamicPagesField;
+            type NonRef = NonAggregate | LinkField | FormField | EmbeddedVideoField;
+            type Configuration = Text | BooleanField;
+            type Aggregate = Complex | Ref;
+            namespace Aggregate {
+                function filter(field: Type): field is Aggregate;
+            }
+            function filter(field: Type): field is Simple;
+        }
+        type Composite = ListField | ObjectField;
+        namespace Composite {
+            type Id = Composite['type'];
+            function filter(field: Type): field is Composite;
+        }
+    }
+    type Value<T extends Type = Type> = T extends Type.Simple ? Value.ForSimpleType<T> : T extends Type.Composite ? Value.ForCompositeType<T> : never;
+    namespace Value {
+        type ForSimpleType<T extends Type.Simple> = T extends TextField ? TextField.Value : T extends RichTextField ? RichTextField.Value : T extends EnumField ? EnumField.Value<T> : T extends BooleanField ? BooleanField.Value : T extends DateField ? DateField.Value : T extends DynamicPagesField ? DynamicPagesField.Value : T extends TimestampField ? TimestampField.Value : T extends LinkField ? LinkField.Value : T extends FormField ? FormField.Value : T extends EmbeddedVideoField ? EmbeddedVideoField.Value : T extends AssetField<infer F> ? AssetField.Value<F> : T extends CollectionField<infer C> ? CollectionField.Value<C> : T extends PageField<infer S> ? PageField.Value<S> : 'invalid type';
+        type ForSimpleRefType<T extends Type.Simple.MaybeRef> = T extends CollectionField ? CollectionField.Value.ForRef : 'invalid type';
+        type ForSimpleInlineType<T extends Type.Simple.MaybeRef> = T extends CollectionField ? CollectionField.Value.ForInline : 'invalid type';
+        type ForCompositeType<T extends Type.Composite> = T extends ObjectField ? ObjectField.Value<T> : T extends ListField ? ListField.Value<T> : 'invalid type';
+        type ForOptionalType<T extends Optional.Maybe<Type>> = T extends Optional<any> ? Value<T['schema']> | undefined : T extends Type ? Value<T> : 'invalid type';
+    }
+    type LinkedValue<T extends Type = Type> = T extends Type.Simple ? LinkedValue.ForSimpleType<T> : T extends Type.Composite ? LinkedValue.ForCompositeType<T> : never;
+    namespace LinkedValue {
+        type ForSimpleType<T extends Type.Simple> = T extends TextField ? TextField.Value : T extends RichTextField ? RichTextField.Value : T extends EnumField ? EnumField.Value<T> : T extends BooleanField ? BooleanField.Value : T extends DateField ? DateField.Value : T extends DynamicPagesField ? DynamicPagesField.LinkedValue : T extends TimestampField ? TimestampField.Value : T extends LinkField ? LinkField.LinkedValue : T extends FormField ? FormField.Value : T extends EmbeddedVideoField ? EmbeddedVideoField.Value : T extends AssetField<infer F> ? F : T extends CollectionField<infer C> ? CollectionField.LinkedValue<C> : T extends PageField<infer S> ? PageField.LinkedValue<S> : 'invalid type';
+        type ForCompositeType<T extends Type.Composite> = T extends ObjectField ? ObjectField.LinkedValue<T> : T extends ListField ? ListField.LinkedValue<T> : 'invalid type';
+        type ForOptionalType<T extends Optional.Maybe<Type>> = T extends Optional<any> ? LinkedValue<T['schema']> | undefined : T extends Type ? LinkedValue<T> : 'invalid type';
+    }
+    type Data<T extends Type = Type> = T extends Type.Simple ? T extends Type.Simple.MaybeRef ? Data.ForSimpleMaybeRefType<T> | Data.ForSimpleMaybeInlineType<T> : T extends Type.Simple.Ref ? Data.ForSimpleRefType<T> : Data.ForSimpleType<T> : T extends Type.Composite ? Data.ForCompositeType<T> : never;
+    namespace Data {
+        type ForSimpleMaybeRefType<T extends Type.Simple.MaybeRef> = {
+            __ref: T['type'];
+            type: T['type'];
+            value: Value.ForSimpleRefType<T>;
+        };
+        type ForSimpleMaybeInlineType<T extends Type.Simple.MaybeRef> = {
+            type: T['type'];
+            value: Value.ForSimpleInlineType<T>;
+        };
+        type ForSimpleRefType<T extends Type.Simple.Ref> = {
+            __ref: T['type'];
+            type: T['type'];
+            value: Value.ForSimpleType<T>;
+        };
+        type ForSimpleType<T extends Type.Simple> = {
+            type: T['type'];
+            value: Value.ForSimpleType<T>;
+        };
+        namespace ForSimpleType {
+            function toValue<T extends Type.Simple.NonRef>(data?: Data.ForSimpleType<T>): Value.ForSimpleType<T> | undefined;
+            function fromValue<T extends Type.Simple.NonRef>(schema: T, value?: Value.ForSimpleType<T>): Data.ForSimpleType<T>;
+        }
+        type ForCompositeType<T extends Type.Composite> = {
+            type: T['type'];
+            value: Value.ForCompositeType<T>;
+        };
+        type ForOptionalType<T extends Optional.Maybe<Type>> = T extends Optional<any> ? Data<Optional.InnerType<T>> | undefined : T extends Type ? Data<T> : never;
+        function isTextField(data: Field.Data | undefined): data is Field.Data<TextField>;
+        function getText(data: Field.Data | undefined): string | undefined;
+        namespace InternalLink {
+            type Link = {
+                type: LinkField['type'];
+                value: LinkField.Value.Internal;
+            };
+            function filter(value: any): value is Link;
+            function getId(link: Link): PageType.Id;
+        }
+        type DynamicPages = {
+            type: DynamicPagesField['type'];
+            value: DynamicPagesField.Value;
+        };
+        namespace DynamicPages {
+            function filter(value: any): value is DynamicPages;
+        }
+        namespace Collection {
+            type Ref = Data.ForSimpleMaybeRefType<CollectionField>;
+            namespace Ref {
+                function filter(value: any): value is Ref;
+                function getId(collection: Ref): CollectionType.Id;
+            }
+            type Inline = Data.ForSimpleMaybeInlineType<CollectionField>;
+            namespace Inline {
+                function filter(value: any): value is Inline;
+                function getId(collection: Ref): CollectionType.Id;
+            }
+        }
+        type Page = Data<PageField>;
+        namespace Page {
+            function filter(value: any): value is Page;
+            function getId(page: Page): PageType.Id;
+        }
+        function newValue<T extends TextField | RichTextField | ListField>(type: Data<T>['type']): Data<T>;
+    }
+    type LinkedData<T extends Type = Type> = T extends Type.Simple ? LinkedData.ForSimpleType<T> : T extends Type.Composite ? LinkedData.ForCompositeType<T> : never;
+    namespace LinkedData {
+        type ForSimpleType<T extends Type.Simple> = {
+            type: T['type'];
+            value: LinkedValue.ForSimpleType<T>;
+        };
+        type ForCompositeType<T extends Type.Composite> = {
+            type: T['type'];
+            value: LinkedValue.ForCompositeType<T>;
+        };
+        type ForOptionalType<T extends Optional.Maybe<Type>> = T extends Optional<any> ? LinkedData<Optional.InnerType<T>> | undefined : T extends Type ? LinkedData<T> : never;
+    }
+    const text: (args: TextField.ConstructorArgs) => TextField;
+    const exactText: (args: RequiredBy<Omit<TextField.ConstructorArgs, "semantics" | "regex">, "exact">) => TextField;
+    const slug: (args: Omit<TextField.ConstructorArgs, "semantics" | "regex">) => TextField;
+    const uri: (args: Omit<TextField.ConstructorArgs, "semantics" | "regex">) => TextField;
+    const url: (args: Omit<TextField.ConstructorArgs, "semantics" | "regex">) => TextField;
+    const email: (args: Omit<TextField.ConstructorArgs, "semantics" | "regex">) => TextField;
+    const phone: (args: Omit<TextField.ConstructorArgs, "semantics" | "regex">) => TextField;
+    const phoneIntl: (args: Omit<TextField.ConstructorArgs, "semantics" | "regex">) => TextField;
+    const password: (args: Omit<TextField.ConstructorArgs, "semantics" | "regex">) => TextField;
+    const passwordInput: (args: Omit<TextField.ConstructorArgs, "semantics" | "regex">) => TextField;
+    const integer: (args: Omit<TextField.ConstructorArgs, "semantics" | "regex">) => TextField;
+    const richtext: (args: RichTextField.ConstructorArgs) => RichTextField;
+    const enumeration: <T extends EnumField.Options>(args: EnumField.ConstructorArgs<T>) => EnumField<T>;
+    const boolean: (args: BooleanField.ConstructorArgs) => BooleanField;
+    const date: (args: DateField.ConstructorArgs) => DateField;
+    const timestamp: (args: TimestampField.ConstructorArgs) => TimestampField;
+    const link: ({ internal, allowExternal, allowEmail, allowPhone, ...args }: LinkField.ConstructorArgs) => LinkField;
+    const internalLink: ({ pageTypes, ...args }: ConstructorArgs & Partial<LinkField.InternalArgs>) => LinkField;
+    const externalLink: (args: ConstructorArgs) => LinkField;
+    const navigationalLink: (args: ConstructorArgs & Partial<LinkField.InternalArgs<string> & LinkField.ExternalArgs>) => LinkField;
+    const emailLink: (args: ConstructorArgs) => LinkField;
+    const phoneLink: (args: ConstructorArgs) => LinkField;
+    const dynamicPages: (args: DynamicPagesField.ConstructorArgs) => DynamicPagesField;
+    const form: (args: FormField.ConstructorArgs) => FormField;
+    const embeddedVideo: (args: EmbeddedVideoField.ConstructorArgs) => EmbeddedVideoField;
+    const media: <T extends AssetField.LinkedValue>(args: AssetField.ConstructorArgs<T>) => AssetField<T>;
+    const visual: ({ mimeTypes, tags, ...args }: AssetField.ConstructorArgs.ForVisual) => AssetField<AssetField.LinkedValue.Visual>;
+    const image: ({ mimeTypes, tags, ...args }: AssetField.ConstructorArgs.ForImage) => AssetField<AssetField.LinkedValue.Image>;
+    const svg: ({ tags, ...args }: Omit<AssetField.ConstructorArgs.ForImage, "mimeTypes">) => AssetField<AssetField.LinkedValue.Image>;
+    const logo: (args: Omit<AssetField.ConstructorArgs.ForImage, "mimeTypes" | "tags">) => AssetField<AssetField.LinkedValue.Image>;
+    const video: ({ mimeTypes, tags, ...args }: AssetField.ConstructorArgs.ForVideo) => AssetField<AssetField.LinkedValue.Video>;
+    const collection: <T extends CollectionType>(args: CollectionField.ConstructorArgs<T>) => CollectionField<T>;
+    const page: (args: Omit<PageField.ConstructorArgs, "scope">) => PageField<"full">;
+    const pagePreview: (args: Omit<PageField.ConstructorArgs, "scope">) => PageField<"preview">;
+    const pageLink: (args: Omit<PageField.ConstructorArgs, "scope">) => PageField<"link">;
+    const object: <T extends ObjectField.Content>(args: ObjectField.ConstructorArgs<T>) => ObjectField<T>;
+    const list: <T extends ListField.Content>(args: ListField.ConstructorArgs<T>) => ListField<T>;
+}

package/dist/schema/field/Field.js

@@ -0,0 +1,309 @@
+"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.Field = void 0;
+const errors_1 = require("../../errors");
+const MimeType_1 = require("../../ui/MimeType");
+const LexicalUtils_1 = require("../../ui/richtext/LexicalUtils");
+const Optional_1 = require("../Optional");
+const _1 = require("./");
+// class
+class Field {
+    constructor(args) {
+        var _a;
+        // initialize instance variables
+        this.name = args.name;
+        this.hint = args.hint;
+        this.description = args.description;
+        this.required = (_a = args.required) !== null && _a !== void 0 ? _a : true;
+    }
+    optional() {
+        return new Optional_1.Optional(this);
+    }
+    unwrap() {
+        return this;
+    }
+    rename(name) {
+        return this.modify({ name });
+    }
+    require() {
+        return this.modify({ required: true });
+    }
+}
+exports.Field = Field;
+// extension
+(function (Field) {
+    let Type;
+    (function (Type) {
+        let Simple;
+        (function (Simple) {
+            let Aggregate;
+            (function (Aggregate) {
+                function filter(field) {
+                    switch (field.type) {
+                        case 'link':
+                        case 'form':
+                        case 'embedded.video':
+                        case 'asset':
+                        case 'collection':
+                        case 'page':
+                            return true;
+                        default:
+                            return false;
+                    }
+                }
+                Aggregate.filter = filter;
+            })(Aggregate = Simple.Aggregate || (Simple.Aggregate = {}));
+            // helpers
+            function filter(field) {
+                switch (field.type) {
+                    case 'text':
+                    case 'richtext':
+                    case 'enum':
+                    case 'boolean':
+                    case 'date':
+                    case 'timestamp':
+                    case 'link':
+                    case 'form':
+                    case 'embedded.video':
+                    case 'asset':
+                    case 'collection':
+                    case 'page':
+                        return true;
+                    default:
+                        return false;
+                }
+            }
+            Simple.filter = filter;
+        })(Simple = Type.Simple || (Type.Simple = {}));
+        let Composite;
+        (function (Composite) {
+            // helpers
+            function filter(field) {
+                switch (field.type) {
+                    case 'object':
+                    case 'list':
+                        return true;
+                    default:
+                        return false;
+                }
+            }
+            Composite.filter = filter;
+        })(Composite = Type.Composite || (Type.Composite = {}));
+    })(Type = Field.Type || (Field.Type = {}));
+    let Data;
+    (function (Data) {
+        let ForSimpleType;
+        (function (ForSimpleType) {
+            function toValue(data) {
+                return data === null || data === void 0 ? void 0 : data.value;
+            }
+            ForSimpleType.toValue = toValue;
+            function fromValue(schema, value) {
+                return {
+                    type: schema.type,
+                    value: value
+                };
+            }
+            ForSimpleType.fromValue = fromValue;
+        })(ForSimpleType = Data.ForSimpleType || (Data.ForSimpleType = {}));
+        // text
+        function isTextField(data) {
+            return (data === null || data === void 0 ? void 0 : data.type) === 'text';
+        }
+        Data.isTextField = isTextField;
+        function getText(data) {
+            var _a, _b, _c;
+            switch (data === null || data === void 0 ? void 0 : data.type) {
+                case 'text':
+                    return _1.TextField.Value.fromData(data);
+                case 'enum':
+                    return _1.EnumField.Value.fromData(data);
+                case 'richtext':
+                    return ((_c = LexicalUtils_1.LexicalUtils.rootToString((_b = (_a = data === null || data === void 0 ? void 0 : data.value) === null || _a === void 0 ? void 0 : _a.editorState) === null || _b === void 0 ? void 0 : _b.root)) === null || _c === void 0 ? void 0 : _c.trim()) || undefined;
+                default:
+                    return undefined;
+            }
+        }
+        Data.getText = getText;
+        // link (internal)
+        let InternalLink;
+        (function (InternalLink) {
+            // guard
+            function filter(value) {
+                return !!value
+                    && typeof value === 'object'
+                    && !Array.isArray(value)
+                    && 'type' in value
+                    && value.type === 'link'
+                    && 'value' in value
+                    && _1.LinkField.Value.Internal.filter(value.value);
+            }
+            InternalLink.filter = filter;
+            // helpers
+            function getId(link) {
+                return link.value.page.value.id;
+            }
+            InternalLink.getId = getId;
+        })(InternalLink = Data.InternalLink || (Data.InternalLink = {}));
+        let DynamicPages;
+        (function (DynamicPages) {
+            // guard
+            function filter(value) {
+                return !!value
+                    && typeof value === 'object'
+                    && !Array.isArray(value)
+                    && 'type' in value
+                    && value.type === 'dynamic.pages'
+                    && 'value' in value;
+            }
+            DynamicPages.filter = filter;
+        })(DynamicPages = Data.DynamicPages || (Data.DynamicPages = {}));
+        // collection ref
+        let Collection;
+        (function (Collection) {
+            let Ref;
+            (function (Ref) {
+                // guard
+                function filter(value) {
+                    return !!value
+                        && typeof value === 'object'
+                        && !Array.isArray(value)
+                        && 'type' in value
+                        && value.type === 'collection'
+                        && '__ref' in value
+                        && value.__ref === 'collection'
+                        && 'value' in value
+                        && _1.CollectionField.Value.ForRef.filter(value.value);
+                }
+                Ref.filter = filter;
+                // helpers
+                function getId(collection) {
+                    return collection.value.id;
+                }
+                Ref.getId = getId;
+            })(Ref = Collection.Ref || (Collection.Ref = {}));
+            let Inline;
+            (function (Inline) {
+                // guard
+                function filter(value) {
+                    return !!value
+                        && typeof value === 'object'
+                        && !Array.isArray(value)
+                        && 'type' in value
+                        && value.type === 'collection'
+                        && !('__ref' in value)
+                        && 'value' in value
+                        && _1.CollectionField.Value.ForInline.filter(value.value);
+                }
+                Inline.filter = filter;
+                // helpers
+                function getId(collection) {
+                    return collection.value.id;
+                }
+                Inline.getId = getId;
+            })(Inline = Collection.Inline || (Collection.Inline = {}));
+        })(Collection = Data.Collection || (Data.Collection = {}));
+        let Page;
+        (function (Page) {
+            // guard
+            function filter(value) {
+                return !!value
+                    && typeof value === 'object'
+                    && !Array.isArray(value)
+                    && 'type' in value
+                    && value.type === 'page'
+                    && '__ref' in value
+                    && value.__ref === 'page'
+                    && 'value' in value
+                    && _1.PageField.Value.filter(value.value);
+            }
+            Page.filter = filter;
+            // helpers
+            function getId(page) {
+                return page.value.id;
+            }
+            Page.getId = getId;
+        })(Page = Data.Page || (Data.Page = {}));
+        // factories
+        function newValue(type) {
+            // create value
+            switch (type) {
+                case 'text':
+                case 'richtext':
+                    return { type, value: '' };
+                case 'list':
+                    return { type, value: [] };
+                default:
+                    throw new errors_1.NotImplementedError(`No support for creating default "${type}" field data`);
+            }
+        }
+        Data.newValue = newValue;
+    })(Data = Field.Data || (Field.Data = {}));
+    // factories
+    Field.text = (args) => new _1.TextField(args);
+    Field.exactText = (args) => new _1.TextField(Object.assign(Object.assign({}, args), { semantics: 'short' }));
+    Field.slug = (args) => new _1.TextField(Object.assign(Object.assign({}, args), { semantics: 'slug' }));
+    Field.uri = (args) => new _1.TextField(Object.assign(Object.assign({}, args), { semantics: 'uri' }));
+    Field.url = (args) => new _1.TextField(Object.assign(Object.assign({}, args), { semantics: 'url' }));
+    Field.email = (args) => new _1.TextField(Object.assign(Object.assign({}, args), { semantics: 'email', minLength: 5, maxLength: 128 }));
+    Field.phone = (args) => new _1.TextField(Object.assign(Object.assign({}, args), { semantics: 'phone' }));
+    Field.phoneIntl = (args) => new _1.TextField(Object.assign(Object.assign({}, args), { semantics: 'phone-intl' }));
+    Field.password = (args) => new _1.TextField(Object.assign(Object.assign({}, args), { semantics: 'password' }));
+    Field.passwordInput = (args) => new _1.TextField(Object.assign(Object.assign({}, args), { semantics: 'password-input' }));
+    Field.integer = (args) => new _1.TextField(Object.assign(Object.assign({}, args), { semantics: 'integer' }));
+    Field.richtext = (args) => new _1.RichTextField(args);
+    Field.enumeration = (args) => new _1.EnumField(args);
+    Field.boolean = (args) => new _1.BooleanField(args);
+    Field.date = (args) => new _1.DateField(args);
+    Field.timestamp = (args) => new _1.TimestampField(args);
+    Field.link = (_a) => {
+        var { internal = { pageTypes: 'all' }, allowExternal = true, allowEmail = true, allowPhone = true } = _a, args = __rest(_a, ["internal", "allowExternal", "allowEmail", "allowPhone"]);
+        return new _1.LinkField(Object.assign({ internal, allowExternal, allowEmail, allowPhone }, args));
+    };
+    Field.internalLink = (_a) => {
+        var { pageTypes } = _a, args = __rest(_a, ["pageTypes"]);
+        return new _1.LinkField(Object.assign({ internal: { pageTypes: pageTypes !== null && pageTypes !== void 0 ? pageTypes : 'all' } }, args));
+    };
+    Field.externalLink = (args) => new _1.LinkField(Object.assign(Object.assign({}, args), { allowExternal: true }));
+    Field.navigationalLink = (args) => new _1.LinkField(Object.assign({ internal: { pageTypes: 'all' }, allowExternal: true }, args));
+    Field.emailLink = (args) => new _1.LinkField(Object.assign(Object.assign({}, args), { allowEmail: true }));
+    Field.phoneLink = (args) => new _1.LinkField(Object.assign(Object.assign({}, args), { allowPhone: true }));
+    Field.dynamicPages = (args) => new _1.DynamicPagesField(args);
+    Field.form = (args) => new _1.FormField(args);
+    Field.embeddedVideo = (args) => new _1.EmbeddedVideoField(Object.assign({}, args));
+    Field.media = (args) => new _1.AssetField(args);
+    Field.visual = (_a) => {
+        var { mimeTypes = [...MimeType_1.MimeType.image, ...MimeType_1.MimeType.video], tags } = _a, args = __rest(_a, ["mimeTypes", "tags"]);
+        return new _1.AssetField(Object.assign(Object.assign({}, args), { mimeTypes, tags: _1.AssetField.Tags.parse(tags) }));
+    };
+    Field.image = (_a) => {
+        var { mimeTypes = MimeType_1.MimeType.image, tags } = _a, args = __rest(_a, ["mimeTypes", "tags"]);
+        return new _1.AssetField(Object.assign(Object.assign({}, args), { mimeTypes, tags: _1.AssetField.Tags.Image.parse(tags) }));
+    };
+    Field.svg = (_a) => {
+        var { tags } = _a, args = __rest(_a, ["tags"]);
+        return new _1.AssetField(Object.assign(Object.assign({}, args), { mimeTypes: ['image/svg+xml'], tags: _1.AssetField.Tags.Image.parse(tags) }));
+    };
+    Field.logo = (args) => new _1.AssetField(Object.assign(Object.assign({}, args), { mimeTypes: ['image/webp', 'image/png', 'image/svg+xml'], tags: _1.AssetField.Tags.Image.parse(['logo', 'brand']) }));
+    Field.video = (_a) => {
+        var { mimeTypes = MimeType_1.MimeType.video, tags } = _a, args = __rest(_a, ["mimeTypes", "tags"]);
+        return new _1.AssetField(Object.assign(Object.assign({}, args), { mimeTypes, tags: _1.AssetField.Tags.Video.parse(tags) }));
+    };
+    Field.collection = (args) => new _1.CollectionField(args);
+    Field.page = (args) => new _1.PageField(Object.assign(Object.assign({}, args), { scope: 'full' }));
+    Field.pagePreview = (args) => new _1.PageField(Object.assign(Object.assign({}, args), { scope: 'preview' }));
+    Field.pageLink = (args) => new _1.PageField(Object.assign(Object.assign({}, args), { scope: 'link' }));
+    Field.object = (args) => new _1.ObjectField(args);
+    Field.list = (args) => new _1.ListField(args);
+})(Field || (exports.Field = Field = {}));