@prismicio/types-internal 2.2.0-alpha.16 → 2.2.0-alpha.17

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportEmbedBlock.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportEmbedBlock = exports.ImportEmbedBlockType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const Embed_1 = require("../../Embed");
+exports.ImportEmbedBlockType = t.literal("embed");
+exports.ImportEmbedBlock = t.strict({
+    type: exports.ImportEmbedBlockType,
+    oembed: Embed_1.ImportEmbedValue,
+});

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportImageBlock.d.ts

@@ -0,0 +1,8 @@
+import * as t from "io-ts";
+export declare const ImportImageBlockType: t.LiteralC<"image">;
+export declare type ImportImageBlockType = t.TypeOf<typeof ImportImageBlockType>;
+export declare const ImportImageBlock: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"image">;
+    id: t.StringC;
+}>>;
+export declare type ImportImageBlock = t.TypeOf<typeof ImportImageBlock>;

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportImageBlock.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportImageBlock = exports.ImportImageBlockType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../../../validators");
+exports.ImportImageBlockType = t.literal("image");
+exports.ImportImageBlock = t.strict({
+    type: exports.ImportImageBlockType,
+    id: validators_1.String,
+});

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportTextBlock.d.ts

@@ -0,0 +1,70 @@
+import * as t from "io-ts";
+export declare const ImportTextBlockTypes: {
+    readonly Paragraph: "paragraph";
+    readonly OListItem: "o-list-item";
+    readonly ListItem: "list-item";
+    readonly Heading1: "heading1";
+    readonly Heading2: "heading2";
+    readonly Heading3: "heading3";
+    readonly Heading4: "heading4";
+    readonly Heading5: "heading5";
+    readonly Heading6: "heading6";
+    readonly Preformatted: "preformatted";
+};
+export declare const ImportTextBlockType: t.KeyofC<{
+    paragraph: null;
+    "o-list-item": null;
+    "list-item": null;
+    heading1: null;
+    heading2: null;
+    heading3: null;
+    heading4: null;
+    heading5: null;
+    heading6: null;
+    preformatted: null;
+}>;
+export declare type ImportTextBlockType = t.TypeOf<typeof ImportTextBlockType>;
+export declare const ImportTextBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.KeyofC<{
+        paragraph: null;
+        "o-list-item": null;
+        "list-item": null;
+        heading1: null;
+        heading2: null;
+        heading3: null;
+        heading4: null;
+        heading5: null;
+        heading6: null;
+        preformatted: null;
+    }>;
+    text: t.StringC;
+}>, t.PartialC<{
+    spans: t.ArrayC<t.Type<({
+        type: "hyperlink";
+    } & {
+        start: number;
+        end: number;
+    } & {
+        data: ({
+            link_type: "Web";
+            url: string;
+        } & {
+            target?: string;
+        }) | {
+            link_type: "Document";
+            id: string;
+        } | {
+            link_type: "Media";
+            id: string;
+        };
+    }) | ({
+        type: "label" | "strong" | "em";
+    } & {
+        start: number;
+        end: number;
+    }), {
+        type: "label" | "strong" | "em" | "hyperlink";
+    }, unknown>>;
+    direction: t.UnionC<[t.LiteralC<"ltr">, t.LiteralC<"rtl">]>;
+}>]>>;
+export declare type ImportTextBlock = t.TypeOf<typeof ImportTextBlock>;

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportTextBlock.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportTextBlock = exports.ImportTextBlockType = exports.ImportTextBlockTypes = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../../../validators");
+const function_1 = require("../../../../../../validators/function");
+const Span_1 = require("./Span");
+exports.ImportTextBlockTypes = {
+    Paragraph: "paragraph",
+    OListItem: "o-list-item",
+    ListItem: "list-item",
+    Heading1: "heading1",
+    Heading2: "heading2",
+    Heading3: "heading3",
+    Heading4: "heading4",
+    Heading5: "heading5",
+    Heading6: "heading6",
+    Preformatted: "preformatted",
+};
+exports.ImportTextBlockType = t.keyof({
+    [exports.ImportTextBlockTypes.Paragraph]: null,
+    [exports.ImportTextBlockTypes.OListItem]: null,
+    [exports.ImportTextBlockTypes.ListItem]: null,
+    [exports.ImportTextBlockTypes.Heading1]: null,
+    [exports.ImportTextBlockTypes.Heading2]: null,
+    [exports.ImportTextBlockTypes.Heading3]: null,
+    [exports.ImportTextBlockTypes.Heading4]: null,
+    [exports.ImportTextBlockTypes.Heading5]: null,
+    [exports.ImportTextBlockTypes.Heading6]: null,
+    [exports.ImportTextBlockTypes.Preformatted]: null,
+});
+const TextDirection = (0, function_1.withCustomError)(t.union([t.literal("ltr"), t.literal("rtl")]), () => "The 'direction' property must be one of the following: ltr, rtl");
+exports.ImportTextBlock = t.exact(t.intersection([
+    t.type({
+        type: exports.ImportTextBlockType,
+        text: validators_1.String,
+    }),
+    t.partial({
+        spans: (0, function_1.withCustomError)(t.array(Span_1.Span), () => "The 'spans' field must be an array"),
+        direction: TextDirection,
+    }),
+]));

