@prismicio/types-internal 0.1.1 → 0.2.3

package/lib/documents/widgets/nestable/StructuredTextContent/Block.d.ts

@@ -0,0 +1,274 @@
+import * as t from "io-ts";
+import EmbedContent from "../EmbedContent";
+export declare const Meta: t.ExactC<t.IntersectionC<[t.PartialC<{
+    data: t.UnknownC;
+}>, t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+    type: t.StringC;
+}>]>>;
+export declare const ValidatedMetas: t.Type<({
+    data?: unknown;
+} & {
+    start: number;
+    end: number;
+    type: string;
+})[], ({
+    data?: unknown;
+} & {
+    start: number;
+    end: number;
+    type: string;
+})[], unknown>;
+export declare const ImageBlockType = "image";
+export declare const ImageBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"image">;
+    data: t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+        origin: t.ExactC<t.TypeC<{
+            id: t.StringC;
+            url: t.StringC;
+            width: t.NumberC;
+            height: t.NumberC;
+        }>>;
+        width: t.NumberC;
+        height: t.NumberC;
+        edit: t.TypeC<{
+            zoom: t.NumberC;
+            crop: t.TypeC<{
+                x: t.NumberC;
+                y: t.NumberC;
+            }>;
+            background: t.StringC;
+        }>;
+    }>, t.PartialC<{
+        url: t.StringC;
+        credits: t.Type<string | null, string | null, unknown>;
+        alt: t.Type<string | null, string | null, unknown>;
+        provider: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>]>>, t.PartialC<{
+        linkTo: t.UnionC<[t.Type<{
+            id: string;
+        } | ({
+            url: string;
+        } & {
+            kind?: "web";
+            target?: string | null | undefined;
+            preview?: {
+                title?: string;
+            } | null | undefined;
+        }) | ({
+            id: string;
+            url: string;
+            name: string;
+            kind: string;
+        } & {
+            date?: string | null | undefined;
+            size?: string | null | undefined;
+        }) | ({
+            id: string;
+            url: string;
+            height: string;
+            width: string;
+            size: string;
+            name: string;
+            kind: string;
+        } & {
+            date?: string | null | undefined;
+        }), ({
+            id: string;
+        } & {
+            __TYPE__: "DocumentLink";
+        }) | ({
+            url: string;
+        } & {
+            kind?: "web";
+            target?: string | null | undefined;
+            preview?: {
+                title?: string;
+            } | null | undefined;
+        } & {
+            __TYPE__: "ExternalLink";
+        }) | {
+            readonly size: string;
+            readonly __TYPE__: "FileLink";
+            readonly id: string;
+            readonly url: string;
+            readonly name: string;
+            readonly kind: string;
+            readonly date?: string | null | undefined;
+        } | ({
+            id: string;
+            url: string;
+            height: string;
+            width: string;
+            size: string;
+            name: string;
+            kind: string;
+        } & {
+            date?: string | null | undefined;
+        } & {
+            __TYPE__: "ImageLink";
+        }), unknown>, t.NullC, t.UndefinedC]>;
+    }>]>;
+}>, t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    direction: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>]>>;
+export declare type ImageBlock = t.TypeOf<typeof ImageBlock>;
+export declare function checkImageBlock(block: Block): block is ImageBlock;
+export declare const EmbedBlockType = "embed";
+export declare const EmbedBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"embed">;
+    data: t.Type<EmbedContent, unknown, unknown>;
+}>, t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    direction: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>]>>;
+export declare type EmbedBlock = t.TypeOf<typeof EmbedBlock>;
+export declare function checkEmbedBlock(block: Block): block is EmbedBlock;
+export declare const TextBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.Type<string, string, unknown>;
+    content: t.IntersectionC<[t.TypeC<{
+        text: t.StringC;
+    }>, t.PartialC<{
+        spans: t.Type<({
+            data?: unknown;
+        } & {
+            start: number;
+            end: number;
+            type: string;
+        })[], ({
+            data?: unknown;
+        } & {
+            start: number;
+            end: number;
+            type: string;
+        })[], unknown>;
+    }>]>;
+}>, t.PartialC<{
+    label: t.StringC;
+    direction: t.StringC;
+}>]>>;
+export declare type TextBlock = t.TypeOf<typeof TextBlock>;
+export declare const Block: t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"image">;
+    data: t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+        origin: t.ExactC<t.TypeC<{
+            id: t.StringC;
+            url: t.StringC;
+            width: t.NumberC;
+            height: t.NumberC;
+        }>>;
+        width: t.NumberC;
+        height: t.NumberC;
+        edit: t.TypeC<{
+            zoom: t.NumberC;
+            crop: t.TypeC<{
+                x: t.NumberC;
+                y: t.NumberC;
+            }>;
+            background: t.StringC;
+        }>;
+    }>, t.PartialC<{
+        url: t.StringC;
+        credits: t.Type<string | null, string | null, unknown>;
+        alt: t.Type<string | null, string | null, unknown>;
+        provider: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>]>>, t.PartialC<{
+        linkTo: t.UnionC<[t.Type<{
+            id: string;
+        } | ({
+            url: string;
+        } & {
+            kind?: "web";
+            target?: string | null | undefined;
+            preview?: {
+                title?: string;
+            } | null | undefined;
+        }) | ({
+            id: string;
+            url: string;
+            name: string;
+            kind: string;
+        } & {
+            date?: string | null | undefined;
+            size?: string | null | undefined;
+        }) | ({
+            id: string;
+            url: string;
+            height: string;
+            width: string;
+            size: string;
+            name: string;
+            kind: string;
+        } & {
+            date?: string | null | undefined;
+        }), ({
+            id: string;
+        } & {
+            __TYPE__: "DocumentLink";
+        }) | ({
+            url: string;
+        } & {
+            kind?: "web";
+            target?: string | null | undefined;
+            preview?: {
+                title?: string;
+            } | null | undefined;
+        } & {
+            __TYPE__: "ExternalLink";
+        }) | {
+            readonly size: string;
+            readonly __TYPE__: "FileLink";
+            readonly id: string;
+            readonly url: string;
+            readonly name: string;
+            readonly kind: string;
+            readonly date?: string | null | undefined;
+        } | ({
+            id: string;
+            url: string;
+            height: string;
+            width: string;
+            size: string;
+            name: string;
+            kind: string;
+        } & {
+            date?: string | null | undefined;
+        } & {
+            __TYPE__: "ImageLink";
+        }), unknown>, t.NullC, t.UndefinedC]>;
+    }>]>;
+}>, t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    direction: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"embed">;
+    data: t.Type<EmbedContent, unknown, unknown>;
+}>, t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    direction: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.Type<string, string, unknown>;
+    content: t.IntersectionC<[t.TypeC<{
+        text: t.StringC;
+    }>, t.PartialC<{
+        spans: t.Type<({
+            data?: unknown;
+        } & {
+            start: number;
+            end: number;
+            type: string;
+        })[], ({
+            data?: unknown;
+        } & {
+            start: number;
+            end: number;
+            type: string;
+        })[], unknown>;
+    }>]>;
+}>, t.PartialC<{
+    label: t.StringC;
+    direction: t.StringC;
+}>]>>]>;
+export declare type Block = t.TypeOf<typeof Block>;

