@prismicio/types-internal 0.1.1 → 0.2.0

package/lib/documents/widgets/index.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Widget = exports.WidgetTypes = exports.StaticWidgetContent = exports.Slices = exports.Nestable = void 0;
+const EmptyContent_1 = require("./EmptyContent");
+const GroupContent_1 = require("./GroupContent");
+const nestable_1 = require("./nestable");
+const SlicesContent_1 = require("./slices/SlicesContent");
+const StaticWidgetContent_1 = __importDefault(require("./StaticWidgetContent"));
+const UIDContent_1 = require("./UIDContent");
+__exportStar(require("./EmptyContent"), exports);
+__exportStar(require("./GroupContent"), exports);
+exports.Nestable = __importStar(require("./nestable"));
+__exportStar(require("./SimpleWidgetContent"), exports);
+exports.Slices = __importStar(require("./slices"));
+var StaticWidgetContent_2 = require("./StaticWidgetContent");
+Object.defineProperty(exports, "StaticWidgetContent", { enumerable: true, get: function () { return __importDefault(StaticWidgetContent_2).default; } });
+__exportStar(require("./UIDContent"), exports);
+exports.WidgetTypes = {
+    ...nestable_1.NestableTypes,
+    Empty: EmptyContent_1.EmptyContentType,
+    UID: UIDContent_1.UIDContentType,
+    Group: GroupContent_1.GroupContentType,
+    slices: SlicesContent_1.SlicesContentType,
+};
+exports.Widget = {
+    fromJson(widgetKey, widgetValue, widgetTypes, widgetPositions) {
+        const fieldType = widgetTypes.get(widgetKey);
+        if (fieldType === "Slices") {
+            return SlicesContent_1.SlicesContent.fromJson(widgetKey, widgetValue, widgetTypes, widgetPositions);
+        }
+        else {
+            return StaticWidgetContent_1.default.fromJson([], widgetKey, widgetValue, widgetTypes, widgetPositions);
+        }
+    },
+};

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

@@ -0,0 +1,8 @@
+import * as t from "io-ts";
+declare type BooleanContent = {
+    __TYPE__: "BooleanContent";
+    value: boolean;
+};
+export declare const BooleanContentType = "BooleanContent";
+declare const BooleanContent: t.Type<BooleanContent, boolean, unknown>;
+export default BooleanContent;

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

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanContentType = void 0;
+const Either_1 = require("fp-ts/Either");
+const t = __importStar(require("io-ts"));
+exports.BooleanContentType = "BooleanContent";
+const BooleanContent = new t.Type("BooleanContent", (u) => u?.__TYPE__ === exports.BooleanContentType, (u, c) => Either_1.Chain.chain(t.boolean.validate(u, c), (u) => {
+    return t.success({ value: u, __TYPE__: exports.BooleanContentType });
+}), (booleanContent) => t.boolean.encode(booleanContent.value));
+exports.default = BooleanContent;

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

@@ -0,0 +1,40 @@
+import * as t from "io-ts";
+export declare const EmbedContentType = "EmbedContent";
+declare type EmbedContent = t.OutputOf<typeof EmbedContentC> & {
+    all: unknown;
+};
+declare const EmbedContent: t.Type<EmbedContent, unknown, unknown>;
+declare const EmbedContentC: t.Type<{
+    embed_url: string;
+    type: string;
+} & {
+    version?: string | number | null | undefined;
+    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 | undefined;
+    thumbnail_url?: string | null | undefined;
+    thumbnail_width?: number | null | undefined;
+    thumbnail_height?: number | null | undefined;
+    html?: string | null | undefined;
+}, {
+    embed_url: string;
+    type: string;
+} & {
+    version?: string | number | null | undefined;
+    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 | undefined;
+    thumbnail_url?: string | null | undefined;
+    thumbnail_width?: number | null | undefined;
+    thumbnail_height?: number | null | undefined;
+    html?: string | null | undefined;
+} & {
+    __TYPE__: "EmbedContent";
+}, unknown>;
+export default EmbedContent;

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

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbedContentType = void 0;
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/function");
+const t = __importStar(require("io-ts"));
+const validators_1 = require("../../../validators");
+const function_2 = require("../../../validators/function");
+exports.EmbedContentType = "EmbedContent";
+const EmbedContent = new t.Type("EmbedContent", (u) => u.__TYPE__ === exports.EmbedContentType, (u) => {
+    return (0, function_1.pipe)(EmbedContentC.decode(u), fp_ts_1.either.map((s) => ({
+        ...EmbedContentC.encode(s),
+        all: u,
+    })));
+}, (ec) => EmbedContentC.encode(ec));
+const EmbedContentC = (0, function_2.addType)(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,
+    }),
+])), exports.EmbedContentType);
+exports.default = EmbedContent;

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

