@prismicio/types-internal 1.5.3 → 2.0.0-alpha.0

package/lib/content/fields/index.js

@@ -1,25 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WidgetTypes = exports.WidgetContent = void 0;
 const tslib_1 = require("tslib");
-const t = (0, tslib_1.__importStar)(require("io-ts"));
-const GroupContent_1 = require("./GroupContent");
-const nestable_1 = require("./nestable");
-const slices_1 = require("./slices");
-const UIDContent_1 = require("./UIDContent");
 (0, tslib_1.__exportStar)(require("./GroupContent"), exports);
 (0, tslib_1.__exportStar)(require("./nestable"), exports);
 (0, tslib_1.__exportStar)(require("./slices"), exports);
 (0, tslib_1.__exportStar)(require("./UIDContent"), exports);
-exports.WidgetContent = t.union([
-    GroupContent_1.GroupContent,
-    nestable_1.NestableContent,
-    UIDContent_1.UIDContent,
-    slices_1.SlicesContent,
-]);
-exports.WidgetTypes = {
-    ...nestable_1.NestableTypes,
-    UID: UIDContent_1.UIDContentType,
-    Group: GroupContent_1.GroupContentType,
-    slices: slices_1.SlicesContentType,
-};
+(0, tslib_1.__exportStar)(require("./WidgetContent"), exports);

package/lib/content/fields/nestable/BooleanContent.d.ts

@@ -1,7 +1,16 @@
 import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
+export declare const BooleanContentType = "BooleanContent";
+export declare const isBooleanContent: (u: unknown) => u is {
+    __TYPE__: "BooleanContent";
+    value: boolean;
+};
+export declare const BooleanLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    __TYPE__: "BooleanContent";
+    value: boolean;
+}, WithTypes<boolean>, unknown>;
 export declare const BooleanContent: t.ExactC<t.TypeC<{
     __TYPE__: t.LiteralC<"BooleanContent">;
     value: t.BooleanC;
 }>>;
 export declare type BooleanContent = t.TypeOf<typeof BooleanContent>;
-export declare const BooleanContentType = "BooleanContent";

package/lib/content/fields/nestable/BooleanContent.js

@@ -1,11 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BooleanContentType = exports.BooleanContent = void 0;
+exports.BooleanContent = exports.BooleanLegacy = exports.isBooleanContent = exports.BooleanContentType = void 0;
 const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
-const BooleanContent_1 = require("../../../documents/widgets/nestable/BooleanContent");
+const utils_1 = require("../../utils");
+exports.BooleanContentType = "BooleanContent";
+const isBooleanContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.BooleanContentType;
+exports.isBooleanContent = isBooleanContent;
+const BooleanLegacy = (ctx) => new t.Type("BooleanLegacy", exports.isBooleanContent, (u) => {
+    return (0, function_1.pipe)(t.boolean.decode(u), fp_ts_1.either.map((b) => exports.BooleanContent.encode({ value: b, __TYPE__: exports.BooleanContentType })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: "Boolean" },
+    };
+});
+exports.BooleanLegacy = BooleanLegacy;
 exports.BooleanContent = t.strict({
-    __TYPE__: t.literal(BooleanContent_1.BooleanContentType),
+    __TYPE__: t.literal(exports.BooleanContentType),
     value: t.boolean,
 });
-exports.BooleanContentType = BooleanContent_1.BooleanContentType;

package/lib/content/fields/nestable/EmbedContent.d.ts

@@ -1,5 +1,7 @@
 import * as t from "io-ts";