package/lib/documents/widgets/nestable/StructuredTextContent/Block.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Block = exports.TextBlock = exports.checkEmbedBlock = exports.EmbedBlock = exports.EmbedBlockType = exports.checkImageBlock = exports.ImageBlock = exports.ImageBlockType = exports.ValidatedMetas = exports.Meta = void 0;
+const tslib_1 = require("tslib");
+const E = (0, tslib_1.__importStar)(require("fp-ts/lib/Either"));
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../validators");
+const function_1 = require("../../../../validators/function");
+const EmbedContent_1 = (0, tslib_1.__importDefault)(require("../EmbedContent"));
+const ImageContent_1 = require("../ImageContent");
+const Link_1 = require("../Link");
+exports.Meta = t.exact(t.intersection([
+    t.partial({
+        data: t.unknown,
+    }),
+    t.type({
+        start: t.number,
+        end: t.number,
+        type: t.string,
+    }),
+]));
+exports.ValidatedMetas = new t.Type("ValidatedMetas", (metas) => Array.isArray(metas) && metas.every(exports.Meta.is), (metas, c) => {
+    if (Array.isArray(metas)) {
+        const res = metas
+            .reduce((acc, maybeMeta) => {
+            const maybeDecodedMeta = exports.Meta.decode(maybeMeta);
+            if (E.isRight(maybeDecodedMeta)) {
+                const meta = maybeDecodedMeta.right;
+                // if it's an hyperlink it should have data validated as link otherwise we don't care and keep the meta
+                if ((meta.data &&
+                    meta.type === "hyperlink" &&
+                    E.isRight(Link_1.Link.validate(meta.data, c))) ||
+                    meta.type !== "hyperlink") {
+                    return [...acc, meta];
+                }
+            }
+            return acc;
+        }, [])
+            .sort((m1, m2) => m1.start - m2.start);
+        return t.success(res);
+    }
+    else
+        return t.failure(metas, c);
+}, (m) => t.array(exports.Meta).encode(m));
+exports.ImageBlockType = "image";
+exports.ImageBlock = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.ImageBlockType),
+        data: t.intersection([
+            ImageContent_1.ImageContentView,
+            t.partial({
+                linkTo: (0, function_1.nullable)(Link_1.Link),
+            }),
+        ]),
+    }),
+    t.partial({
+        label: validators_1.StringOrNull,
+        direction: validators_1.StringOrNull,
+    }),
+]));
+function checkImageBlock(block) {
+    return block.type === exports.ImageBlockType;
+}
+exports.checkImageBlock = checkImageBlock;
+exports.EmbedBlockType = "embed";
+exports.EmbedBlock = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.EmbedBlockType),
+        data: EmbedContent_1.default,
+    }),
+    t.partial({
+        label: validators_1.StringOrNull,
+        direction: validators_1.StringOrNull,
+    }),
+]));
+function checkEmbedBlock(block) {
+    return block.type === exports.EmbedBlockType;
+}
+exports.checkEmbedBlock = checkEmbedBlock;
+exports.TextBlock = t.exact(t.intersection([
+    t.type({
+        type: (0, function_1.refineType)(t.string, `string which isn't ${exports.ImageBlockType} ${exports.EmbedBlockType}`, (s) => s !== exports.ImageBlockType && s !== exports.EmbedBlockType),
+        content: t.intersection([
+            t.type({
+                text: t.string,
+            }),
+            t.partial({
+                spans: exports.ValidatedMetas,
+            }),
+        ]),
+    }),
+    t.partial({
+        label: t.string,
+        direction: t.string,
+    }),
+]));
+exports.Block = t.union([exports.ImageBlock, exports.EmbedBlock, exports.TextBlock]);