@@ -0,0 +1,12 @@
+import * as O from "fp-ts/Option";
+export declare const FieldContentType = "FieldContent";
+declare type FieldContent = {
+    value: string;
+    type: string;
+    __TYPE__: typeof FieldContentType;
+};
+declare const FieldContent: {
+    types: string[];
+    forType: (type: string, value: unknown) => O.Option<FieldContent>;
+};
+export default FieldContent;

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

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldContentType = void 0;
+const function_1 = require("fp-ts/function");
+const O = __importStar(require("fp-ts/Option"));
+const t = __importStar(require("io-ts"));
+exports.FieldContentType = "FieldContent";
+//we do that instead of idiomatic .trim()
+//because we need to have the exact same behaviour than scala/java .trim()
+//in other world only trim space and not non-breaking space or tab
+function trimScalaStyle(s) {
+    let startAt = 0;
+    while (startAt < s.length && s[startAt] <= " ") {
+        startAt++;
+    }
+    let endAt = s.length;
+    while (startAt < endAt && s[endAt - 1] <= " ") {
+        endAt--;
+    }
+    return s.substring(startAt, endAt);
+}
+const FieldContent = {
+    types: ["Text", "Date", "Timestamp", "Color", "Number", "Range", "Select"],
+    forType: (type, value) => {
+        return (0, function_1.pipe)(O.fromEither(t.string.decode(value)), O.map((r) => {
+            return {
+                value: trimScalaStyle(r),
+                type,
+                __TYPE__: "FieldContent",
+            };
+        }));
+    },
+};
+exports.default = FieldContent;

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

@@ -0,0 +1,17 @@
+import * as t from "io-ts";
+export declare const GeoPointContentType = "GeoPointContent";
+export declare const GeoPointContent: t.Type<{
+    position: {
+        lat: number;
+        lng: number;
+    };
+}, {
+    position: {
+        lat: number;
+        lng: number;
+    };
+} & {
+    __TYPE__: "GeoPointContent";
+}, unknown>;
+export declare type GeoPointContent = t.TypeOf<typeof GeoPointContent>;
+export declare type GeoPointContentO = t.OutputOf<typeof GeoPointContent>;

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

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoPointContent = exports.GeoPointContentType = void 0;
+const t = __importStar(require("io-ts"));
+const function_1 = require("../../../validators/function");
+exports.GeoPointContentType = "GeoPointContent";
+exports.GeoPointContent = (0, function_1.addType)(t.strict({
+    position: t.strict({
+        lat: t.number,
+        lng: t.number,
+    }),
+}), exports.GeoPointContentType);

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

@@ -0,0 +1,127 @@
+import * as t from "io-ts";
+export declare const ImageContentView: 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]>;
+}>]>>;
+export declare type ImageContentView = t.TypeOf<typeof ImageContentView>;
+export declare const ImageContentType = "ImageContent";
+export declare const ImageContent: t.Type<{
+    origin: {
+        id: string;
+        url: string;
+        width: number;
+        height: number;
+    };
+    width: number;
+    height: number;
+    edit: {
+        zoom: number;
+        crop: {
+            x: number;
+            y: number;
+        };
+        background: string;
+    };
+} & {
+    url?: string | undefined;
+    credits?: string | null | undefined;
+    alt?: string | null | undefined;
+    provider?: string | null | undefined;
+} & {
+    thumbnails?: {
+        [x: string]: {
+            origin: {
+                id: string;
+                url: string;
+                width: number;
+                height: number;
+            };
+            width: number;
+            height: number;
+            edit: {
+                zoom: number;
+                crop: {
+                    x: number;
+                    y: number;
+                };
+                background: string;
+            };
+        } & {
+            url?: string | undefined;
+            credits?: string | null | undefined;
+            alt?: string | null | undefined;
+            provider?: string | null | undefined;
+        };
+    } | undefined;
+}, {
+    origin: {
+        id: string;
+        url: string;
+        width: number;
+        height: number;
+    };
+    width: number;
+    height: number;
+    edit: {
+        zoom: number;
+        crop: {
+            x: number;
+            y: number;
+        };
+        background: string;
+    };
+} & {
+    url?: string | undefined;
+    credits?: string | null | undefined;
+    alt?: string | null | undefined;
+    provider?: string | null | undefined;
+} & {
+    thumbnails?: {
+        [x: string]: {
+            origin: {
+                id: string;
+                url: string;
+                width: number;
+                height: number;
+            };
+            width: number;
+            height: number;
+            edit: {
+                zoom: number;
+                crop: {
+                    x: number;
+                    y: number;
+                };
+                background: string;
+            };
+        } & {
+            url?: string | undefined;
+            credits?: string | null | undefined;
+            alt?: string | null | undefined;
+            provider?: string | null | undefined;
+        };
+    } | undefined;
+} & {
+    __TYPE__: "ImageContent";
+}, unknown>;
+export declare type ImageContent = t.TypeOf<typeof ImageContent>;
+export declare type ImageContentO = t.OutputOf<typeof ImageContent>;

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

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageContent = exports.ImageContentType = exports.ImageContentView = void 0;
+const t = __importStar(require("io-ts"));
+const validators_1 = require("../../../validators");
+const function_1 = require("../../../validators/function");
+const Origin = t.exact(t.type({
+    id: t.string,
+    url: t.string,
+    width: t.number,
+    height: t.number,
+}));
+exports.ImageContentView = t.exact(t.intersection([
+    t.type({
+        origin: Origin,
+        width: t.number,
+        height: t.number,
+        edit: t.type({
+            zoom: t.number,
+            crop: t.type({
+                x: t.number,
+                y: t.number,
+            }),
+            background: t.string,
+        }),
+    }),
+    t.partial({
+        url: t.string,
+        credits: validators_1.NonEmptyStringOrNull,
+        alt: validators_1.NonEmptyStringOrNull,
+        provider: validators_1.StringOrNull,
+    }),
+]));
+exports.ImageContentType = "ImageContent";
+exports.ImageContent = (0, function_1.addType)(t.intersection([
+    exports.ImageContentView,
+    t.partial({
+        thumbnails: t.record(t.string, exports.ImageContentView),
+    }),
+]), exports.ImageContentType);

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