-export declare const EmbedContent: t.IntersectionC<[t.Type<{
+import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
+export declare const EmbedContentType = "EmbedContent";
+export declare const isEmbedContent: (u: unknown) => u is {
     embed_url: string;
     type: string;
 } & {
@@ -14,7 +16,27 @@ export declare const EmbedContent: t.IntersectionC<[t.Type<{
     thumbnail_width?: number | null | undefined;
     thumbnail_height?: number | null | undefined;
     html?: string | null | undefined;
-}, {
+} & {
+    __TYPE__: "EmbedContent";
+};
+export declare const EmbedContentLegacy: t.ExactC<t.IntersectionC<[t.TypeC<{
+    embed_url: t.StringC;
+    type: t.StringC;
+}>, t.PartialC<{
+    version: t.UnionC<[t.StringC, t.NumberC, t.NullC]>;
+    title: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    author_name: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    author_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    provider_name: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    provider_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    cache_age: t.UnionC<[t.StringC, t.NumberC, t.NullC]>;
+    thumbnail_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    thumbnail_width: t.UnionC<[t.Type<number, number, unknown>, t.NullC, t.UndefinedC]>;
+    thumbnail_height: t.UnionC<[t.Type<number, number, unknown>, t.NullC, t.UndefinedC]>;
+    html: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>]>>;
+export declare type EmbedLegacy = t.TypeOf<typeof EmbedContentLegacy>;
+export declare const EmbedLegacy: (ctx: LegacyContentCtx) => t.Type<{
     embed_url: string;
     type: string;
 } & {
@@ -31,9 +53,38 @@ export declare const EmbedContent: t.IntersectionC<[t.Type<{
     html?: string | null | undefined;
 } & {
     __TYPE__: "EmbedContent";
-}, unknown>, t.ExactC<t.TypeC<{
+}, WithTypes<{
+    embed_url: string;
+    type: string;
+} & {
+    version?: string | number | null;
+    title?: string | null | undefined;
+    author_name?: string | null | undefined;
+    author_url?: string | null | undefined;
+    provider_name?: string | null | undefined;
+    provider_url?: string | null | undefined;
+    cache_age?: string | number | null;
+    thumbnail_url?: string | null | undefined;
+    thumbnail_width?: number | null | undefined;
+    thumbnail_height?: number | null | undefined;
+    html?: string | null | undefined;
+}>, unknown>;
+export declare const EmbedContent: t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+    embed_url: t.StringC;
+    type: t.StringC;
+}>, t.PartialC<{
+    version: t.UnionC<[t.StringC, t.NumberC, t.NullC]>;
+    title: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    author_name: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    author_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    provider_name: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    provider_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    cache_age: t.UnionC<[t.StringC, t.NumberC, t.NullC]>;
+    thumbnail_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    thumbnail_width: t.UnionC<[t.Type<number, number, unknown>, t.NullC, t.UndefinedC]>;
+    thumbnail_height: t.UnionC<[t.Type<number, number, unknown>, t.NullC, t.UndefinedC]>;
+    html: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>]>>, t.ExactC<t.TypeC<{
     __TYPE__: t.LiteralC<"EmbedContent">;
-    all: t.UnknownC;
 }>>]>;
 export declare type EmbedContent = t.TypeOf<typeof EmbedContent>;
-export declare const EmbedContentType = "EmbedContent";

package/lib/content/fields/nestable/EmbedContent.js

@@ -1,14 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmbedContentType = exports.EmbedContent = void 0;
+exports.EmbedContent = exports.EmbedLegacy = exports.EmbedContentLegacy = exports.isEmbedContent = exports.EmbedContentType = void 0;
 const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
-const EmbedContent_1 = require("../../../documents/widgets/nestable/EmbedContent");
+const Objects_1 = require("../../../utils/Objects");
+const validators_1 = require("../../../validators");
+const utils_1 = require("../../utils");
+exports.EmbedContentType = "EmbedContent";
+const isEmbedContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.EmbedContentType;
+exports.isEmbedContent = isEmbedContent;
+exports.EmbedContentLegacy = t.exact(t.intersection([
+    t.type({
+        embed_url: t.string,
+        type: t.string,
+    }),
+    t.partial({
+        version: t.union([t.string, t.number, t.null]),
+        title: validators_1.StringOrNull,
+        author_name: validators_1.StringOrNull,
+        author_url: validators_1.StringOrNull,
+        provider_name: validators_1.StringOrNull,
+        provider_url: validators_1.StringOrNull,
+        cache_age: t.union([t.string, t.number, t.null]),
+        thumbnail_url: validators_1.StringOrNull,
+        thumbnail_width: validators_1.NumberOrNull,
+        thumbnail_height: validators_1.NumberOrNull,
+        html: validators_1.StringOrNull,
+    }),
+]));
+const EmbedLegacy = (ctx) => new t.Type("EmbedLegacy", exports.isEmbedContent, (u) => {
+    return (0, function_1.pipe)(exports.EmbedContentLegacy.decode(u), fp_ts_1.either.map((embed) => exports.EmbedContent.encode({
+        ...embed,
+        __TYPE__: exports.EmbedContentType,
+    })));
+}, (embed) => {
+    return {
+        content: (0, Objects_1.withOptionals)({
+            embed_url: embed.embed_url,
+            type: embed.type,
+        }, [
+            ["author_name", embed.author_name],
+            ["author_url", embed.author_url],
+            ["cache_age", embed.cache_age],
+            ["html", embed.html],
+            ["provider_name", embed.provider_name],
+            ["provider_url", embed.provider_url],
+            ["thumbnail_height", embed.thumbnail_height],
+            ["thumbnail_width", embed.thumbnail_width],
+            ["thumbnail_url", embed.thumbnail_url],
+            ["title", embed.title],
+            ["version", embed.version],
+        ]),
+        types: { [ctx.keyOfType]: "Embed" },
+    };
+});
+exports.EmbedLegacy = EmbedLegacy;
 exports.EmbedContent = t.intersection([
-    EmbedContent_1.EmbedContentC,
+    exports.EmbedContentLegacy,
     t.strict({
-        __TYPE__: t.literal(EmbedContent_1.EmbedContentType),
-        all: t.unknown,
+        __TYPE__: t.literal(exports.EmbedContentType),
     }),
 ]);
-exports.EmbedContentType = EmbedContent_1.EmbedContentType;

package/lib/content/fields/nestable/FieldContent/ColorContent.d.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+export declare const isColorContent: (u: unknown) => u is {
+    type: "Color";
+    value: string;
+    __TYPE__: "FieldContent";
+};
+export declare const ColorLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    type: "Color";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
+export declare const ColorContent: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Color">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type ColorContent = t.TypeOf<typeof ColorContent>;

package/lib/content/fields/nestable/FieldContent/ColorContent.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorContent = exports.ColorLegacy = exports.isColorContent = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const widgets_1 = require("../../../../customtypes/widgets");
+const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../../validators/TrimmedString"));
+const utils_1 = require("../../../utils");
+const common_1 = require("./common");
+const isColorContent = (u) => (0, utils_1.hasContentType)(u) &&
+    u.__TYPE__ === common_1.FieldContentType &&
+    (0, utils_1.hasFieldContentType)(u) &&
+    u.type === "Color";
+exports.isColorContent = isColorContent;
+const ColorLegacy = (ctx) => new t.Type("ColorLegacy", exports.isColorContent, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.ColorContent.encode({
+        value: f,
+        type: widgets_1.ColorFieldType,
+        __TYPE__: common_1.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: widgets_1.ColorFieldType },
+    };
+});
+exports.ColorLegacy = ColorLegacy;
+exports.ColorContent = t.strict({
+    type: t.literal(widgets_1.ColorFieldType),
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(common_1.FieldContentType),
+});

package/lib/content/fields/nestable/FieldContent/DateContent.d.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+export declare const isDateContent: (u: unknown) => u is {
+    type: "Date";
+    value: string;
+    __TYPE__: "FieldContent";
+};
+export declare const DateLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    type: "Date";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
+export declare const DateContent: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Date">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type DateContent = t.TypeOf<typeof DateContent>;

package/lib/content/fields/nestable/FieldContent/DateContent.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateContent = exports.DateLegacy = exports.isDateContent = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const widgets_1 = require("../../../../customtypes/widgets");
+const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../../validators/TrimmedString"));
+const utils_1 = require("../../../utils");
+const common_1 = require("./common");
+const isDateContent = (u) => (0, utils_1.hasContentType)(u) &&
+    u.__TYPE__ === common_1.FieldContentType &&
+    (0, utils_1.hasFieldContentType)(u) &&
+    u.type === "Date";
+exports.isDateContent = isDateContent;
+const DateLegacy = (ctx) => new t.Type("DateLegacy", exports.isDateContent, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.DateContent.encode({
+        value: f,
+        type: widgets_1.DateFieldType,
+        __TYPE__: common_1.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: widgets_1.DateFieldType },
+    };
+});
+exports.DateLegacy = DateLegacy;
+exports.DateContent = t.strict({
+    type: t.literal(widgets_1.DateFieldType),
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(common_1.FieldContentType),
+});

package/lib/content/fields/nestable/FieldContent/NumberContent.d.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+export declare const isNumberContent: (u: unknown) => u is {
+    type: "Number";
+    value: string;
+    __TYPE__: "FieldContent";
+};
+export declare const NumberLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    type: "Number";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
+export declare const NumberContent: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Number">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type NumberContent = t.TypeOf<typeof NumberContent>;

package/lib/content/fields/nestable/FieldContent/NumberContent.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberContent = exports.NumberLegacy = exports.isNumberContent = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const widgets_1 = require("../../../../customtypes/widgets");
+const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../../validators/TrimmedString"));
+const utils_1 = require("../../../utils");
+const common_1 = require("./common");
+const isNumberContent = (u) => (0, utils_1.hasContentType)(u) &&
+    u.__TYPE__ === common_1.FieldContentType &&
+    (0, utils_1.hasFieldContentType)(u) &&
+    u.type === "Number";
+exports.isNumberContent = isNumberContent;
+const NumberLegacy = (ctx) => new t.Type("NumberLegacy", exports.isNumberContent, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.NumberContent.encode({
+        value: f,
+        type: widgets_1.NumberFieldType,
+        __TYPE__: common_1.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: widgets_1.NumberFieldType },
+    };
+});
+exports.NumberLegacy = NumberLegacy;
+exports.NumberContent = t.strict({
+    type: t.literal(widgets_1.NumberFieldType),
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(common_1.FieldContentType),
+});

package/lib/content/fields/nestable/FieldContent/RangeContent.d.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+export declare const isRangeContent: (u: unknown) => u is {
+    type: "Range";
+    value: string;
+    __TYPE__: "FieldContent";
+};
+export declare const RangeLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    type: "Range";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
+export declare const RangeContent: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Range">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type RangeContent = t.TypeOf<typeof RangeContent>;

package/lib/content/fields/nestable/FieldContent/RangeContent.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RangeContent = exports.RangeLegacy = exports.isRangeContent = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const widgets_1 = require("../../../../customtypes/widgets");
+const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../../validators/TrimmedString"));
+const utils_1 = require("../../../utils");
+const common_1 = require("./common");
+const isRangeContent = (u) => (0, utils_1.hasContentType)(u) &&
+    u.__TYPE__ === common_1.FieldContentType &&
+    (0, utils_1.hasFieldContentType)(u) &&
+    u.type === "Range";
+exports.isRangeContent = isRangeContent;
+const RangeLegacy = (ctx) => new t.Type("RangeLegacy", exports.isRangeContent, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.RangeContent.encode({
+        value: f,
+        type: widgets_1.RangeFieldType,
+        __TYPE__: common_1.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: widgets_1.RangeFieldType },
+    };
+});
+exports.RangeLegacy = RangeLegacy;
+exports.RangeContent = t.strict({
+    type: t.literal(widgets_1.RangeFieldType),
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(common_1.FieldContentType),
+});

package/lib/content/fields/nestable/FieldContent/SelectContent.d.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+export declare const isSelectContent: (u: unknown) => u is {
+    type: "Select";
+    value: string;
+    __TYPE__: "FieldContent";
+};
+export declare const SelectLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    type: "Select";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
+export declare const SelectContent: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Select">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type SelectContent = t.TypeOf<typeof SelectContent>;

package/lib/content/fields/nestable/FieldContent/SelectContent.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectContent = exports.SelectLegacy = exports.isSelectContent = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const widgets_1 = require("../../../../customtypes/widgets");
+const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../../validators/TrimmedString"));
+const utils_1 = require("../../../utils");
+const common_1 = require("./common");
+const isSelectContent = (u) => (0, utils_1.hasContentType)(u) &&
+    u.__TYPE__ === common_1.FieldContentType &&
+    (0, utils_1.hasFieldContentType)(u) &&
+    u.type === "Select";
+exports.isSelectContent = isSelectContent;
+const SelectLegacy = (ctx) => new t.Type("SelectLegacy", exports.isSelectContent, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.SelectContent.encode({
+        value: f,
+        type: widgets_1.SelectFieldType,
+        __TYPE__: common_1.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: widgets_1.SelectFieldType },
+    };
+});
+exports.SelectLegacy = SelectLegacy;
+exports.SelectContent = t.strict({
+    type: t.literal(widgets_1.SelectFieldType),
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(common_1.FieldContentType),
+});