package/lib/documents/widgets/nestable/StructuredTextContent/index.d.ts

@@ -0,0 +1,9 @@
+import * as t from "io-ts";
+import { Block } from "./Block";
+export declare const StructuredTextContentType = "StructuredTextContent";
+export declare type StructuredTextContent = {
+    value: Block[];
+    __TYPE__: typeof StructuredTextContentType;
+};
+export declare const StructuredTextContent: t.Type<StructuredTextContent, string, unknown>;
+export * as Blocks from "./Block";

package/lib/documents/widgets/nestable/StructuredTextContent/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blocks = exports.StructuredTextContent = exports.StructuredTextContentType = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const Block_1 = require("./Block");
+exports.StructuredTextContentType = "StructuredTextContent";
+exports.StructuredTextContent = new t.Type(exports.StructuredTextContentType, (u) => u?.__TYPE__ === exports.StructuredTextContentType, (u, c) => Either_1.Chain.chain(t.array(Block_1.Block).validate(u, c), (u) => {
+    return t.success({ value: u, __TYPE__: exports.StructuredTextContentType });
+}), () => {
+    throw new Error("NotImplementedError: Not relevant method");
+});
+exports.Blocks = (0, tslib_1.__importStar)(require("./Block"));

package/lib/documents/widgets/nestable/index.d.ts