@@ -0,0 +1,8 @@
+import * as t from "io-ts";
+declare type IntegrationFieldsContent = {
+    __TYPE__: "IntegrationFieldsContent";
+    value: string;
+};
+export declare const IntegrationFieldsContentType = "IntegrationFieldsContent";
+declare const IntegrationFieldsContent: t.Type<IntegrationFieldsContent, IntegrationFieldsContent, unknown>;
+export default IntegrationFieldsContent;

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

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationFieldsContentType = void 0;
+const Either_1 = require("fp-ts/Either");
+const t = __importStar(require("io-ts"));
+exports.IntegrationFieldsContentType = "IntegrationFieldsContent";
+const IntegrationFieldsContent = new t.Type("IntegrationFieldsContent", (u) => u?.__TYPE__ === exports.IntegrationFieldsContentType, (u, c) => Either_1.Chain.chain(t.string.validate(u, c), (u) => {
+    return t.success({
+        value: u,
+        __TYPE__: exports.IntegrationFieldsContentType,
+    });
+}), () => {
+    throw new Error("Not implemented - Not used - Not relevant");
+});
+exports.default = IntegrationFieldsContent;

package/lib/documents/widgets/nestable/Link/DocumentLink.d.ts

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+export declare const DocumentLinkType = "DocumentLink";
+export declare const DocumentLink: t.Type<{
+    id: string;
+}, {
+    id: string;
+} & {
+    __TYPE__: "DocumentLink";
+}, unknown>;
+export declare type DocumentLink = t.TypeOf<typeof DocumentLink>;
+export declare type DocumentLinkO = t.OutputOf<typeof DocumentLink>;
+export declare function isDocumentLink(u: unknown): u is DocumentLinkO;

package/lib/documents/widgets/nestable/Link/DocumentLink.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDocumentLink = exports.DocumentLink = exports.DocumentLinkType = void 0;
+const t = __importStar(require("io-ts"));
+const validators_1 = require("../../../../validators");
+const function_1 = require("../../../../validators/function");
+exports.DocumentLinkType = "DocumentLink";
+exports.DocumentLink = (0, function_1.addType)(t.strict({ id: validators_1.NonEmptyString }), exports.DocumentLinkType);
+function isDocumentLink(u) {
+    return u.__TYPE__ === exports.DocumentLinkType;
+}
+exports.isDocumentLink = isDocumentLink;

package/lib/documents/widgets/nestable/Link/ExternalLink.d.ts

@@ -0,0 +1,24 @@
+import * as t from "io-ts";
+export declare const ExternalLinkType = "ExternalLink";
+export declare const ExternalLink: t.Type<{
+    url: string;
+} & {
+    kind?: "web" | undefined;
+    target?: string | null | undefined;
+    preview?: {
+        title?: string | undefined;
+    } | null | undefined;
+}, {
+    url: string;
+} & {
+    kind?: "web" | undefined;
+    target?: string | null | undefined;
+    preview?: {
+        title?: string | undefined;
+    } | null | undefined;
+} & {
+    __TYPE__: "ExternalLink";
+}, unknown>;
+export declare type ExternalLink = t.TypeOf<typeof ExternalLink>;
+export declare type ExternalLinkO = t.OutputOf<typeof ExternalLink>;
+export declare function isExternalLink(u: unknown): u is ExternalLinkO;

package/lib/documents/widgets/nestable/Link/ExternalLink.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExternalLink = exports.ExternalLink = exports.ExternalLinkType = void 0;
+const t = __importStar(require("io-ts"));
+const validators_1 = require("../../../../validators");
+const function_1 = require("../../../../validators/function");
+exports.ExternalLinkType = "ExternalLink";
+exports.ExternalLink = (0, function_1.addType)(t.exact(t.intersection([
+    t.type({
+        url: t.string,
+    }),
+    t.partial({
+        kind: t.literal("web"),
+        target: validators_1.StringOrNull,
+        preview: (0, function_1.nullable)(t.partial({
+            title: t.string,
+        })),
+    }),
+])), exports.ExternalLinkType);
+function isExternalLink(u) {
+    return u.__TYPE__ === exports.ExternalLinkType;
+}
+exports.isExternalLink = isExternalLink;