@prismicio/types-internal 2.2.1 → 2.3.0

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

@@ -0,0 +1,6 @@
+import * as t from "io-ts";
+import { ImportEmbedBlockType } from "./ImportEmbedBlock";
+import { ImportImageBlockType } from "./ImportImageBlock";
+import { ImportTextBlockType } from "./ImportTextBlock";
+export declare type ImportBlockType = ImportTextBlockType | ImportImageBlockType | ImportEmbedBlockType;
+export declare const ImportBlockType: (allowedBlockTypes: string[]) => t.Type<ImportBlockType, ImportBlockType, unknown>;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportBlockType = void 0;
+const tslib_1 = require("tslib");
+const E = (0, tslib_1.__importStar)(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_2 = require("../../../../../../validators/function");
+const ImportEmbedBlock_1 = require("./ImportEmbedBlock");
+const ImportImageBlock_1 = require("./ImportImageBlock");
+const ImportTextBlock_1 = require("./ImportTextBlock");
+const ImportBlockTypeValidator = (0, function_2.withCustomError)(t.union([ImportTextBlock_1.ImportTextBlockType, ImportImageBlock_1.ImportImageBlockType, ImportEmbedBlock_1.ImportEmbedBlockType]), () => `Invalid block type. Supported block types are: ${Object.keys(ImportTextBlock_1.ImportTextBlockType.keys).join(", ")}, ${ImportImageBlock_1.ImportImageBlockType.value}, ${ImportEmbedBlock_1.ImportEmbedBlockType.value}`);
+const ImportBlockType = (allowedBlockTypes) => new t.Type("ImportBlockType", (u) => ImportBlockTypeValidator.is(u), (u, c) => {
+    return (0, function_1.pipe)(ImportBlockTypeValidator.validate(u, c), E.chain((validBlockType) => allowedBlockTypes.includes(validBlockType)
+        ? t.success(validBlockType)
+        : t.failure(u, c, `The block type '${validBlockType}' is not allowed in your document type. Enable the type for this rich text field to create the document.`)));
+}, t.identity);
+exports.ImportBlockType = ImportBlockType;

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

@@ -0,0 +1,10 @@
+import * as t from "io-ts";
+export declare const ImportEmbedBlockType: t.LiteralC<"embed">;
+export declare type ImportEmbedBlockType = t.TypeOf<typeof ImportEmbedBlockType>;
+export declare const ImportEmbedBlock: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"embed">;
+    oembed: t.ExactC<t.TypeC<{
+        embed_url: t.Type<string, string, unknown>;
+    }>>;
+}>>;
+export declare type ImportEmbedBlock = t.TypeOf<typeof ImportEmbedBlock>;

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,22 @@
+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.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"image">;
+}>, t.IntersectionC<[t.TypeC<{
+    id: t.StringC;
+}>, t.PartialC<{
+    dimensions: t.PartialC<{
+        width: t.NumberC;
+        height: t.NumberC;
+    }>;
+    edit: t.PartialC<{
+        x: t.NumberC;
+        y: t.NumberC;
+        zoom: t.NumberC;
+        background: t.StringC;
+    }>;
+    copyright: t.UnionC<[t.StringC, t.NullC]>;
+    alt: t.UnionC<[t.StringC, t.NullC]>;
+}>]>]>>;
+export declare type ImportImageBlock = t.TypeOf<typeof ImportImageBlock>;

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

@@ -0,0 +1,13 @@
+"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("../../Image/validators");
+exports.ImportImageBlockType = t.literal("image");
+exports.ImportImageBlock = t.exact(t.intersection([
+    t.type({
+        type: exports.ImportImageBlockType,
+    }),
+    validators_1.ImportImageView,
+]));

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