@@ -0,0 +1,26 @@
+export { default as BooleanContent } from "./BooleanContent";
+export { default as EmbedContent } from "./EmbedContent";
+export { default as FieldContent } from "./FieldContent";
+export { type GeoPointContentO, GeoPointContent } from "./GeoPointContent";
+export { type ImageContentO, ImageContent, ImageContentView, } from "./ImageContent";
+export { default as IntegrationFieldsContent } from "./IntegrationFieldsContent";
+export * as Links from "./Link";
+export * from "./SeparatorContent";
+export * from "./StructuredTextContent";
+export declare const NestableTypes: {
+    Links: {
+        DocumentLink: string;
+        FileLink: string;
+        ExternalLink: string;
+        ImageLink: string;
+        LinkContent: string;
+    };
+    StructuredText: string;
+    Boolean: string;
+    Embed: string;
+    Field: string;
+    GeoPoint: string;
+    Image: string;
+    IntegrationFields: string;
+    Separator: string;
+};

package/lib/documents/widgets/nestable/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestableTypes = exports.Links = exports.IntegrationFieldsContent = exports.ImageContentView = exports.ImageContent = exports.GeoPointContent = exports.FieldContent = exports.EmbedContent = exports.BooleanContent = void 0;
+const tslib_1 = require("tslib");
+const BooleanContent_1 = require("./BooleanContent");
+const EmbedContent_1 = require("./EmbedContent");
+const FieldContent_1 = require("./FieldContent");
+const GeoPointContent_1 = require("./GeoPointContent");
+const ImageContent_1 = require("./ImageContent");
+const IntegrationFieldsContent_1 = require("./IntegrationFieldsContent");
+const Link_1 = require("./Link");
+const SeparatorContent_1 = require("./SeparatorContent");
+const StructuredTextContent_1 = require("./StructuredTextContent");
+var BooleanContent_2 = require("./BooleanContent");
+Object.defineProperty(exports, "BooleanContent", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(BooleanContent_2).default; } });
+var EmbedContent_2 = require("./EmbedContent");
+Object.defineProperty(exports, "EmbedContent", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(EmbedContent_2).default; } });
+var FieldContent_2 = require("./FieldContent");
+Object.defineProperty(exports, "FieldContent", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(FieldContent_2).default; } });
+var GeoPointContent_2 = require("./GeoPointContent");
+Object.defineProperty(exports, "GeoPointContent", { enumerable: true, get: function () { return GeoPointContent_2.GeoPointContent; } });
+var ImageContent_2 = require("./ImageContent");
+Object.defineProperty(exports, "ImageContent", { enumerable: true, get: function () { return ImageContent_2.ImageContent; } });
+Object.defineProperty(exports, "ImageContentView", { enumerable: true, get: function () { return ImageContent_2.ImageContentView; } });
+var IntegrationFieldsContent_2 = require("./IntegrationFieldsContent");
+Object.defineProperty(exports, "IntegrationFieldsContent", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(IntegrationFieldsContent_2).default; } });
+exports.Links = (0, tslib_1.__importStar)(require("./Link"));
+(0, tslib_1.__exportStar)(require("./SeparatorContent"), exports);
+(0, tslib_1.__exportStar)(require("./StructuredTextContent"), exports);
+exports.NestableTypes = {
+    Links: Link_1.LinksTypes,
+    StructuredText: StructuredTextContent_1.StructuredTextContentType,
+    Boolean: BooleanContent_1.BooleanContentType,
+    Embed: EmbedContent_1.EmbedContentType,
+    Field: FieldContent_1.FieldContentType,
+    GeoPoint: GeoPointContent_1.GeoPointContentType,
+    Image: ImageContent_1.ImageContentType,
+    IntegrationFields: IntegrationFieldsContent_1.IntegrationFieldsContentType,
+    Separator: SeparatorContent_1.SeparatorContentType,
+};

package/lib/documents/widgets/slices/CompositeSliceContent.d.ts