package/lib/import/validators/fields/nestable/ImportRichText/blocks/Span.d.ts

@@ -0,0 +1,65 @@
+import * as t from "io-ts";
+declare const SpanType: t.UnionC<[t.LiteralC<"hyperlink">, t.KeyofC<{
+    strong: null;
+    em: null;
+    label: null;
+}>]>;
+export declare type SpanType = t.TypeOf<typeof SpanType>;
+declare const SpanShape: t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"hyperlink">;
+}>, t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+}>, t.TypeC<{
+    data: t.Type<({
+        link_type: "Web";
+        url: string;
+    } & {
+        target?: string;
+    }) | {
+        link_type: "Document";
+        id: string;
+    } | {
+        link_type: "Media";
+        id: string;
+    }, {
+        link_type: "Document" | "Web" | "Media";
+    }, unknown>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.KeyofC<{
+        strong: null;
+        em: null;
+        label: null;
+    }>;
+}>, t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+}>]>>]>;
+export declare type Span = t.TypeOf<typeof SpanShape>;
+export declare const Span: t.Type<({
+    type: "hyperlink";
+} & {
+    start: number;
+    end: number;
+} & {
+    data: ({
+        link_type: "Web";
+        url: string;
+    } & {
+        target?: string;
+    }) | {
+        link_type: "Document";
+        id: string;
+    } | {
+        link_type: "Media";
+        id: string;
+    };
+}) | ({
+    type: "label" | "strong" | "em";
+} & {
+    start: number;
+    end: number;
+}), {
+    type: "label" | "strong" | "em" | "hyperlink";
+}, unknown>;
+export {};

package/lib/import/validators/fields/nestable/ImportRichText/blocks/Span.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Span = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("../../../../../../validators/function");
+const spans_1 = require("./spans");
+const SpanType = (0, function_1.withCustomError)(t.union([spans_1.HyperlinkSpanType, spans_1.TextSpanType]), () => `Span 'type' field must be specified and have one of the following values: ${Object.keys(spans_1.TextSpanType.keys).join(", ")} or ${spans_1.HyperlinkSpanType.value}`);
+const SpanTypeValidator = (0, function_1.withCustomError)(t.type({
+    type: SpanType,
+}), () => "Span must be an object");
+const SpanShape = t.union([spans_1.HyperlinkSpan, spans_1.TextSpan]);
+exports.Span = SpanTypeValidator.pipe(new t.Type("Span", (u) => SpanShape.is(u), (u, c) => {
+    if (spans_1.HyperlinkSpanType.is(u.type)) {
+        return spans_1.HyperlinkSpan.validate(u, c);
+    }
+    else {
+        return spans_1.TextSpan.validate(u, c);
+    }
+}, t.identity));