package/lib/content/fields/nestable/FieldContent/TextContent.d.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+export declare const isTextContent: (u: unknown) => u is {
+    type: "Text";
+    value: string;
+    __TYPE__: "FieldContent";
+};
+export declare const TextLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    type: "Text";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
+export declare const TextContent: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Text">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type TextContent = t.TypeOf<typeof TextContent>;

package/lib/content/fields/nestable/FieldContent/TextContent.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextContent = exports.TextLegacy = exports.isTextContent = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const widgets_1 = require("../../../../customtypes/widgets");
+const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../../validators/TrimmedString"));
+const utils_1 = require("../../../utils");
+const common_1 = require("./common");
+const isTextContent = (u) => (0, utils_1.hasContentType)(u) &&
+    u.__TYPE__ === common_1.FieldContentType &&
+    (0, utils_1.hasFieldContentType)(u) &&
+    u.type === "Text";
+exports.isTextContent = isTextContent;
+const TextLegacy = (ctx) => new t.Type("TextLegacy", exports.isTextContent, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.TextContent.encode({
+        value: f,
+        type: widgets_1.TextFieldType,
+        __TYPE__: common_1.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: widgets_1.TextFieldType },
+    };
+});
+exports.TextLegacy = TextLegacy;
+exports.TextContent = t.strict({
+    type: t.literal(widgets_1.TextFieldType),
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(common_1.FieldContentType),
+});

