@prismicio/types-internal 1.2.0-alpha.1 → 1.2.0

package/lib/content/fields/GroupContent.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupContentType = exports.GroupContent = exports.GroupItemContentType = exports.GroupItemContent = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const GroupContent_1 = require("../../documents/widgets/GroupContent");
+const nestable_1 = require("./nestable");
+exports.GroupItemContent = t.strict({
+    __TYPE__: t.literal(GroupContent_1.GroupItemContentType),
+    value: t.array(t.tuple([t.string, nestable_1.NestableContent])),
+});
+exports.GroupItemContentType = GroupContent_1.GroupItemContentType;
+exports.GroupContent = t.strict({
+    __TYPE__: t.literal(GroupContent_1.GroupContentType),
+    value: t.array(exports.GroupItemContent),
+});
+exports.GroupContentType = GroupContent_1.GroupContentType;

package/lib/content/fields/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./GroupContent";
+export * from "./nestable";
+export * from "./slices";

package/lib/content/fields/index.js

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

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

@@ -0,0 +1,7 @@
+import * as t from "io-ts";
+export declare const BooleanContent: t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"BooleanContent">;
+    value: t.BooleanC;
+}>>;
+export declare type BooleanContent = t.TypeOf<typeof BooleanContent>;
+export declare const BooleanContentType = "BooleanContent";

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanContentType = exports.BooleanContent = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const BooleanContent_1 = require("../../../documents/widgets/nestable/BooleanContent");
+exports.BooleanContent = t.strict({
+    __TYPE__: t.literal(BooleanContent_1.BooleanContentType),
+    value: t.boolean,
+});
+exports.BooleanContentType = BooleanContent_1.BooleanContentType;

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

@@ -0,0 +1,70 @@
+import * as t from "io-ts";
+export declare const EmbedContent: t.IntersectionC<[t.Type<{
+    embed_url: string;
+    type: string;
+} & {
+    version?: string | number | null;
+    title?: string | null | undefined;
+    author_name?: string | null | undefined;
+    author_url?: string | null | undefined;
+    provider_name?: string | null | undefined;
+    provider_url?: string | null | undefined;
+    cache_age?: string | number | null;
+    thumbnail_url?: string | null | undefined;
+    thumbnail_width?: number | null | undefined;
+    thumbnail_height?: number | null | undefined;
+    html?: string | null | undefined;
+}, {
+    embed_url: string;
+    type: string;
+} & {
+    version?: string | number | null;
+    title?: string | null | undefined;
+    author_name?: string | null | undefined;
+    author_url?: string | null | undefined;
+    provider_name?: string | null | undefined;
+    provider_url?: string | null | undefined;
+    cache_age?: string | number | null;
+    thumbnail_url?: string | null | undefined;
+    thumbnail_width?: number | null | undefined;
+    thumbnail_height?: number | null | undefined;
+    html?: string | null | undefined;
+} & {
+    __TYPE__: "EmbedContent";
+}, unknown>, t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"EmbedContent">;
+    all: t.Type<{
+        embed_url: string;
+        type: string;
+    } & {
+        version?: string | number | null;
+        title?: string | null | undefined;
+        author_name?: string | null | undefined;
+        author_url?: string | null | undefined;
+        provider_name?: string | null | undefined;
+        provider_url?: string | null | undefined;
+        cache_age?: string | number | null;
+        thumbnail_url?: string | null | undefined;
+        thumbnail_width?: number | null | undefined;
+        thumbnail_height?: number | null | undefined;
+        html?: string | null | undefined;
+    }, {
+        embed_url: string;
+        type: string;
+    } & {
+        version?: string | number | null;
+        title?: string | null | undefined;
+        author_name?: string | null | undefined;
+        author_url?: string | null | undefined;
+        provider_name?: string | null | undefined;
+        provider_url?: string | null | undefined;
+        cache_age?: string | number | null;
+        thumbnail_url?: string | null | undefined;
+        thumbnail_width?: number | null | undefined;
+        thumbnail_height?: number | null | undefined;
+        html?: string | null | undefined;
+    } & {
+        __TYPE__: "EmbedContent";
+    }, unknown>;
+}>>]>;
+export declare type EmbedContent = t.TypeOf<typeof EmbedContent>;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbedContent = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const EmbedContent_1 = require("../../../documents/widgets/nestable/EmbedContent");
+exports.EmbedContent = t.intersection([
+    EmbedContent_1.EmbedContentC,
+    t.strict({
+        __TYPE__: t.literal(EmbedContent_1.EmbedContentType),
+        all: EmbedContent_1.EmbedContentC,
+    }),
+]);

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