package/lib/import/validators/fields/nestable/ImportRichText/blocks/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ImportBlockType";
+export * from "./ImportEmbedBlock";
+export * from "./ImportImageBlock";
+export * from "./ImportTextBlock";

package/lib/import/validators/fields/nestable/ImportRichText/blocks/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./ImportBlockType"), exports);
+(0, tslib_1.__exportStar)(require("./ImportEmbedBlock"), exports);
+(0, tslib_1.__exportStar)(require("./ImportImageBlock"), exports);
+(0, tslib_1.__exportStar)(require("./ImportTextBlock"), exports);

package/lib/import/validators/fields/nestable/ImportRichText/blocks/spans/HyperlinkSpan.d.ts

@@ -0,0 +1,24 @@
+import * as t from "io-ts";
+export declare const HyperlinkSpanType: t.LiteralC<"hyperlink">;
+export declare type HyperlinkSpanType = t.TypeOf<typeof HyperlinkSpanType>;
+export declare const HyperlinkSpan: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"hyperlink">;
+}>, t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+}>, t.TypeC<{
+    data: t.Type<({
+        link_type: "Web";
+        url: string;
+    } & {
+        target?: string;
+    }) | {
+        link_type: "Document";
+        id: string;
+    } | {
+        link_type: "Media";
+        id: string;
+    }, {
+        link_type: "Document" | "Web" | "Media";
+    }, unknown>;
+}>]>>;

package/lib/import/validators/fields/nestable/ImportRichText/blocks/spans/HyperlinkSpan.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperlinkSpan = exports.HyperlinkSpanType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("../../../../../../../validators/function");
+const Link_1 = require("../../../Link");
+const SpanLocation_1 = require("./SpanLocation");
+exports.HyperlinkSpanType = t.literal("hyperlink");
+exports.HyperlinkSpan = t.exact(t.intersection([
+    t.type({
+        type: exports.HyperlinkSpanType,
+    }),
+    SpanLocation_1.SpanLocation,
+    (0, function_1.withCustomError)(t.type({
+        data: Link_1.Link,
+    }), () => "Hyperlink span must contain a 'data' field with link data"),
+]));

package/lib/import/validators/fields/nestable/ImportRichText/blocks/spans/SpanLocation.d.ts

@@ -0,0 +1,5 @@
+import * as t from "io-ts";
+export declare const SpanLocation: t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+}>;

package/lib/import/validators/fields/nestable/ImportRichText/blocks/spans/SpanLocation.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpanLocation = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../../../../validators");
+exports.SpanLocation = t.type({
+    start: validators_1.Number,
+    end: validators_1.Number,
+});

package/lib/import/validators/fields/nestable/ImportRichText/blocks/spans/TextSpan.d.ts

@@ -0,0 +1,17 @@
+import * as t from "io-ts";
+export declare const TextSpanType: t.KeyofC<{
+    strong: null;
+    em: null;
+    label: null;
+}>;
+export declare const TextSpan: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.KeyofC<{
+        strong: null;
+        em: null;
+        label: null;
+    }>;
+}>, t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+}>]>>;
+export declare type TextSpan = t.TypeOf<typeof TextSpan>;

package/lib/import/validators/fields/nestable/ImportRichText/blocks/spans/TextSpan.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextSpan = exports.TextSpanType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const SpanLocation_1 = require("./SpanLocation");
+const TextSpanTypes = {
+    Strong: "strong",
+    Em: "em",
+    Label: "label",
+};
+exports.TextSpanType = t.keyof({
+    [TextSpanTypes.Strong]: null,
+    [TextSpanTypes.Em]: null,
+    [TextSpanTypes.Label]: null,
+});
+exports.TextSpan = t.exact(t.intersection([
+    t.type({
+        type: exports.TextSpanType,
+    }),
+    SpanLocation_1.SpanLocation,
+]));

package/lib/import/validators/fields/nestable/ImportRichText/blocks/spans/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./HyperlinkSpan";
+export * from "./TextSpan";

package/lib/import/validators/fields/nestable/ImportRichText/blocks/spans/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./HyperlinkSpan"), exports);
+(0, tslib_1.__exportStar)(require("./TextSpan"), exports);

