@prismicio/types-internal 0.2.2 → 0.2.6

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

@@ -1,7 +1,11 @@
-import { Chain } from "fp-ts/Either";
-import * as t from "io-ts";
-export const BooleanContentType = "BooleanContent";
-const BooleanContent = new t.Type("BooleanContent", (u) => u?.__TYPE__ === BooleanContentType, (u, c) => Chain.chain(t.boolean.validate(u, c), (u) => {
-    return t.success({ value: u, __TYPE__: BooleanContentType });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanContentType = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const t = (0, tslib_1.__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));
-export default BooleanContent;
+exports.default = BooleanContent;

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

@@ -1,9 +1,12 @@
 import * as t from "io-ts";
 export declare const EmbedContentType = "EmbedContent";
-declare type EmbedContent = t.OutputOf<typeof EmbedContentC> & {
+export declare type EmbedContent = t.TypeOf<typeof EmbedContentC> & {
     all: unknown;
 };
-declare const EmbedContent: t.Type<EmbedContent, unknown, unknown>;
+export declare type EmbedContentO = t.OutputOf<typeof EmbedContentC> & {
+    all: unknown;
+};
+export declare const EmbedContent: t.Type<EmbedContentO, unknown, unknown>;
 declare const EmbedContentC: t.Type<{
     embed_url: string;
     type: string;
@@ -37,4 +40,4 @@ declare const EmbedContentC: t.Type<{
 } & {
     __TYPE__: "EmbedContent";
 }, unknown>;
-export default EmbedContent;
+export {};

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

@@ -1,32 +1,35 @@
-import { either } from "fp-ts";
-import { pipe } from "fp-ts/function";
-import * as t from "io-ts";
-import { NumberOrNull, StringOrNull } from "../../../validators";
-import { addType } from "../../../validators/function";
-export const EmbedContentType = "EmbedContent";
-const EmbedContent = new t.Type("EmbedContent", (u) => u.__TYPE__ === EmbedContentType, (u) => {
-    return pipe(EmbedContentC.decode(u), either.map((s) => ({
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbedContent = exports.EmbedContentType = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+const function_2 = require("../../../validators/function");
+exports.EmbedContentType = "EmbedContent";
+exports.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 = addType(t.exact(t.intersection([
+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: StringOrNull,
-        author_name: StringOrNull,
-        author_url: StringOrNull,
-        provider_name: StringOrNull,
-        provider_url: StringOrNull,
+        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: StringOrNull,
-        thumbnail_width: NumberOrNull,
-        thumbnail_height: NumberOrNull,
-        html: StringOrNull,
+        thumbnail_url: validators_1.StringOrNull,
+        thumbnail_width: validators_1.NumberOrNull,
+        thumbnail_height: validators_1.NumberOrNull,
+        html: validators_1.StringOrNull,
     }),
-])), EmbedContentType);
-export default EmbedContent;
+])), exports.EmbedContentType);

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

@@ -1,12 +1,13 @@
 import * as O from "fp-ts/Option";
+export declare type FieldType = "Text" | "Date" | "Timestamp" | "Color" | "Number" | "Range" | "Select";
 export declare const FieldContentType = "FieldContent";
 declare type FieldContent = {
     value: string;
-    type: string;
+    type: FieldType;
     __TYPE__: typeof FieldContentType;
 };
 declare const FieldContent: {
     types: string[];
-    forType: (type: string, value: unknown) => O.Option<FieldContent>;
+    forType: (type: FieldType, value: unknown) => O.Option<FieldContent>;
 };
 export default FieldContent;

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

@@ -1,7 +1,11 @@
-import { pipe } from "fp-ts/function";
-import * as O from "fp-ts/Option";
-import * as t from "io-ts";
-export const FieldContentType = "FieldContent";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldContentType = void 0;
+const tslib_1 = require("tslib");
+const function_1 = require("fp-ts/function");
+const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
+const t = (0, tslib_1.__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
@@ -21,7 +25,7 @@ function trimScalaStyle(s) {
 const FieldContent = {
     types: ["Text", "Date", "Timestamp", "Color", "Number", "Range", "Select"],
     forType: (type, value) => {
-        return pipe(O.fromEither(t.string.decode(value)), O.map((r) => {
+        return (0, function_1.pipe)(O.fromEither(t.string.decode(value)), O.map((r) => {
             return {
                 value: trimScalaStyle(r),
                 type,
@@ -30,4 +34,4 @@ const FieldContent = {
         }));
     },
 };
-export default FieldContent;
+exports.default = FieldContent;

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

@@ -1,9 +1,13 @@
-import * as t from "io-ts";
-import { addType } from "../../../validators/function";
-export const GeoPointContentType = "GeoPointContent";
-export const GeoPointContent = addType(t.strict({
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoPointContent = exports.GeoPointContentType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__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,
     }),
-}), GeoPointContentType);
+}), exports.GeoPointContentType);

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

@@ -1,13 +1,17 @@
-import * as t from "io-ts";
-import { NonEmptyStringOrNull, StringOrNull } from "../../../validators";
-import { addType } from "../../../validators/function";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageContent = exports.ImageContentType = exports.ImageContentView = 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 Origin = t.exact(t.type({
     id: t.string,
     url: t.string,
     width: t.number,
     height: t.number,
 }));
-export const ImageContentView = t.exact(t.intersection([
+exports.ImageContentView = t.exact(t.intersection([
     t.type({
         origin: Origin,
         width: t.number,
@@ -23,15 +27,15 @@ export const ImageContentView = t.exact(t.intersection([
     }),
     t.partial({
         url: t.string,
-        credits: NonEmptyStringOrNull,
-        alt: NonEmptyStringOrNull,
-        provider: StringOrNull,
+        credits: validators_1.NonEmptyStringOrNull,
+        alt: validators_1.NonEmptyStringOrNull,
+        provider: validators_1.StringOrNull,
     }),
 ]));
-export const ImageContentType = "ImageContent";
-export const ImageContent = addType(t.intersection([
-    ImageContentView,
+exports.ImageContentType = "ImageContent";
+exports.ImageContent = (0, function_1.addType)(t.intersection([
+    exports.ImageContentView,
     t.partial({
-        thumbnails: t.record(t.string, ImageContentView),
+        thumbnails: t.record(t.string, exports.ImageContentView),
     }),
-]), ImageContentType);
+]), exports.ImageContentType);

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

@@ -1,12 +1,16 @@
-import { Chain } from "fp-ts/Either";
-import * as t from "io-ts";
-export const IntegrationFieldsContentType = "IntegrationFieldsContent";
-const IntegrationFieldsContent = new t.Type("IntegrationFieldsContent", (u) => u?.__TYPE__ === IntegrationFieldsContentType, (u, c) => Chain.chain(t.string.validate(u, c), (u) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationFieldsContentType = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const t = (0, tslib_1.__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__: IntegrationFieldsContentType,
+        __TYPE__: exports.IntegrationFieldsContentType,
     });
 }), () => {
     throw new Error("Not implemented - Not used - Not relevant");
 });
-export default IntegrationFieldsContent;
+exports.default = IntegrationFieldsContent;

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

@@ -1,8 +1,13 @@
-import * as t from "io-ts";
-import { NonEmptyString } from "../../../../validators";
-import { addType } from "../../../../validators/function";
-export const DocumentLinkType = "DocumentLink";
-export const DocumentLink = addType(t.strict({ id: NonEmptyString }), DocumentLinkType);
-export function isDocumentLink(u) {
-    return u.__TYPE__ === DocumentLinkType;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDocumentLink = exports.DocumentLink = exports.DocumentLinkType = 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");
+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.js

@@ -1,19 +1,24 @@
-import * as t from "io-ts";
-import { StringOrNull } from "../../../../validators";
-import { addType, nullable } from "../../../../validators/function";
-export const ExternalLinkType = "ExternalLink";
-export const ExternalLink = addType(t.exact(t.intersection([
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExternalLink = exports.ExternalLink = exports.ExternalLinkType = 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");
+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: StringOrNull,
-        preview: nullable(t.partial({
+        target: validators_1.StringOrNull,
+        preview: (0, function_1.nullable)(t.partial({
             title: t.string,
         })),
     }),
-])), ExternalLinkType);
-export function isExternalLink(u) {
-    return u.__TYPE__ === ExternalLinkType;
+])), exports.ExternalLinkType);
+function isExternalLink(u) {
+    return u.__TYPE__ === exports.ExternalLinkType;
 }
+exports.isExternalLink = isExternalLink;

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

@@ -1,8 +1,12 @@
-import * as t from "io-ts";
-import { mapOutput } from "io-ts-types/lib/mapOutput";
-import { nullable } from "../../../../validators/function";
-export const FileLinkType = "FileLink";
-export const FileLink = mapOutput(t.exact(t.intersection([
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFileLink = exports.FileLink = exports.FileLinkType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const mapOutput_1 = require("io-ts-types/lib/mapOutput");
+const function_1 = require("../../../../validators/function");
+exports.FileLinkType = "FileLink";
+exports.FileLink = (0, mapOutput_1.mapOutput)(t.exact(t.intersection([
     t.type({
         id: t.string,
         url: t.string,
@@ -10,10 +14,11 @@ export const FileLink = mapOutput(t.exact(t.intersection([
         kind: t.string,
     }),
     t.partial({
-        date: nullable(t.string),
-        size: nullable(t.string),
+        date: (0, function_1.nullable)(t.string),
+        size: (0, function_1.nullable)(t.string),
     }),
-])), (o) => ({ ...o, size: o.size || "0", __TYPE__: FileLinkType }));
-export function isFileLink(u) {
-    return u.__TYPE__ === FileLinkType;
+])), (o) => ({ ...o, size: o.size || "0", __TYPE__: exports.FileLinkType }));
+function isFileLink(u) {
+    return u.__TYPE__ === exports.FileLinkType;
 }
+exports.isFileLink = isFileLink;

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

@@ -1,8 +1,12 @@
-import * as t from "io-ts";
-import { StringOrNull } from "../../../../validators";
-import { addType } from "../../../../validators/function";
-export const ImageLinkType = "ImageLink";
-export const ImageLink = addType(t.exact(t.intersection([
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImageLink = exports.ImageLink = exports.ImageLinkType = 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");
+exports.ImageLinkType = "ImageLink";
+exports.ImageLink = (0, function_1.addType)(t.exact(t.intersection([
     t.type({
         id: t.string,
         url: t.string,
@@ -13,9 +17,10 @@ export const ImageLink = addType(t.exact(t.intersection([
         kind: t.string,
     }),
     t.partial({
-        date: StringOrNull,
+        date: validators_1.StringOrNull,
     }),
-])), ImageLinkType);
-export function isImageLink(u) {
-    return u.__TYPE__ === ImageLinkType;
+])), exports.ImageLinkType);
+function isImageLink(u) {
+    return u.__TYPE__ === exports.ImageLinkType;
 }
+exports.isImageLink = isImageLink;

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

@@ -1,9 +1,13 @@
-import { Chain } from "fp-ts/Either";
-import * as t from "io-ts";
-import { Link } from "./index";
-export const LinkContentType = "LinkContent";
-export const LinkContent = new t.Type("LinkContent", (u) => {
-    return Link.is(u?.value);
-}, (u, c) => Chain.chain(Link.validate(u, c), (u) => {
-    return t.success({ value: u, __TYPE__: LinkContentType });
-}), (linkContent) => Link.encode(linkContent.value));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkContent = exports.LinkContentType = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const index_1 = require("./index");
+exports.LinkContentType = "LinkContent";
+exports.LinkContent = new t.Type("LinkContent", (u) => {
+    return index_1.Link.is(u?.value);
+}, (u, c) => Either_1.Chain.chain(index_1.Link.validate(u, c), (u) => {
+    return t.success({ value: u, __TYPE__: exports.LinkContentType });
+}), (linkContent) => index_1.Link.encode(linkContent.value));

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

@@ -81,9 +81,9 @@ export declare const is: {
     imageLink: typeof isImageLink;
 };
 export declare const LinksTypes: {
-    DocumentLink: string;
-    FileLink: string;
-    ExternalLink: string;
-    ImageLink: string;
-    LinkContent: string;
+    readonly DocumentLink: "DocumentLink";
+    readonly FileLink: "FileLink";
+    readonly ExternalLink: "ExternalLink";
+    readonly ImageLink: "ImageLink";
+    readonly LinkContent: "LinkContent";
 };

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

@@ -1,26 +1,35 @@
-import * as t from "io-ts";
-import { DocumentLink, DocumentLinkType, isDocumentLink } from "./DocumentLink";
-import { ExternalLink, ExternalLinkType, isExternalLink } from "./ExternalLink";
-import { FileLink, FileLinkType, isFileLink } from "./FileLink";
-import { ImageLink, ImageLinkType, isImageLink } from "./ImageLink";
-import { LinkContentType } from "./LinkContent";
-export const Link = t.union([ImageLink, FileLink, DocumentLink, ExternalLink]);
-export { DocumentLink } from "./DocumentLink";
-export { ExternalLink } from "./ExternalLink";
-export { FileLink } from "./FileLink";
-export { ImageLink } from "./ImageLink";
-export { LinkContent } from "./LinkContent";
-export const BROKEN_CUSTOM_TYPE = "broken_type";
-export const is = {
-    documentLink: isDocumentLink,
-    fileLink: isFileLink,
-    externalLink: isExternalLink,
-    imageLink: isImageLink,
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinksTypes = exports.is = exports.BROKEN_CUSTOM_TYPE = exports.LinkContent = exports.ImageLink = exports.FileLink = exports.ExternalLink = exports.DocumentLink = exports.Link = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const DocumentLink_1 = require("./DocumentLink");
+const ExternalLink_1 = require("./ExternalLink");
+const FileLink_1 = require("./FileLink");
+const ImageLink_1 = require("./ImageLink");
+const LinkContent_1 = require("./LinkContent");
+exports.Link = t.union([ImageLink_1.ImageLink, FileLink_1.FileLink, DocumentLink_1.DocumentLink, ExternalLink_1.ExternalLink]);
+var DocumentLink_2 = require("./DocumentLink");
+Object.defineProperty(exports, "DocumentLink", { enumerable: true, get: function () { return DocumentLink_2.DocumentLink; } });
+var ExternalLink_2 = require("./ExternalLink");
+Object.defineProperty(exports, "ExternalLink", { enumerable: true, get: function () { return ExternalLink_2.ExternalLink; } });
+var FileLink_2 = require("./FileLink");
+Object.defineProperty(exports, "FileLink", { enumerable: true, get: function () { return FileLink_2.FileLink; } });
+var ImageLink_2 = require("./ImageLink");
+Object.defineProperty(exports, "ImageLink", { enumerable: true, get: function () { return ImageLink_2.ImageLink; } });
+var LinkContent_2 = require("./LinkContent");
+Object.defineProperty(exports, "LinkContent", { enumerable: true, get: function () { return LinkContent_2.LinkContent; } });
+exports.BROKEN_CUSTOM_TYPE = "broken_type";
+exports.is = {
+    documentLink: DocumentLink_1.isDocumentLink,
+    fileLink: FileLink_1.isFileLink,
+    externalLink: ExternalLink_1.isExternalLink,
+    imageLink: ImageLink_1.isImageLink,
 };
-export const LinksTypes = {
-    DocumentLink: DocumentLinkType,
-    FileLink: FileLinkType,
-    ExternalLink: ExternalLinkType,
-    ImageLink: ImageLinkType,
-    LinkContent: LinkContentType,
+exports.LinksTypes = {
+    DocumentLink: DocumentLink_1.DocumentLinkType,
+    FileLink: FileLink_1.FileLinkType,
+    ExternalLink: ExternalLink_1.ExternalLinkType,
+    ImageLink: ImageLink_1.ImageLinkType,
+    LinkContent: LinkContent_1.LinkContentType,
 };

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

@@ -1,5 +1,8 @@
-export const SeparatorContentType = "SeparatorContent";
-export const SeparatorContent = {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeparatorContent = exports.SeparatorContentType = void 0;
+exports.SeparatorContentType = "SeparatorContent";
+exports.SeparatorContent = {
     is(value) {
         const asFieldContent = value;
         return asFieldContent.__TYPE__ === "SeparatorContent";

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

@@ -1,5 +1,4 @@
 import * as t from "io-ts";
-import EmbedContent from "../EmbedContent";
 export declare const Meta: t.ExactC<t.IntersectionC<[t.PartialC<{
     data: t.UnknownC;
 }>, t.TypeC<{
@@ -119,7 +118,7 @@ export declare function checkImageBlock(block: Block): block is ImageBlock;
 export declare const EmbedBlockType = "embed";
 export declare const EmbedBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
     type: t.LiteralC<"embed">;
-    data: t.Type<EmbedContent, unknown, unknown>;
+    data: t.Type<import("../EmbedContent").EmbedContentO, unknown, unknown>;
 }>, t.PartialC<{
     label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
     direction: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
@@ -244,7 +243,7 @@ export declare const Block: t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
     direction: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
 }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
     type: t.LiteralC<"embed">;
-    data: t.Type<EmbedContent, unknown, unknown>;
+    data: t.Type<import("../EmbedContent").EmbedContentO, unknown, unknown>;
 }>, t.PartialC<{
     label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
     direction: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;

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

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