@@ -0,0 +1,14 @@
+import * as O from "fp-ts/Option";
+import type { GroupItemContent } from "../GroupContent";
+import { SimpleWidgetContent } from "../index";
+export declare const CompositeSliceContentType = "CompositeSliceContent";
+export declare type CompositeSliceContent = {
+    repeat: GroupItemContent[];
+    nonRepeat: {
+        [key: string]: SimpleWidgetContent;
+    };
+    __TYPE__: typeof CompositeSliceContentType;
+};
+export declare const CompositeSliceContent: {
+    fromJson: (prefixes: Array<string>, key: string, value: unknown, fieldTypes: Map<string, string>, fieldPositions: Map<string, number>) => O.Option<CompositeSliceContent>;
+};

package/lib/documents/widgets/slices/CompositeSliceContent.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeSliceContent = exports.CompositeSliceContentType = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const index_1 = require("../index");
+exports.CompositeSliceContentType = "CompositeSliceContent";
+const codec = t.exact(t.partial({
+    repeat: t.array(t.unknown),
+    "non-repeat": t.UnknownRecord,
+}));
+exports.CompositeSliceContent = {
+    fromJson: (prefixes, key, value, fieldTypes, fieldPositions) => {
+        const prefixedRepeatKey = Array.of(prefixes, [key, "repeat"])
+            .flat()
+            .join(".");
+        const decodedValue = codec.decode(value);
+        if ((0, Either_1.isRight)(decodedValue)) {
+            const repeatObj = decodedValue.right.repeat;
+            const nonRepeatObj = decodedValue.right["non-repeat"] ?? {};
+            const groupItemsContentsRepeat = index_1.GroupContent.itemsContentsFromJson(prefixedRepeatKey, repeatObj, fieldTypes, fieldPositions);
+            const sortedFields = Object.entries(nonRepeatObj).sort(([k1], [k2]) => {
+                const p1 = fieldPositions.get(`${Array.of(prefixes, [key]).flat().join(".")}.${k1}`) ?? 10000;
+                const p2 = fieldPositions.get(`${Array.of(prefixes, [key]).flat().join(".")}.${k2}`) ?? 10000;
+                return p1 - p2;
+            });
+            const nonRepeat = sortedFields.reduce((acc, [k, v]) => {
+                const kp = Array.of(prefixes, [key, "non-repeat", k]).flat().join(".");
+                const kind = fieldTypes.get(kp);
+                if (kind) {
+                    const mWidgetContent = index_1.SimpleWidgetContent.from(kind, v);
+                    if (O.isSome(mWidgetContent)) {
+                        acc[k] = mWidgetContent.value;
+                    }
+                }
+                return acc;
+            }, {});
+            return O.some({
+                repeat: groupItemsContentsRepeat,
+                nonRepeat,
+                __TYPE__: "CompositeSliceContent",
+            });
+        }
+        else {
+            return O.none;
+        }
+    },
+};

package/lib/documents/widgets/slices/SharedSliceContent.d.ts

@@ -0,0 +1,15 @@
+import * as O from "fp-ts/Option";
+import type { GroupItemContent } from "../GroupContent";
+import { SimpleWidgetContent } from "../index";
+export declare const SharedSliceContentType = "SharedSliceContent";
+export declare type SharedSliceContent = {
+    variation: string;
+    primary: {
+        [key: string]: SimpleWidgetContent;
+    };
+    items: GroupItemContent[];
+    __TYPE__: typeof SharedSliceContentType;
+};
+export declare const SharedSliceContent: {
+    fromJson: (prefixes: Array<string>, key: string, value: unknown, fieldTypes: Map<string, string>, fieldPositions: Map<string, number>) => O.Option<SharedSliceContent>;
+};

