@prismicio/types-internal 3.16.0 → 3.16.1-alpha.0

package/lib/src/customtypes/widgets/nestable/Link.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Link = exports.LinkConfig = exports.LinkFieldType = exports.CustomTypes = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/lib/Either");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const withFallback_1 = require("io-ts-types/lib/withFallback");
+const validators_1 = require("../../../validators");
+const arrayString = (entries) => {
+    if (entries instanceof Array) {
+        const isValidEntries = entries.reduce((acc, l) => acc && typeof l === "string", true);
+        if (isValidEntries)
+            return t.success(entries);
+    }
+    return;
+};
+const plainString = (entries) => {
+    if (typeof entries === "string") {
+        return t.success([entries]);
+    }
+    return;
+};
+const MasksArrayString = new t.Type("MasksArrayString", (u) => {
+    return u instanceof Array;
+}, (u, context) => {
+    return Either_1.either.chain(t.union([t.array(t.string), t.string]).validate(u, context), (masks) => {
+        return arrayString(masks) || plainString(masks) || t.failure(u, context);
+    });
+}, (res) => res);
+// Field selection in content relationship fields doesn't support nested groups.
+const CustomTypeLevel2FieldGroupFields = new t.Type("CustomTypeLevel2FieldGroupFields", (u) => Array.isArray(u) && u.every((item) => typeof item === "string"), (u, context) => Either_1.either.chain(t.array(t.string).validate(u, context), (fields) => {
+    // duplicates not allowed
+    const filtered = new Set(fields);
+    return filtered.size === fields.length
+        ? t.success(fields)
+        : t.failure(u, context, "Fields have duplicates.");
+}), (a) => a);
+const CustomTypeLevel2Field = t.union([
+    t.strict({
+        id: t.string,
+        fields: CustomTypeLevel2FieldGroupFields,
+    }),
+    t.string,
+]);
+const CustomTypeLevel2Fields = new t.Type("CustomTypeLevel2Fields", (u) => Array.isArray(u) && u.every((item) => CustomTypeLevel2Field.is(item)), (u, context) => Either_1.either.chain(t.array(CustomTypeLevel2Field).validate(u, context), (fields) => {
+    // duplicates not allowed
+    const filtered = new Set(fields.map((field) => (typeof field === "string" ? field : field.id)));
+    return filtered.size === fields.length
+        ? t.success(fields)
+        : t.failure(u, context, "Fields have duplicates.");
+}), (a) => a);
+const CustomTypeLevel2 = t.union([
+    t.string,
+    t.strict({
+        id: t.string,
+        fields: CustomTypeLevel2Fields,
+    }),
+]);
+const CustomTypesLevel2 = new t.Type("CustomTypesLevel2", (u) => Array.isArray(u) && u.every((item) => CustomTypeLevel2.is(item)), (u, context) => Either_1.either.chain(t.array(CustomTypeLevel2).validate(u, context), (cts) => {
+    // duplicates not allowed
+    const filtered = new Set(cts.map((ct) => (typeof ct === "string" ? ct : ct.id)));
+    return filtered.size === cts.length
+        ? t.success(cts)
+        : t.failure(u, context, "Custom types have duplicates.");
+}), (a) => a);
+const CustomTypeLevel1FieldCustomTypes = t.strict({
+    id: t.string,
+    customtypes: CustomTypesLevel2,
+});
+const CustomTypeLevel1FieldGroupField = t.union([
+    CustomTypeLevel1FieldCustomTypes,
+    t.string,
+]);
+const CustomTypeLevel1FieldGroupFields = new t.Type("CustomTypeLevel1FieldGroupFields", (u) => Array.isArray(u) &&
+    u.every((item) => CustomTypeLevel1FieldGroupField.is(item)), (u, context) => Either_1.either.chain(t.array(CustomTypeLevel1FieldGroupField).validate(u, context), (fields) => {
+    // duplicates not allowed
+    const filtered = new Set(fields.map((field) => (typeof field === "string" ? field : field.id)));
+    return filtered.size === fields.length
+        ? t.success(fields)
+        : t.failure(u, context, "Fields have duplicates.");
+}), (a) => a);
+const CustomTypeLevel1Field = t.union([
+    t.strict({
+        id: t.string,
+        fields: CustomTypeLevel1FieldGroupFields,
+    }),
+    CustomTypeLevel1FieldCustomTypes,
+    t.string,
+]);
+const CustomTypeLevel1Fields = new t.Type("CustomTypeLevel1Fields", (u) => Array.isArray(u) && u.every((item) => CustomTypeLevel1Field.is(item)), (u, context) => Either_1.either.chain(t.array(CustomTypeLevel1Field).validate(u, context), (fields) => {
+    // duplicates not allowed
+    const filtered = new Set(fields.map((field) => (typeof field === "string" ? field : field.id)));
+    return filtered.size === fields.length
+        ? t.success(fields)
+        : t.failure(u, context, "Fields have duplicates.");
+}), (a) => a);
+const CustomTypeLevel1 = t.union([
+    t.string,
+    t.strict({
+        id: t.string,
+        fields: CustomTypeLevel1Fields,
+    }),
+]);
+exports.CustomTypes = new t.Type("CustomTypes", (u) => Array.isArray(u) && u.every((item) => CustomTypeLevel1.is(item)), (u, context) => Either_1.either.chain(t.array(CustomTypeLevel1).validate(u, context), (cts) => {
+    // if a ct appears more than once as a string, we allow it (legacy)
+    // if a ct appears once as a string and then again via object (or vice versa), we don't allow it
+    // if a ct appears more than once as an object, we don't allow it
+    const strings = new Set();
+    const objects = new Set();
+    for (const ct of cts) {
+        let failed = false;
+        if (typeof ct === "string") {
+            failed = objects.has(ct);
+            strings.add(ct);
+        }
+        else {
+            const { id } = ct;
+            failed = strings.has(id) || objects.has(id);
+            objects.add(id);
+        }
+        if (failed)
+            return t.failure(u, context, "Custom types have duplicates.");
+    }
+    if (objects.size > 1) {
+        return t.failure(u, context, "Cannot have multiple custom types with fields selection.");
+    }
+    if (strings.size > 0 && objects.size > 0) {
+        return t.failure(u, context, "Cannot mix custom types as strings and objects with fields.");
+    }
+    return t.success(cts);
+}), (a) => a);
+exports.LinkFieldType = "Link";
+exports.LinkConfig = t.exact(t.partial({
+    label: validators_1.StringOrNull,
+    useAsTitle: t.boolean,
+    placeholder: t.string,
+    select: (0, withFallback_1.withFallback)(t.union([
+        t.literal("media"),
+        t.literal("document"),
+        t.literal("web"),
+        t.null,
+    ]), null),
+    customtypes: exports.CustomTypes,
+    masks: MasksArrayString,
+    tags: MasksArrayString,
+    allowTargetBlank: t.boolean,
+    allowText: t.boolean,
+    /**
+     * `repeat` property is used to allow multiple links to be added.
+     * `undefined` means that the field is not repeatable (hence repeat = false).
+     */
+    repeat: t.boolean,
+    /**
+     * `variants` allows an option to be picked from a list (e.g. "primary"). To
+     * be considered, the list must have at least one item.
+     */
+    variants: t.array(t.string),
+}));
+exports.Link = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.LinkFieldType),
+    }),
+    t.partial({
+        fieldset: validators_1.StringOrNull,
+        config: exports.LinkConfig,
+    }),
+]));