@@ -0,0 +1,26 @@
+import * as t from "io-ts";
+export declare const FieldType: t.KeyofC<{
+    Text: null;
+    Date: null;
+    Timestamp: null;
+    Color: null;
+    Number: null;
+    Range: null;
+    Select: null;
+}>;
+export declare type FieldType = t.TypeOf<typeof FieldType>;
+export declare const FieldContent: t.ExactC<t.TypeC<{
+    type: t.KeyofC<{
+        Text: null;
+        Date: null;
+        Timestamp: null;
+        Color: null;
+        Number: null;
+        Range: null;
+        Select: null;
+    }>;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type FieldContent = t.TypeOf<typeof FieldContent>;
+export declare const FieldContentType = "FieldContent";

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldContentType = exports.FieldContent = exports.FieldType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const FieldContent_1 = require("../../../documents/widgets/nestable/FieldContent");
+const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../validators/TrimmedString"));
+exports.FieldType = t.keyof({
+    Text: null,
+    Date: null,
+    Timestamp: null,
+    Color: null,
+    Number: null,
+    Range: null,
+    Select: null,
+});
+exports.FieldContent = t.strict({
+    type: exports.FieldType,
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(FieldContent_1.FieldContentType),
+});
+exports.FieldContentType = FieldContent_1.FieldContentType;

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

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+export declare const GeoPointContent: t.IntersectionC<[t.Type<{
+    position: {
+        lat: number;
+        lng: number;
+    };
+}, {
+    position: {
+        lat: number;
+        lng: number;
+    };
+} & {
+    __TYPE__: "GeoPointContent";
+}, unknown>, t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"GeoPointContent">;
+}>>]>;
+export declare type GeoPointContent = t.TypeOf<typeof GeoPointContent>;
+export declare const GeoPointContentType = "GeoPointContent";

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoPointContentType = exports.GeoPointContent = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const GeoPointContent_1 = require("../../../documents/widgets/nestable/GeoPointContent");
+exports.GeoPointContent = t.intersection([
+    GeoPointContent_1.GeoPointContent,
+    t.strict({
+        __TYPE__: t.literal(GeoPointContent_1.GeoPointContentType),
+    }),
+]);
+exports.GeoPointContentType = GeoPointContent_1.GeoPointContentType;

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

@@ -0,0 +1,103 @@
+import * as t from 'io-ts';
+export declare const ImageContent: t.IntersectionC<[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;
+    credits?: string | null;
+    alt?: string | null;
+    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;
+            credits?: string | null;
+            alt?: string | null;
+            provider?: string | null | 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;
+    credits?: string | null;
+    alt?: string | null;
+    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;
+            credits?: string | null;
+            alt?: string | null;
+            provider?: string | null | undefined;
+        };
+    };
+} & {
+    __TYPE__: "ImageContent";
+}, unknown>, t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"ImageContent">;
+}>>]>;
+export declare type ImageContent = t.TypeOf<typeof ImageContent>;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageContent = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const nestable_1 = require("../../../documents/widgets/nestable");
+const ImageContent_1 = require("../../../documents/widgets/nestable/ImageContent");
+exports.ImageContent = t.intersection([
+    nestable_1.ImageContent,
+    t.strict({
+        __TYPE__: t.literal(ImageContent_1.ImageContentType)
+    })
+]);

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