package/lib/import/validators/fields/nestable/ImportRichText/index.d.ts

@@ -0,0 +1,2 @@
+export { ImportBlock } from "./ImportBlock";
+export { ImportRichText } from "./ImportRichText";

package/lib/import/validators/fields/nestable/ImportRichText/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportRichText = exports.ImportBlock = void 0;
+var ImportBlock_1 = require("./ImportBlock");
+Object.defineProperty(exports, "ImportBlock", { enumerable: true, get: function () { return ImportBlock_1.ImportBlock; } });
+var ImportRichText_1 = require("./ImportRichText");
+Object.defineProperty(exports, "ImportRichText", { enumerable: true, get: function () { return ImportRichText_1.ImportRichText; } });

package/lib/import/validators/fields/nestable/Link.d.ts

@@ -1,22 +1,37 @@
 import type { TypeOf } from "io-ts";
 import * as t from "io-ts";
-declare const WebLink: t.IntersectionC<[t.TypeC<{
+declare const WebLink: t.ExactC<t.IntersectionC<[t.TypeC<{
     link_type: t.LiteralC<"Web">;
     url: t.StringC;
 }>, t.PartialC<{
     target: t.StringC;
-}>]>;
+}>]>>;
 export declare type WebLink = t.TypeOf<typeof WebLink>;
-declare const DocumentLink: t.TypeC<{
+declare const DocumentLink: t.ExactC<t.TypeC<{
     link_type: t.LiteralC<"Document">;
     id: t.Type<string, string, unknown>;
-}>;
+}>>;
 export declare type DocumentLink = t.TypeOf<typeof DocumentLink>;
-declare const MediaLink: t.TypeC<{
+declare const MediaLink: t.ExactC<t.TypeC<{
     link_type: t.LiteralC<"Media">;
     id: t.StringC;
-}>;
+}>>;
 export declare type MediaLink = t.TypeOf<typeof MediaLink>;