package/lib/src/customtypes/widgets/nestable/NestableWidget.d.ts

@@ -0,0 +1,217 @@
+import * as t from "io-ts";
+export declare const NestableWidget: t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Color">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Boolean">;
+}>, t.PartialC<{
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        default_value: t.BooleanC;
+        placeholder_true: t.StringC;
+        placeholder_false: t.StringC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Embed">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        useAsTitle: t.BooleanC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"GeoPoint">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Date">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        default: t.StringC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Number">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        min: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+        max: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+        step: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Range">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        min: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+        max: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+        step: t.UnionC<[t.NumberC, import("io-ts-types").NumberFromStringC]>;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"StructuredText">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        useAsTitle: t.BooleanC;
+        single: t.Type<string, string, unknown>;
+        multi: t.Type<string, string, unknown>;
+        imageConstraint: t.PartialC<{
+            width: t.Type<number | null, unknown, unknown>;
+            height: t.Type<number | null, unknown, unknown>;
+        }>;
+        labels: t.Type<readonly string[], object, unknown>;
+        allowTargetBlank: t.BooleanC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Select">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        default_value: t.StringC;
+        options: t.ReadonlyArrayC<t.UnionC<[t.StringC, t.Type<string, string, unknown>, t.Type<string, string, unknown>]>>;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Separator">;
+}>, t.PartialC<{
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Table">;
+}>, t.PartialC<{
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Text">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        useAsTitle: t.BooleanC;
+        placeholder: t.StringC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Timestamp">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        default: t.StringC;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Link">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        useAsTitle: t.BooleanC;
+        placeholder: t.StringC;
+        select: t.UnionC<[t.LiteralC<"media">, t.LiteralC<"document">, t.LiteralC<"web">, t.NullC]>;
+        customtypes: t.Type<readonly (string | {
+            id: string;
+            fields: readonly (string | {
+                id: string;
+                customtypes: readonly (string | {
+                    id: string;
+                    fields: readonly (string | {
+                        id: string;
+                        fields: readonly string[];
+                    })[];
+                })[];
+            } | {
+                id: string;
+                fields: readonly (string | {
+                    id: string;
+                    customtypes: readonly (string | {
+                        id: string;
+                        fields: readonly (string | {
+                            id: string;
+                            fields: readonly string[];
+                        })[];
+                    })[];
+                })[];
+            })[];
+        })[], readonly (string | {
+            id: string;
+            fields: readonly (string | {
+                id: string;
+                customtypes: readonly (string | {
+                    id: string;
+                    fields: readonly (string | {
+                        id: string;
+                        fields: readonly string[];
+                    })[];
+                })[];
+            } | {
+                id: string;
+                fields: readonly (string | {
+                    id: string;
+                    customtypes: readonly (string | {
+                        id: string;
+                        fields: readonly (string | {
+                            id: string;
+                            fields: readonly string[];
+                        })[];
+                    })[];
+                })[];
+            })[];
+        })[], unknown>;
+        masks: t.Type<readonly string[], object, unknown>;
+        tags: t.Type<readonly string[], object, unknown>;
+        allowTargetBlank: t.BooleanC;
+        allowText: t.BooleanC;
+        repeat: t.BooleanC;
+        variants: t.ArrayC<t.StringC>;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Image">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        constraint: t.PartialC<{
+            width: t.Type<number | null, unknown, unknown>;
+            height: t.Type<number | null, unknown, unknown>;
+        }>;
+        thumbnails: t.ReadonlyArrayC<t.ExactC<t.IntersectionC<[t.TypeC<{
+            name: t.StringC;
+        }>, t.PartialC<{
+            width: t.Type<number | null, unknown, unknown>;
+            height: t.Type<number | null, unknown, unknown>;
+        }>]>>>;
+    }>>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"IntegrationFields">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        catalog: t.StringC;
+    }>>;
+}>]>>]>;
+export declare type NestableWidget = t.TypeOf<typeof NestableWidget>;
+export declare type NestableFieldTypes = NestableWidget["type"];