package/lib/content/fields/nestable/FieldContent/TimestampContent.d.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+export declare const isTimestampContent: (u: unknown) => u is {
+    type: "Timestamp";
+    value: string;
+    __TYPE__: "FieldContent";
+};
+export declare const TimestampLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    type: "Timestamp";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
+export declare const TimestampContent: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Timestamp">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type TimestampContent = t.TypeOf<typeof TimestampContent>;

package/lib/content/fields/nestable/FieldContent/TimestampContent.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimestampContent = exports.TimestampLegacy = exports.isTimestampContent = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const widgets_1 = require("../../../../customtypes/widgets");
+const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../../validators/TrimmedString"));
+const utils_1 = require("../../../utils");
+const common_1 = require("./common");
+const isTimestampContent = (u) => (0, utils_1.hasContentType)(u) &&
+    u.__TYPE__ === common_1.FieldContentType &&
+    (0, utils_1.hasFieldContentType)(u) &&
+    u.type === "Timestamp";
+exports.isTimestampContent = isTimestampContent;
+const TimestampLegacy = (ctx) => new t.Type("TimestampLegacy", exports.isTimestampContent, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.TimestampContent.encode({
+        value: f,
+        type: widgets_1.TimestampFieldType,
+        __TYPE__: common_1.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: widgets_1.TimestampFieldType },
+    };
+});
+exports.TimestampLegacy = TimestampLegacy;
+exports.TimestampContent = t.strict({
+    type: t.literal(widgets_1.TimestampFieldType),
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(common_1.FieldContentType),
+});

package/lib/content/fields/nestable/FieldContent/common.d.ts

@@ -0,0 +1 @@
+export declare const FieldContentType = "FieldContent";

package/lib/content/fields/nestable/FieldContent/common.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldContentType = void 0;
+exports.FieldContentType = "FieldContent";