package/lib/documents/widgets/slices/SharedSliceContent.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceContent = exports.SharedSliceContentType = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const io_ts_types_1 = require("io-ts-types");
+const index_1 = require("../index");
+exports.SharedSliceContentType = "SharedSliceContent";
+const codec = t.exact(t.type({
+    variation: t.string,
+    items: (0, io_ts_types_1.withFallback)(t.array(t.unknown), []),
+    primary: (0, io_ts_types_1.withFallback)(t.UnknownRecord, {}),
+}));
+exports.SharedSliceContent = {
+    fromJson: (prefixes, key, value, fieldTypes, fieldPositions) => {
+        const r = (0, Either_1.map)((v) => {
+            const prefixedItemsKey = Array.of(prefixes, [
+                key,
+                "variations",
+                v.variation,
+                "items",
+            ])
+                .flat()
+                .join(".");
+            const groupItemsContents = index_1.GroupContent.itemsContentsFromJson(prefixedItemsKey, v.items, fieldTypes, fieldPositions);
+            const sortedFields = Object.entries(v.primary).sort(([k1], [k2]) => {
+                const p1 = fieldPositions.get(`${Array.of(prefixes, [key]).flat().join(".")}.${k1}`) ?? 10000;
+                const p2 = fieldPositions.get(`${Array.of(prefixes, [key]).flat().join(".")}.${k2}`) ?? 10000;
+                return p1 - p2;
+            });
+            const primary = sortedFields.reduce((acc, [k, w]) => {
+                const kp = Array.of(prefixes, [
+                    key,
+                    "variations",
+                    v.variation,
+                    "primary",
+                    k,
+                ])
+                    .flat()
+                    .join(".");
+                const kind = fieldTypes.get(kp);
+                if (kind) {
+                    const maybeWidgetContent = index_1.SimpleWidgetContent.from(kind, w);
+                    if (O.isSome(maybeWidgetContent)) {
+                        acc[k] = maybeWidgetContent.value;
+                    }
+                }
+                return acc;
+            }, {});
+            const result = {
+                variation: v.variation,
+                primary,
+                items: groupItemsContents,
+                __TYPE__: "SharedSliceContent",
+            };
+            return result;
+        })(codec.decode(value));
+        return O.fromEither(r);
+    },
+};

package/lib/documents/widgets/slices/SimpleSliceContent.d.ts

@@ -0,0 +1,6 @@
+import StaticWidgetContent from "../StaticWidgetContent";
+export declare type SimpleSliceContent = StaticWidgetContent;
+export declare const SimpleSliceContent: {
+    fromJson: (prefixes: string[], key: string, value: unknown, fieldTypes: Map<string, string>, fieldPositions: Map<string, number>) => import("fp-ts/lib/Option").Option<StaticWidgetContent>;
+    is: (value: unknown) => value is StaticWidgetContent;
+};

package/lib/documents/widgets/slices/SimpleSliceContent.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleSliceContent = void 0;
+const tslib_1 = require("tslib");
+const StaticWidgetContent_1 = (0, tslib_1.__importDefault)(require("../StaticWidgetContent"));
+exports.SimpleSliceContent = StaticWidgetContent_1.default;

package/lib/documents/widgets/slices/SliceWidgetContent.d.ts

@@ -0,0 +1,8 @@
+import * as O from "fp-ts/Option";
+import { CompositeSliceContent } from "./CompositeSliceContent";
+import { SharedSliceContent } from "./SharedSliceContent";
+import type { SimpleSliceContent } from "./SimpleSliceContent";
+export declare type SliceWidgetContent = SimpleSliceContent | CompositeSliceContent | SharedSliceContent;
+export declare const SliceWidgetContent: {
+    fromJson: (prefixes: Array<string>, key: string, value: unknown, fieldTypes: Map<string, string>, fieldPositions: Map<string, number>) => O.Option<SliceWidgetContent>;
+};

package/lib/documents/widgets/slices/SliceWidgetContent.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SliceWidgetContent = void 0;
+const tslib_1 = require("tslib");
+const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
+const StaticWidgetContent_1 = (0, tslib_1.__importDefault)(require("../StaticWidgetContent"));
+const CompositeSliceContent_1 = require("./CompositeSliceContent");
+const SharedSliceContent_1 = require("./SharedSliceContent");
+exports.SliceWidgetContent = {
+    fromJson: (prefixes, key, value, fieldTypes, fieldPositions) => {
+        const prefixedKey = Array.of(prefixes, [key]).flat().join(".");
+        const fieldType = fieldTypes.get(prefixedKey);
+        if (fieldType === "SharedSlice") {
+            return SharedSliceContent_1.SharedSliceContent.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
+        }
+        else if (fieldType === "Slice") {
+            return CompositeSliceContent_1.CompositeSliceContent.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
+        }
+        else if (fieldType) {
+            return StaticWidgetContent_1.default.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
+        }
+        else {
+            return O.none;
+        }
+    },
+};