package/lib/src/customtypes/widgets/nestable/NestableWidget.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestableWidget = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const BooleanField_1 = require("./BooleanField");
+const Color_1 = require("./Color");
+const Date_1 = require("./Date");
+const Embed_1 = require("./Embed");
+const GeoPoint_1 = require("./GeoPoint");
+const Image_1 = require("./Image");
+const IntegrationField_1 = require("./IntegrationField");
+const Link_1 = require("./Link");
+const Number_1 = require("./Number");
+const Range_1 = require("./Range");
+const RichText_1 = require("./RichText");
+const Select_1 = require("./Select");
+const Separator_1 = require("./Separator");
+const Table_1 = require("./Table");
+const Text_1 = require("./Text");
+const Timestamp_1 = require("./Timestamp");
+exports.NestableWidget = t.union([
+    Color_1.Color,
+    BooleanField_1.BooleanField,
+    Embed_1.Embed,
+    GeoPoint_1.GeoPoint,
+    Date_1.Date,
+    Number_1.Number,
+    Range_1.Range,
+    RichText_1.RichText,
+    Select_1.Select,
+    Separator_1.Separator,
+    Table_1.Table,
+    Text_1.Text,
+    Timestamp_1.Timestamp,
+    Link_1.Link,
+    Image_1.Image,
+    IntegrationField_1.IntegrationField,
+]);