@@ -0,0 +1,104 @@
+import * as t from "io-ts";
+export declare const ImageContent: t.IntersectionC<[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;
+    credits?: string | null;
+    alt?: string | null;
+    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;
+            credits?: string | null;
+            alt?: string | null;
+            provider?: string | null | 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;
+    credits?: string | null;
+    alt?: string | null;
+    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;
+            credits?: string | null;
+            alt?: string | null;
+            provider?: string | null | undefined;
+        };
+    };
+} & {
+    __TYPE__: "ImageContent";
+}, unknown>, t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"ImageContent">;
+}>>]>;
+export declare type ImageContent = t.TypeOf<typeof ImageContent>;
+export declare const ImageContentType = "ImageContent";

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageContentType = exports.ImageContent = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const ImageContent_1 = require("../../../documents/widgets/nestable/ImageContent");
+exports.ImageContent = t.intersection([
+    ImageContent_1.ImageContent,
+    t.strict({
+        __TYPE__: t.literal(ImageContent_1.ImageContentType),
+    }),
+]);
+exports.ImageContentType = ImageContent_1.ImageContentType;

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

@@ -0,0 +1,7 @@
+import * as t from "io-ts";
+export declare const IntegrationFieldContent: t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"IntegrationFieldsContent">;
+    value: t.StringC;
+}>>;
+export declare type IntegrationFieldContent = t.TypeOf<typeof IntegrationFieldContent>;
+export declare const IntegrationFieldsContentType = "IntegrationFieldsContent";

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationFieldsContentType = exports.IntegrationFieldContent = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const IntegrationFieldsContent_1 = require("../../../documents/widgets/nestable/IntegrationFieldsContent");
+exports.IntegrationFieldContent = t.strict({
+    __TYPE__: t.literal(IntegrationFieldsContent_1.IntegrationFieldsContentType),
+    value: t.string,
+});
+exports.IntegrationFieldsContentType = IntegrationFieldsContent_1.IntegrationFieldsContentType;

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