@@ -0,0 +1,78 @@
+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: "strong" | "em";
+    } & {
+        start: number;
+        end: number;
+    }) | ({
+        type: "label";
+        data: {
+            label: string;
+        };
+    } & {
+        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,79 @@
+import * as t from "io-ts";
+declare const SpanType: t.UnionC<[t.LiteralC<"hyperlink">, t.KeyofC<{
+    strong: null;
+    em: null;
+}>, t.LiteralC<"label">]>;
+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;
+    }>;
+}>, t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"label">;
+    data: t.ExactC<t.TypeC<{
+        label: t.StringC;
+    }>>;
+}>, 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: "strong" | "em";
+} & {
+    start: number;
+    end: number;
+}) | ({
+    type: "label";
+    data: {
+        label: string;
+    };
+} & {
+    start: number;
+    end: number;
+}), {
+    type: "label" | "strong" | "em" | "hyperlink";
+}, unknown>;
+export {};

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

@@ -0,0 +1,27 @@
+"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 LabelSpan_1 = require("./spans/LabelSpan");
+const SpanType = (0, function_1.withCustomError)(t.union([spans_1.HyperlinkSpanType, spans_1.TextSpanType, LabelSpan_1.LabelSpanType]), () => `Span 'type' field must be specified and have one of the following values: ${[
+    ...Object.keys(spans_1.TextSpanType.keys),
+    LabelSpan_1.LabelSpanType.value,
+].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, LabelSpan_1.LabelSpan]);
+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 if (LabelSpan_1.LabelSpanType.is(u.type)) {
+        return LabelSpan_1.LabelSpan.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/LabelSpan.d.ts

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+export declare const LabelSpanType: t.LiteralC<"label">;
+export declare const LabelSpan: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"label">;
+    data: t.ExactC<t.TypeC<{
+        label: t.StringC;
+    }>>;
+}>, t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+}>]>>;
+export declare type LabelSpan = t.TypeOf<typeof LabelSpan>;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LabelSpan = exports.LabelSpanType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const SpanLocation_1 = require("./SpanLocation");
+exports.LabelSpanType = t.literal("label");
+exports.LabelSpan = t.exact(t.intersection([
+    t.type({
+        type: exports.LabelSpanType,
+        data: t.strict({
+            label: t.string,
+        }),
+    }),
+    SpanLocation_1.SpanLocation,
+]));

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,15 @@
+import * as t from "io-ts";
+export declare const TextSpanType: t.KeyofC<{
+    strong: null;
+    em: null;
+}>;
+export declare const TextSpan: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.KeyofC<{
+        strong: null;
+        em: 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,20 @@
+"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",
+};
+exports.TextSpanType = t.keyof({
+    [TextSpanTypes.Strong]: null,
+    [TextSpanTypes.Em]: 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

@@ -0,0 +1,53 @@
+import type { TypeOf } from "io-ts";
+import * as t from "io-ts";
+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.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.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: ({
+        link_type: "Web";
+        url: string;
+    } & {
+        target?: string;
+    }) | {
+        link_type: "Document";
+        id: string;
+    } | {
+        link_type: "Media";
+        id: string;
+    } | null;
+}, {
+    link_type: "Document" | "Web" | "Media";
+} | undefined, unknown>;
+export declare type ImportLink = TypeOf<typeof ImportLink>;
+export {};

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+const validators_1 = require("../../../../validators");
+const function_1 = require("../../../../validators/function");
+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.exact(t.intersection([
+    t.type({
+        link_type: t.literal("Web"),
+        url: validators_1.String,
+    }),
+    t.partial({
+        target: validators_1.String,
+    }),
+]));
+const DocumentLink = t.strict({
+    link_type: t.literal("Document"),
+    id: DocumentId_1.DocumentId,
+});
+const MediaLink = t.strict({
+    link_type: t.literal("Media"),
+    id: validators_1.String,
+});
+exports.Link = LinkTypeValidator.pipe(t.union([WebLink, DocumentLink, MediaLink]));
+// This is the default value for the link
+const AnyLink = t.strict({
+    link_type: t.literal("Any"),
+});
+exports.ImportLink = (0, ImportContent_1.ImportContent)("Link", (0, validators_1.DefaultOrElse)(AnyLink)(exports.Link));