package/lib/src/customtypes/widgets/nestable/Number.d.ts

@@ -0,0 +1,23 @@
+import * as t from "io-ts";
+export declare const NumberFieldType = "Number";
+export declare const NumberConfig: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    placeholder: t.StringC;
+    min: t.UnionC<[t.NumberC, import("io-ts-types/lib/NumberFromString").NumberFromStringC]>;
+    max: t.UnionC<[t.NumberC, import("io-ts-types/lib/NumberFromString").NumberFromStringC]>;
+    step: t.UnionC<[t.NumberC, import("io-ts-types/lib/NumberFromString").NumberFromStringC]>;
+}>>;
+export declare type NumberConfig = t.TypeOf<typeof NumberConfig>;
+export declare const Number: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Number">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        min: t.UnionC<[t.NumberC, import("io-ts-types/lib/NumberFromString").NumberFromStringC]>;
+        max: t.UnionC<[t.NumberC, import("io-ts-types/lib/NumberFromString").NumberFromStringC]>;
+        step: t.UnionC<[t.NumberC, import("io-ts-types/lib/NumberFromString").NumberFromStringC]>;
+    }>>;
+}>]>>;
+export declare type Number = t.TypeOf<typeof Number>;

package/lib/src/customtypes/widgets/nestable/Number.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Number = exports.NumberConfig = exports.NumberFieldType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const NumberFromString_1 = require("io-ts-types/lib/NumberFromString");
+const validators_1 = require("../../../validators");
+exports.NumberFieldType = "Number";
+exports.NumberConfig = t.exact(t.partial({
+    label: validators_1.StringOrNull,
+    placeholder: t.string,
+    min: t.union([t.number, NumberFromString_1.NumberFromString]),
+    max: t.union([t.number, NumberFromString_1.NumberFromString]),
+    step: t.union([t.number, NumberFromString_1.NumberFromString]),
+}));
+exports.Number = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.NumberFieldType),
+    }),
+    t.partial({
+        fieldset: validators_1.StringOrNull,
+        config: exports.NumberConfig,
+    }),
+]));

package/lib/src/customtypes/widgets/nestable/Range.d.ts

@@ -0,0 +1,23 @@
+import * as t from "io-ts";
+export declare const RangeFieldType = "Range";
+export declare const RangeConfig: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    placeholder: t.StringC;
+    min: t.UnionC<[t.NumberC, import("io-ts-types/lib/NumberFromString").NumberFromStringC]>;
+    max: t.UnionC<[t.NumberC, import("io-ts-types/lib/NumberFromString").NumberFromStringC]>;
+    step: t.UnionC<[t.NumberC, import("io-ts-types/lib/NumberFromString").NumberFromStringC]>;
+}>>;
+export declare type RangeConfig = t.TypeOf<typeof RangeConfig>;
+export declare const Range: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Range">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        min: t.UnionC<[t.NumberC, import("io-ts-types/lib/NumberFromString").NumberFromStringC]>;
+        max: t.UnionC<[t.NumberC, import("io-ts-types/lib/NumberFromString").NumberFromStringC]>;
+        step: t.UnionC<[t.NumberC, import("io-ts-types/lib/NumberFromString").NumberFromStringC]>;
+    }>>;
+}>]>>;
+export declare type Range = t.TypeOf<typeof Range>;