+export declare const Link: t.Type<({
+    link_type: "Web";
+    url: string;
+} & {
+    target?: string;
+}) | {
+    link_type: "Document";
+    id: string;
+} | {
+    link_type: "Media";
+    id: string;
+}, {
+    link_type: "Document" | "Web" | "Media";
+}, unknown>;
+export declare type Link = TypeOf<typeof Link>;
 export declare const ImportLink: t.Type<{
     type: "Link";
     value: ({

package/lib/import/validators/fields/nestable/Link.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportLink = void 0;
+exports.ImportLink = exports.Link = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const DocumentId_1 = require("../../../../utils/DocumentId");
@@ -10,7 +10,7 @@ const ImportContent_1 = require("../ImportContent");
 const LinkTypeValidator = t.type({
     link_type: (0, function_1.withCustomError)(t.union([t.literal("Web"), t.literal("Document"), t.literal("Media")]), () => "The value must be `Web`, `Document` or `Media`"),
 });
-const WebLink = t.intersection([
+const WebLink = t.exact(t.intersection([
     t.type({
         link_type: t.literal("Web"),
         url: validators_1.String,
@@ -18,18 +18,18 @@ const WebLink = t.intersection([
     t.partial({
         target: validators_1.String,
     }),
-]);
-const DocumentLink = t.type({
+]));
+const DocumentLink = t.strict({
     link_type: t.literal("Document"),
     id: DocumentId_1.DocumentId,
 });
-const MediaLink = t.type({
+const MediaLink = t.strict({
     link_type: t.literal("Media"),
     id: validators_1.String,
 });
-const Link = LinkTypeValidator.pipe(t.union([WebLink, DocumentLink, MediaLink]));
+exports.Link = LinkTypeValidator.pipe(t.union([WebLink, DocumentLink, MediaLink]));
 // This is the default value for the link
-const AnyLink = t.type({
+const AnyLink = t.strict({
     link_type: t.literal("Any"),
 });
-exports.ImportLink = (0, ImportContent_1.ImportContent)("Link", (0, validators_1.DefaultOrElse)(AnyLink)(Link));
+exports.ImportLink = (0, ImportContent_1.ImportContent)("Link", (0, validators_1.DefaultOrElse)(AnyLink)(exports.Link));

package/lib/import/validators/fields/nestable/Nestable.d.ts

@@ -5,12 +5,13 @@ import { ImportDate } from "./Date";
 import { ImportEmbed } from "./Embed";
 import { ImportGeoPoint } from "./GeoPoint";
 import { ImportImage } from "./Image";
+import { ImportRichText } from "./ImportRichText";
 import { ImportLink } from "./Link";
 import { ImportNumber } from "./Number";
 import { ImportSelect } from "./Select";
 import { ImportText } from "./Text";
 import { ImportTimestamp } from "./Timestamp";
-export declare type ImportNestable = ImportBoolean | ImportColor | ImportNumber | ImportSelect | ImportText | ImportDate | ImportTimestamp | ImportEmbed | ImportLink | ImportGeoPoint | ImportImage;
+export declare type ImportNestable = ImportBoolean | ImportColor | ImportNumber | ImportSelect | ImportText | ImportDate | ImportTimestamp | ImportEmbed | ImportLink | ImportGeoPoint | ImportImage | ImportRichText;
 export declare const ImportNestable: {
     is(u: unknown): u is ImportNestable;
     decode: (field: NestableWidget) => (content: unknown) => {
@@ -59,6 +60,9 @@ export declare const ImportNestable: {
         }, {
             link_type: "Document" | "Web" | "Media";
         } | undefined, unknown> | import("io-ts").Type<{
+            type: "StructuredText";
+            value: import("./ImportRichText").ImportBlock[] | null;
+        }, unknown[] | undefined, unknown> | import("io-ts").Type<{
             type: "Number";
             value: number | null;
         }, number | undefined, unknown> | import("io-ts").Type<{
@@ -83,6 +87,9 @@ export declare const ImportNestable: {
         }> | import("fp-ts/lib/Either").Right<{
             type: "Number";
             value: number | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "StructuredText";
+            value: import("./ImportRichText").ImportBlock[] | null;
         }> | import("fp-ts/lib/Either").Right<{
             type: "Link";
             value: ({

package/lib/import/validators/fields/nestable/Nestable.js

@@ -7,6 +7,7 @@ const Date_1 = require("./Date");
 const Embed_1 = require("./Embed");
 const GeoPoint_1 = require("./GeoPoint");
 const Image_1 = require("./Image");
+const ImportRichText_1 = require("./ImportRichText");
 const Link_1 = require("./Link");
 const Number_1 = require("./Number");
 const Select_1 = require("./Select");
@@ -24,7 +25,8 @@ exports.ImportNestable = {
             Embed_1.ImportEmbed.is(u) ||
             Link_1.ImportLink.is(u) ||
             GeoPoint_1.ImportGeoPoint.is(u) ||
-            (0, Image_1.ImportImage)().is(u));
+            (0, Image_1.ImportImage)().is(u) ||
+            (0, ImportRichText_1.ImportRichText)().is(u));
     },
     decode: (field) => {
         return (content) => {
@@ -52,6 +54,8 @@ exports.ImportNestable = {
                         return (0, Image_1.ImportImage)(field);
                     case "GeoPoint":
                         return GeoPoint_1.ImportGeoPoint;
+                    case "StructuredText":
+                        return (0, ImportRichText_1.ImportRichText)(field);
                     default:
                         throw new Error(`Unsupported type of nestable field ${field.type}`);
                 }

package/lib/import/validators/fields/nestable/index.d.ts

@@ -1,10 +1,11 @@
 export * from "./Boolean";
 export * from "./Color";
 export * from "./Date";
-export * from "./Embed";
+export { ImportEmbed } from "./Embed";
 export * from "./GeoPoint";
 export * from "./Image";
 export * from "./Image/index";
+export * from "./ImportRichText";
 export * from "./Link";
 export * from "./Nestable";
 export * from "./Number";

package/lib/import/validators/fields/nestable/index.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportEmbed = void 0;
 const tslib_1 = require("tslib");
 (0, tslib_1.__exportStar)(require("./Boolean"), exports);
 (0, tslib_1.__exportStar)(require("./Color"), exports);
 (0, tslib_1.__exportStar)(require("./Date"), exports);
-(0, tslib_1.__exportStar)(require("./Embed"), exports);
+var Embed_1 = require("./Embed");
+Object.defineProperty(exports, "ImportEmbed", { enumerable: true, get: function () { return Embed_1.ImportEmbed; } });
 (0, tslib_1.__exportStar)(require("./GeoPoint"), exports);
 (0, tslib_1.__exportStar)(require("./Image"), exports);
 (0, tslib_1.__exportStar)(require("./Image/index"), exports);
+(0, tslib_1.__exportStar)(require("./ImportRichText"), exports);
 (0, tslib_1.__exportStar)(require("./Link"), exports);
 (0, tslib_1.__exportStar)(require("./Nestable"), exports);
 (0, tslib_1.__exportStar)(require("./Number"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "2.2.0-alpha.16",
+	"version": "2.2.0-alpha.17",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/import/converters/fields/nestable/Image.ts

@@ -1,11 +1,28 @@
 import type { Asset } from "../../../../common"
 import { getAssetOrThrow } from "../../../../common"
-import type { ImageContent } from "../../../../content"
+import type { ImageContent, ImageContentView } from "../../../../content"
 import { withOptionals } from "../../../../utils/Objects"
 import type { ImageField, ImportImage } from "../../../validators"
+import type { ImportImageBlock } from "../../../validators/fields/nestable/ImportRichText/blocks"
 
-function convertImage(imageField: ImageField, image: Asset) {
-	return withOptionals<Omit<ImageContent, "__TYPE__" | "thumbnails">>(
+function convertImage<Input extends ImageField | ImportImageBlock>(
+	inputImage: Input,
+	image: Asset,
+) {
+	// We can do that because anyway all properties being read
+	const imageField: ImageField = {
+		...inputImage,
+		edit:
+			"edit" in inputImage
+				? inputImage.edit
+				: {
+						x: 0,
+						y: 0,
+						zoom: 1,
+				  },
+		dimensions: "dimensions" in inputImage ? inputImage.dimensions : {},
+	}
+	return withOptionals<ImageContentView>(
 		{
 			origin: {
 				id: image.id,
@@ -57,6 +74,16 @@ function convertThumbnails(
 	)
 }
 
+export const imageBlockConverter = (
+	imageBlock: ImportImageBlock,
+	assets: Record<Asset["id"], Asset | undefined>,
+): ImageContentView => {
+	return convertImage<ImportImageBlock>(
+		imageBlock,
+		getAssetOrThrow(assets)(imageBlock.id),
+	)
+}
+
 // All assets from `imageField` must be present in `assets`
 // If not then function will throw an error
 export const imageConverter = (
@@ -66,7 +93,10 @@ export const imageConverter = (
 	if (!imageField) return
 
 	return {
-		...convertImage(imageField, getAssetOrThrow(assets)(imageField.id)),
+		...convertImage<ImageField>(
+			imageField,
+			getAssetOrThrow(assets)(imageField.id),
+		),
 		thumbnails: convertThumbnails(imageField, assets),
 		__TYPE__: "ImageContent" as const,
 	}

package/src/import/converters/fields/nestable/Nestable.ts

@@ -11,6 +11,7 @@ import {
 	imageConverter,
 	linkConverter,
 	numberConverter,
+	richTextConverter,
 	selectConverter,
 	textConverter,
 	timestampConverter,
@@ -44,6 +45,8 @@ export function convertNestableWidget(
 			return linkConverter(field.value, assets)
 		case "Image":
 			return imageConverter(field.value, assets)
+		case "StructuredText":
+			return richTextConverter(field.value, assets, embeds)
 		default:
 			throw new Error(
 				`Unsupported type of nestable converter ${JSON.stringify(field)}`,