@@ -0,0 +1,159 @@
+import * as t from "io-ts";
+export declare const ImageLinkContent: t.IntersectionC<[t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"ImageLink">;
+}>>, t.Type<{
+    id: string;
+    url: string;
+    height: string;
+    width: string;
+    size: string;
+    name: string;
+    kind: string;
+} & {
+    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>]>;
+export declare type ImageLinkContent = t.TypeOf<typeof ImageLinkContent>;
+export declare const ImageLinkType = "ImageLink";
+export declare const FileLinkContent: t.IntersectionC<[t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"FileLink">;
+}>>, t.Type<{
+    id: string;
+    url: string;
+    name: string;
+    kind: string;
+} & {
+    date?: string | null | undefined;
+    size?: string;
+}, {
+    readonly size: string;
+    readonly __TYPE__: "FileLink";
+    readonly id: string;
+    readonly url: string;
+    readonly name: string;
+    readonly kind: string;
+    readonly date?: string | null | undefined;
+}, unknown>]>;
+export declare type FileLinkContent = t.TypeOf<typeof FileLinkContent>;
+export declare const FileLinkType = "FileLink";
+export declare const DocumentLinkContent: t.IntersectionC<[t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"DocumentLink">;
+}>>, t.Type<{
+    id: string;
+}, {
+    id: string;
+} & {
+    __TYPE__: "DocumentLink";
+}, unknown>]>;
+export declare type DocumentLinkContent = t.TypeOf<typeof DocumentLinkContent>;
+export declare const DocumentLinkType = "DocumentLink";
+export declare const ExternalLinkContent: t.IntersectionC<[t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"ExternalLink">;
+}>>, t.Type<{
+    url: string;
+} & {
+    kind?: "web";
+    target?: string | null | undefined;
+    preview?: {
+        title?: string;
+    } | null | undefined;
+}, {
+    url: string;
+} & {
+    kind?: "web";
+    target?: string | null | undefined;
+    preview?: {
+        title?: string;
+    } | null | undefined;
+} & {
+    __TYPE__: "ExternalLink";
+}, unknown>]>;
+export declare type ExternalLinkContent = t.TypeOf<typeof ExternalLinkContent>;
+export declare const ExternalLinkType = "ExternalLink";
+export declare const LinkContent: t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"LinkContent">;
+    value: t.UnionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"ImageLink">;
+    }>>, t.Type<{
+        id: string;
+        url: string;
+        height: string;
+        width: string;
+        size: string;
+        name: string;
+        kind: string;
+    } & {
+        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.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"FileLink">;
+    }>>, t.Type<{
+        id: string;
+        url: string;
+        name: string;
+        kind: string;
+    } & {
+        date?: string | null | undefined;
+        size?: string;
+    }, {
+        readonly size: string;
+        readonly __TYPE__: "FileLink";
+        readonly id: string;
+        readonly url: string;
+        readonly name: string;
+        readonly kind: string;
+        readonly date?: string | null | undefined;
+    }, unknown>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"DocumentLink">;
+    }>>, t.Type<{
+        id: string;
+    }, {
+        id: string;
+    } & {
+        __TYPE__: "DocumentLink";
+    }, unknown>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"ExternalLink">;
+    }>>, t.Type<{
+        url: string;
+    } & {
+        kind?: "web";
+        target?: string | null | undefined;
+        preview?: {
+            title?: string;
+        } | null | undefined;
+    }, {
+        url: string;
+    } & {
+        kind?: "web";
+        target?: string | null | undefined;
+        preview?: {
+            title?: string;
+        } | null | undefined;
+    } & {
+        __TYPE__: "ExternalLink";
+    }, unknown>]>]>;
+}>>;
+export declare type LinkContent = t.TypeOf<typeof LinkContent>;
+export declare const LinkContentType = "LinkContent";

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkContentType = exports.LinkContent = exports.ExternalLinkType = exports.ExternalLinkContent = exports.DocumentLinkType = exports.DocumentLinkContent = exports.FileLinkType = exports.FileLinkContent = exports.ImageLinkType = exports.ImageLinkContent = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const DocumentLink_1 = require("../../../documents/widgets/nestable/Link/DocumentLink");
+const ExternalLink_1 = require("../../../documents/widgets/nestable/Link/ExternalLink");
+const FileLink_1 = require("../../../documents/widgets/nestable/Link/FileLink");
+const ImageLink_1 = require("../../../documents/widgets/nestable/Link/ImageLink");
+const LinkContent_1 = require("../../../documents/widgets/nestable/Link/LinkContent");
+exports.ImageLinkContent = t.intersection([
+    t.strict({
+        __TYPE__: t.literal(ImageLink_1.ImageLinkType),
+    }),
+    ImageLink_1.ImageLink,
+]);
+exports.ImageLinkType = ImageLink_1.ImageLinkType;
+exports.FileLinkContent = t.intersection([
+    t.strict({
+        __TYPE__: t.literal(FileLink_1.FileLinkType),
+    }),
+    FileLink_1.FileLink,
+]);
+exports.FileLinkType = FileLink_1.FileLinkType;
+exports.DocumentLinkContent = t.intersection([
+    t.strict({
+        __TYPE__: t.literal(DocumentLink_1.DocumentLinkType),
+    }),
+    DocumentLink_1.DocumentLink,
+]);
+exports.DocumentLinkType = DocumentLink_1.DocumentLinkType;
+exports.ExternalLinkContent = t.intersection([
+    t.strict({
+        __TYPE__: t.literal(ExternalLink_1.ExternalLinkType),
+    }),
+    ExternalLink_1.ExternalLink,
+]);
+exports.ExternalLinkType = ExternalLink_1.ExternalLinkType;
+exports.LinkContent = t.strict({
+    __TYPE__: t.literal(LinkContent_1.LinkContentType),
+    value: t.union([
+        exports.ImageLinkContent,
+        exports.FileLinkContent,
+        exports.DocumentLinkContent,
+        exports.ExternalLinkContent,
+    ]),
+});
+exports.LinkContentType = LinkContent_1.LinkContentType;