package/lib/src/customtypes/widgets/nestable/Range.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Range = exports.RangeConfig = exports.RangeFieldType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const NumberFromString_1 = require("io-ts-types/lib/NumberFromString");
+const validators_1 = require("../../../validators");
+exports.RangeFieldType = "Range";
+exports.RangeConfig = t.exact(t.partial({
+    label: validators_1.StringOrNull,
+    placeholder: t.string,
+    min: t.union([t.number, NumberFromString_1.NumberFromString]),
+    max: t.union([t.number, NumberFromString_1.NumberFromString]),
+    step: t.union([t.number, NumberFromString_1.NumberFromString]),
+}));
+exports.Range = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.RangeFieldType),
+    }),
+    t.partial({
+        fieldset: validators_1.StringOrNull,
+        config: exports.RangeConfig,
+    }),
+]));

package/lib/src/customtypes/widgets/nestable/RichText.d.ts

@@ -0,0 +1,73 @@
+import * as t from "io-ts";
+export declare const RichTextFieldType = "StructuredText";
+export declare const DEFAULT_OPTION = "paragraph";
+export declare type RichTextNodeType = typeof RichTextNodeType[keyof typeof RichTextNodeType];
+export declare const RichTextNodeType: {
+    readonly heading1: "heading1";
+    readonly heading2: "heading2";
+    readonly heading3: "heading3";
+    readonly heading4: "heading4";
+    readonly heading5: "heading5";
+    readonly heading6: "heading6";
+    readonly paragraph: "paragraph";
+    readonly strong: "strong";
+    readonly em: "em";
+    readonly preformatted: "preformatted";
+    readonly hyperlink: "hyperlink";
+    readonly image: "image";
+    readonly embed: "embed";
+    readonly list: "list-item";
+    readonly orderedList: "o-list-item";
+    readonly rtl: "rtl";
+};
+export declare const RichTextNodeTypeCodec: t.KeyofC<{
+    heading1: null;
+    heading2: null;
+    heading3: null;
+    heading4: null;
+    heading5: null;
+    heading6: null;
+    paragraph: null;
+    strong: null;
+    em: null;
+    preformatted: null;
+    hyperlink: null;
+    image: null;
+    embed: null;
+    "list-item": null;
+    "o-list-item": null;
+    rtl: null;
+}>;
+export declare const RichTextConfig: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    placeholder: t.StringC;
+    useAsTitle: t.BooleanC;
+    single: t.Type<string, string, unknown>;
+    multi: t.Type<string, string, unknown>;
+    imageConstraint: t.PartialC<{
+        width: t.Type<number | null, unknown, unknown>;
+        height: t.Type<number | null, unknown, unknown>;
+    }>;
+    labels: t.Type<readonly string[], object, unknown>;
+    allowTargetBlank: t.BooleanC;
+}>>;
+export declare type RichTextConfig = t.TypeOf<typeof RichTextConfig>;
+export declare const RichText: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"StructuredText">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        useAsTitle: t.BooleanC;
+        single: t.Type<string, string, unknown>;
+        multi: t.Type<string, string, unknown>;
+        imageConstraint: t.PartialC<{
+            width: t.Type<number | null, unknown, unknown>;
+            height: t.Type<number | null, unknown, unknown>;
+        }>;
+        labels: t.Type<readonly string[], object, unknown>;
+        allowTargetBlank: t.BooleanC;
+    }>>;
+}>]>>;
+export declare type RichText = t.TypeOf<typeof RichText>;