@prismicio/types-internal 3.17.0 → 4.0.0-canary.3fe5f1e

package/dist/content/link.d.ts

@@ -0,0 +1,163 @@
+import { z } from "zod/mini";
+
+//#region src/content/link.d.ts
+declare const FilledImageLinkValueContentSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<"image", string>>;
+  id: z.ZodMiniString<string>;
+  url: z.ZodMiniString<string>;
+  height: z.ZodMiniString<string>;
+  width: z.ZodMiniString<string>;
+  size: z.ZodMiniString<string>;
+  name: z.ZodMiniString<string>;
+  date: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  __TYPE__: z.ZodMiniLiteral<"ImageLink">;
+}, z.core.$strict>;
+declare const EmptyImageLinkValueContentSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniLiteral<"image">;
+  __TYPE__: z.ZodMiniLiteral<"ImageLink">;
+}, z.core.$strict>;
+declare const FilledFileLinkValueContentSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<"file", string>>;
+  id: z.ZodMiniString<string>;
+  url: z.ZodMiniString<string>;
+  name: z.ZodMiniString<string>;
+  size: z.ZodMiniTransform<string, unknown>;
+  date: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  __TYPE__: z.ZodMiniLiteral<"FileLink">;
+}, z.core.$strict>;
+declare const EmptyFileLinkValueContentSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniLiteral<"file">;
+  __TYPE__: z.ZodMiniLiteral<"FileLink">;
+}, z.core.$strict>;
+declare const EmptyMediaLinkValueContentSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniLiteral<"media">;
+  __TYPE__: z.ZodMiniLiteral<"MediaLink">;
+}, z.core.$strict>;
+declare const FilledDocumentLinkValueContentSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniPipe<z.ZodMiniOptional<z.ZodMiniLiteral<"document">>, z.ZodMiniTransform<"document", "document" | undefined>>;
+  id: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"DocumentLink">;
+}, z.core.$strict>;
+declare const EmptyDocumentLinkValueContentSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniLiteral<"document">;
+  __TYPE__: z.ZodMiniLiteral<"DocumentLink">;
+}, z.core.$strict>;
+declare const FilledExternalLinkValueContentSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniPipe<z.ZodMiniOptional<z.ZodMiniLiteral<"web">>, z.ZodMiniTransform<"web", "web" | undefined>>;
+  url: z.ZodMiniString<string>;
+  target: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  preview: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniObject<{
+    title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  }, z.core.$strict>>>;
+  __TYPE__: z.ZodMiniLiteral<"ExternalLink">;
+}, z.core.$strict>;
+declare const EmptyExternalLinkValueContentSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniLiteral<"web">;
+  __TYPE__: z.ZodMiniLiteral<"ExternalLink">;
+}, z.core.$strict>;
+declare const AnyLinkValueContentSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniTransform<"any", unknown>;
+  __TYPE__: z.ZodMiniLiteral<"AnyLink">;
+}, z.core.$strict>;
+type FilledImageLinkValueContent = z.infer<typeof FilledImageLinkValueContentSchema>;
+type FilledFileLinkValueContent = z.infer<typeof FilledFileLinkValueContentSchema>;
+type FilledDocumentLinkValueContent = z.infer<typeof FilledDocumentLinkValueContentSchema>;
+type FilledExternalLinkValueContent = z.infer<typeof FilledExternalLinkValueContentSchema>;
+type FilledLinkValueContent = FilledImageLinkValueContent | FilledFileLinkValueContent | FilledDocumentLinkValueContent | FilledExternalLinkValueContent;
+type EmptyImageLinkValueContent = z.infer<typeof EmptyImageLinkValueContentSchema>;
+type EmptyFileLinkValueContent = z.infer<typeof EmptyFileLinkValueContentSchema>;
+type EmptyMediaLinkValueContent = z.infer<typeof EmptyMediaLinkValueContentSchema>;
+type EmptyDocumentLinkValueContent = z.infer<typeof EmptyDocumentLinkValueContentSchema>;
+type EmptyExternalLinkValueContent = z.infer<typeof EmptyExternalLinkValueContentSchema>;
+type AnyLinkValueContent = z.infer<typeof AnyLinkValueContentSchema>;
+type EmptyLinkValueContent = EmptyImageLinkValueContent | EmptyFileLinkValueContent | EmptyMediaLinkValueContent | EmptyDocumentLinkValueContent | EmptyExternalLinkValueContent | AnyLinkValueContent;
+type LinkValueContent = FilledLinkValueContent | EmptyLinkValueContent;
+declare const LinkContentSchema: z.ZodMiniObject<{
+  __TYPE__: z.ZodMiniLiteral<"LinkContent">;
+  key: z.ZodMiniTransform<string, unknown>;
+  value: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>, z.ZodMiniTransform<{
+    text?: unknown;
+    variant?: unknown;
+    value: Record<string, unknown>;
+  }, Record<string, unknown>>>, z.ZodMiniObject<{
+    text: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    variant: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    value: z.ZodMiniType<LinkValueContent, Record<string, unknown>>;
+  }, z.core.$strip>>, z.ZodMiniTransform<{
+    kind: "image";
+    id: string;
+    url: string;
+    height: string;
+    width: string;
+    size: string;
+    name: string;
+    __TYPE__: "ImageLink";
+    date?: string | null | undefined;
+    variant?: string | undefined;
+    text?: string | undefined;
+  } | {
+    kind: "file";
+    id: string;
+    url: string;
+    name: string;
+    size: string;
+    __TYPE__: "FileLink";
+    date?: string | null | undefined;
+    variant?: string | undefined;
+    text?: string | undefined;
+  } | {
+    kind: "document";
+    id: string;
+    __TYPE__: "DocumentLink";
+    variant?: string | undefined;
+    text?: string | undefined;
+  } | {
+    kind: "web";
+    url: string;
+    __TYPE__: "ExternalLink";
+    target?: string | null | undefined;
+    preview?: {
+      title?: string | undefined;
+    } | null | undefined;
+    variant?: string | undefined;
+    text?: string | undefined;
+  } | {
+    kind: "image";
+    __TYPE__: "ImageLink";
+    variant?: string | undefined;
+    text?: string | undefined;
+  } | {
+    kind: "file";
+    __TYPE__: "FileLink";
+    variant?: string | undefined;
+    text?: string | undefined;
+  } | {
+    kind: "media";
+    __TYPE__: "MediaLink";
+    variant?: string | undefined;
+    text?: string | undefined;
+  } | {
+    kind: "document";
+    __TYPE__: "DocumentLink";
+    variant?: string | undefined;
+    text?: string | undefined;
+  } | {
+    kind: "web";
+    __TYPE__: "ExternalLink";
+    variant?: string | undefined;
+    text?: string | undefined;
+  } | {
+    kind: "any";
+    __TYPE__: "AnyLink";
+    variant?: string | undefined;
+    text?: string | undefined;
+  }, {
+    value: LinkValueContent;
+    text?: string | undefined;
+    variant?: string | undefined;
+  }>>;
+}, z.core.$strip>;
+type LinkContent = z.infer<typeof LinkContentSchema>;
+//#endregion
+export { FilledLinkValueContent, LinkContent, LinkValueContent };
+//# sourceMappingURL=link.d.ts.map

package/dist/content/link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.d.ts","names":[],"sources":["../../src/content/link.ts"],"mappings":";;;cAiBM,iCAAA,EAAiC,CAAA,CAAA,aAAA;;;;;;;;;;;cAIjC,gCAAA,EAAgC,CAAA,CAAA,aAAA;;;;cAKhC,gCAAA,EAAgC,CAAA,CAAA,aAAA;;;;;;;;;cAIhC,+BAAA,EAA+B,CAAA,CAAA,aAAA;;;;cAK/B,gCAAA,EAAgC,CAAA,CAAA,aAAA;;;;cAKhC,oCAAA,EAAoC,CAAA,CAAA,aAAA;;;;;cAIpC,mCAAA,EAAmC,CAAA,CAAA,aAAA;;;;cAKnC,oCAAA,EAAoC,CAAA,CAAA,aAAA;;;;;;;;;cAIpC,mCAAA,EAAmC,CAAA,CAAA,aAAA;;;;cAKnC,yBAAA,EAAyB,CAAA,CAAA,aAAA;;;;KAe1B,2BAAA,GAA8B,CAAA,CAAE,KAAA,QAAa,iCAAA;AAAA,KAC7C,0BAAA,GAA6B,CAAA,CAAE,KAAA,QAAa,gCAAA;AAAA,KAC5C,8BAAA,GAAiC,CAAA,CAAE,KAAA,QAAa,oCAAA;AAAA,KAChD,8BAAA,GAAiC,CAAA,CAAE,KAAA,QAAa,oCAAA;AAAA,KACzC,sBAAA,GACT,2BAAA,GACA,0BAAA,GACA,8BAAA,GACA,8BAAA;AAAA,KAYE,0BAAA,GAA6B,CAAA,CAAE,KAAA,QAAa,gCAAA;AAAA,KAC5C,yBAAA,GAA4B,CAAA,CAAE,KAAA,QAAa,+BAAA;AAAA,KAC3C,0BAAA,GAA6B,CAAA,CAAE,KAAA,QAAa,gCAAA;AAAA,KAC5C,6BAAA,GAAgC,CAAA,CAAE,KAAA,QAAa,mCAAA;AAAA,KAC/C,6BAAA,GAAgC,CAAA,CAAE,KAAA,QAAa,mCAAA;AAAA,KAC/C,mBAAA,GAAsB,CAAA,CAAE,KAAA,QAAa,yBAAA;AAAA,KAC9B,qBAAA,GACT,0BAAA,GACA,yBAAA,GACA,0BAAA,GACA,6BAAA,GACA,6BAAA,GACA,mBAAA;AAAA,KAQS,gBAAA,GAAmB,sBAAA,GAAyB,qBAAA;AAAA,cAK3C,iBAAA,EAAiB,CAAA,CAAA,aAAA;;;;;;WAiBjB,MAAA;EAAA;;;WAOwB,CAAA,CAAE,WAAA,CAAY,gBAAA,EAAkB,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAWzD,WAAA,GAAc,CAAA,CAAE,KAAA,QAAa,iBAAA"}

package/dist/content/link.js

@@ -0,0 +1,50 @@
+import { AnyLinkLegacySchema, EmptyDocumentLinkValueLegacySchema, EmptyExternalLinkValueLegacySchema, EmptyFileLinkValueLegacySchema, EmptyImageLinkValueLegacySchema, EmptyMediaLinkValueLegacySchema, FilledDocumentLinkValueLegacySchema, FilledExternalLinkValueLegacySchema, FilledFileLinkValueLegacySchema, FilledImageLinkValueLegacySchema, LinkType } from "./legacy/link.js";
+import { z } from "zod/mini";
+//#region src/content/link.ts
+const FilledImageLinkValueContentSchema = z.extend(FilledImageLinkValueLegacySchema, { __TYPE__: z.literal(LinkType.Image) });
+const EmptyImageLinkValueContentSchema = z.extend(EmptyImageLinkValueLegacySchema, { __TYPE__: z.literal(LinkType.Image) });
+const FilledFileLinkValueContentSchema = z.extend(FilledFileLinkValueLegacySchema, { __TYPE__: z.literal(LinkType.File) });
+const EmptyFileLinkValueContentSchema = z.extend(EmptyFileLinkValueLegacySchema, { __TYPE__: z.literal(LinkType.File) });
+const EmptyMediaLinkValueContentSchema = z.extend(EmptyMediaLinkValueLegacySchema, { __TYPE__: z.literal(LinkType.Media) });
+const FilledDocumentLinkValueContentSchema = z.extend(FilledDocumentLinkValueLegacySchema, { __TYPE__: z.literal(LinkType.Document) });
+const EmptyDocumentLinkValueContentSchema = z.extend(EmptyDocumentLinkValueLegacySchema, { __TYPE__: z.literal(LinkType.Document) });
+const FilledExternalLinkValueContentSchema = z.extend(FilledExternalLinkValueLegacySchema, { __TYPE__: z.literal(LinkType.External) });
+const EmptyExternalLinkValueContentSchema = z.extend(EmptyExternalLinkValueLegacySchema, { __TYPE__: z.literal(LinkType.External) });
+const AnyLinkValueContentSchema = z.extend(AnyLinkLegacySchema, { __TYPE__: z.literal(LinkType.Any) });
+const FilledLinkValueContentSchema = z.union([
+	FilledImageLinkValueContentSchema,
+	FilledFileLinkValueContentSchema,
+	FilledDocumentLinkValueContentSchema,
+	FilledExternalLinkValueContentSchema
+]);
+const EmptyLinkValueContentSchema = z.union([
+	EmptyImageLinkValueContentSchema,
+	EmptyFileLinkValueContentSchema,
+	EmptyMediaLinkValueContentSchema,
+	EmptyDocumentLinkValueContentSchema,
+	EmptyExternalLinkValueContentSchema,
+	AnyLinkValueContentSchema
+]);
+const LinkValueContentSchema = z.union([FilledLinkValueContentSchema, EmptyLinkValueContentSchema]);
+const LinkContentType = "LinkContent";
+const LinkContentSchema = z.object({
+	__TYPE__: z.literal(LinkContentType),
+	key: z.transform((value) => z.uuidv4().safeParse(value).data || crypto.randomUUID()),
+	value: z.pipe(z.pipe(z.pipe(z.record(z.string(), z.unknown()), z.transform(({ text, variant, ...value }) => ({
+		text,
+		variant,
+		value
+	}))), z.object({
+		text: z.optional(z.string()),
+		variant: z.optional(z.string()),
+		value: LinkValueContentSchema
+	})), z.transform(({ text, variant, value }) => ({
+		...text ? { text } : {},
+		...variant ? { variant } : {},
+		...value
+	})))
+});
+//#endregion
+export { FilledLinkValueContentSchema, LinkContentSchema, LinkContentType };
+
+//# sourceMappingURL=link.js.map

package/dist/content/link.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.js","names":[],"sources":["../../src/content/link.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport {\n\tEmptyDocumentLinkValueLegacySchema,\n\tEmptyImageLinkValueLegacySchema,\n\tFilledDocumentLinkValueLegacySchema,\n\tFilledFileLinkValueLegacySchema,\n\tFilledImageLinkValueLegacySchema,\n\tEmptyMediaLinkValueLegacySchema,\n\tFilledExternalLinkValueLegacySchema,\n\tEmptyExternalLinkValueLegacySchema,\n\tAnyLinkLegacySchema,\n\tLinkType,\n\tEmptyFileLinkValueLegacySchema,\n} from \"./legacy/link\"\n\n// Image\nconst FilledImageLinkValueContentSchema = z.extend(FilledImageLinkValueLegacySchema, {\n\t__TYPE__: z.literal(LinkType.Image),\n})\n\nconst EmptyImageLinkValueContentSchema = z.extend(EmptyImageLinkValueLegacySchema, {\n\t__TYPE__: z.literal(LinkType.Image),\n})\n\n// File\nconst FilledFileLinkValueContentSchema = z.extend(FilledFileLinkValueLegacySchema, {\n\t__TYPE__: z.literal(LinkType.File),\n})\n\nconst EmptyFileLinkValueContentSchema = z.extend(EmptyFileLinkValueLegacySchema, {\n\t__TYPE__: z.literal(LinkType.File),\n})\n\n// Media\nconst EmptyMediaLinkValueContentSchema = z.extend(EmptyMediaLinkValueLegacySchema, {\n\t__TYPE__: z.literal(LinkType.Media),\n})\n\n// Document\nconst FilledDocumentLinkValueContentSchema = z.extend(FilledDocumentLinkValueLegacySchema, {\n\t__TYPE__: z.literal(LinkType.Document),\n})\n\nconst EmptyDocumentLinkValueContentSchema = z.extend(EmptyDocumentLinkValueLegacySchema, {\n\t__TYPE__: z.literal(LinkType.Document),\n})\n\n// External\nconst FilledExternalLinkValueContentSchema = z.extend(FilledExternalLinkValueLegacySchema, {\n\t__TYPE__: z.literal(LinkType.External),\n})\n\nconst EmptyExternalLinkValueContentSchema = z.extend(EmptyExternalLinkValueLegacySchema, {\n\t__TYPE__: z.literal(LinkType.External),\n})\n\n// Any\nconst AnyLinkValueContentSchema = z.extend(AnyLinkLegacySchema, {\n\t__TYPE__: z.literal(LinkType.Any),\n})\n\n// All\n\n// Used by content/richText\nexport const FilledLinkValueContentSchema: z.ZodMiniType<FilledLinkValueContent> = z.union([\n\tFilledImageLinkValueContentSchema,\n\tFilledFileLinkValueContentSchema,\n\tFilledDocumentLinkValueContentSchema,\n\tFilledExternalLinkValueContentSchema,\n])\n\n// Used by content/legacy/link\ntype FilledImageLinkValueContent = z.infer<typeof FilledImageLinkValueContentSchema>\ntype FilledFileLinkValueContent = z.infer<typeof FilledFileLinkValueContentSchema>\ntype FilledDocumentLinkValueContent = z.infer<typeof FilledDocumentLinkValueContentSchema>\ntype FilledExternalLinkValueContent = z.infer<typeof FilledExternalLinkValueContentSchema>\nexport type FilledLinkValueContent =\n\t| FilledImageLinkValueContent\n\t| FilledFileLinkValueContent\n\t| FilledDocumentLinkValueContent\n\t| FilledExternalLinkValueContent\n\nconst EmptyLinkValueContentSchema: z.ZodMiniType<EmptyLinkValueContent> = z.union([\n\tEmptyImageLinkValueContentSchema,\n\tEmptyFileLinkValueContentSchema,\n\tEmptyMediaLinkValueContentSchema,\n\tEmptyDocumentLinkValueContentSchema,\n\tEmptyExternalLinkValueContentSchema,\n\tAnyLinkValueContentSchema,\n])\n\n// Used by content/codec/link\ntype EmptyImageLinkValueContent = z.infer<typeof EmptyImageLinkValueContentSchema>\ntype EmptyFileLinkValueContent = z.infer<typeof EmptyFileLinkValueContentSchema>\ntype EmptyMediaLinkValueContent = z.infer<typeof EmptyMediaLinkValueContentSchema>\ntype EmptyDocumentLinkValueContent = z.infer<typeof EmptyDocumentLinkValueContentSchema>\ntype EmptyExternalLinkValueContent = z.infer<typeof EmptyExternalLinkValueContentSchema>\ntype AnyLinkValueContent = z.infer<typeof AnyLinkValueContentSchema>\nexport type EmptyLinkValueContent =\n\t| EmptyImageLinkValueContent\n\t| EmptyFileLinkValueContent\n\t| EmptyMediaLinkValueContent\n\t| EmptyDocumentLinkValueContent\n\t| EmptyExternalLinkValueContent\n\t| AnyLinkValueContent\n\nconst LinkValueContentSchema: z.ZodMiniType<LinkValueContent> = z.union([\n\tFilledLinkValueContentSchema,\n\tEmptyLinkValueContentSchema,\n])\n\n// Used by content/codec/link\nexport type LinkValueContent = FilledLinkValueContent | EmptyLinkValueContent\n\n// Content\nexport const LinkContentType = \"LinkContent\" as const\n\nexport const LinkContentSchema = z.object({\n\t__TYPE__: z.literal(LinkContentType),\n\tkey: z.transform((value) => z.uuidv4().safeParse(value).data || crypto.randomUUID()),\n\t// We cannot use z.extend here because we're working with unions.\n\t// z.intersection wouldn't work also for the same reason.\n\tvalue: z.pipe(\n\t\tz.pipe(\n\t\t\tz.pipe(\n\t\t\t\tz.record(z.string(), z.unknown()),\n\t\t\t\tz.transform(\n\t\t\t\t\t({\n\t\t\t\t\t\ttext,\n\t\t\t\t\t\tvariant,\n\t\t\t\t\t\t...value\n\t\t\t\t\t}): {\n\t\t\t\t\t\ttext?: unknown\n\t\t\t\t\t\tvariant?: unknown\n\t\t\t\t\t\tvalue: Record<string, unknown>\n\t\t\t\t\t} => ({ text, variant, value }),\n\t\t\t\t),\n\t\t\t),\n\t\t\tz.object({\n\t\t\t\ttext: z.optional(z.string()),\n\t\t\t\tvariant: z.optional(z.string()),\n\t\t\t\tvalue: LinkValueContentSchema as z.ZodMiniType<LinkValueContent, Record<string, unknown>>,\n\t\t\t}),\n\t\t),\n\t\tz.transform(({ text, variant, value }) => ({\n\t\t\t...(text ? { text } : {}),\n\t\t\t...(variant ? { variant } : {}),\n\t\t\t...value,\n\t\t})),\n\t),\n})\n\nexport type LinkContent = z.infer<typeof LinkContentSchema>\n"],"mappings":";;;AAiBA,MAAM,oCAAoC,EAAE,OAAO,kCAAkC,EACpF,UAAU,EAAE,QAAQ,SAAS,MAAM,EACnC,CAAC;AAEF,MAAM,mCAAmC,EAAE,OAAO,iCAAiC,EAClF,UAAU,EAAE,QAAQ,SAAS,MAAM,EACnC,CAAC;AAGF,MAAM,mCAAmC,EAAE,OAAO,iCAAiC,EAClF,UAAU,EAAE,QAAQ,SAAS,KAAK,EAClC,CAAC;AAEF,MAAM,kCAAkC,EAAE,OAAO,gCAAgC,EAChF,UAAU,EAAE,QAAQ,SAAS,KAAK,EAClC,CAAC;AAGF,MAAM,mCAAmC,EAAE,OAAO,iCAAiC,EAClF,UAAU,EAAE,QAAQ,SAAS,MAAM,EACnC,CAAC;AAGF,MAAM,uCAAuC,EAAE,OAAO,qCAAqC,EAC1F,UAAU,EAAE,QAAQ,SAAS,SAAS,EACtC,CAAC;AAEF,MAAM,sCAAsC,EAAE,OAAO,oCAAoC,EACxF,UAAU,EAAE,QAAQ,SAAS,SAAS,EACtC,CAAC;AAGF,MAAM,uCAAuC,EAAE,OAAO,qCAAqC,EAC1F,UAAU,EAAE,QAAQ,SAAS,SAAS,EACtC,CAAC;AAEF,MAAM,sCAAsC,EAAE,OAAO,oCAAoC,EACxF,UAAU,EAAE,QAAQ,SAAS,SAAS,EACtC,CAAC;AAGF,MAAM,4BAA4B,EAAE,OAAO,qBAAqB,EAC/D,UAAU,EAAE,QAAQ,SAAS,IAAI,EACjC,CAAC;AAKF,MAAa,+BAAsE,EAAE,MAAM;CAC1F;CACA;CACA;CACA;CACA,CAAC;AAaF,MAAM,8BAAoE,EAAE,MAAM;CACjF;CACA;CACA;CACA;CACA;CACA;CACA,CAAC;AAiBF,MAAM,yBAA0D,EAAE,MAAM,CACvE,8BACA,4BACA,CAAC;AAMF,MAAa,kBAAkB;AAE/B,MAAa,oBAAoB,EAAE,OAAO;CACzC,UAAU,EAAE,QAAQ,gBAAgB;CACpC,KAAK,EAAE,WAAW,UAAU,EAAE,QAAQ,CAAC,UAAU,MAAM,CAAC,QAAQ,OAAO,YAAY,CAAC;CAGpF,OAAO,EAAE,KACR,EAAE,KACD,EAAE,KACD,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,EACjC,EAAE,WACA,EACA,MACA,SACA,GAAG,aAKE;EAAE;EAAM;EAAS;EAAO,EAC9B,CACD,EACD,EAAE,OAAO;EACR,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC;EAC5B,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC;EAC/B,OAAO;EACP,CAAC,CACF,EACD,EAAE,WAAW,EAAE,MAAM,SAAS,aAAa;EAC1C,GAAI,OAAO,EAAE,MAAM,GAAG,EAAE;EACxB,GAAI,UAAU,EAAE,SAAS,GAAG,EAAE;EAC9B,GAAG;EACH,EAAE,CACH;CACD,CAAC"}

package/dist/content/nestable.d.ts

@@ -0,0 +1,19 @@
+import { BooleanContent } from "./boolean.js";
+import { EmbedContent } from "./embed.js";
+import { EmptyContent } from "./empty.js";
+import { ColorContent, DateContent, NumberContent, RangeContent, SelectContent, TextContent, TimestampContent } from "./field.js";
+import { GeoPointContent } from "./geopoint.js";
+import { ImageContent } from "./image.js";
+import { IntegrationFieldContent } from "./integrationField.js";
+import { LinkContent } from "./link.js";
+import { RepeatableContent } from "./repeatable.js";
+import { RichTextContent } from "./richText.js";
+import { SeparatorContent } from "./separator.js";
+import { TableContent } from "./table.js";
+import { z } from "zod/mini";
+
+//#region src/content/nestable.d.ts
+type NestableContent = EmptyContent | BooleanContent | ColorContent | DateContent | EmbedContent | GeoPointContent | ImageContent | IntegrationFieldContent | LinkContent | NumberContent | RangeContent | RepeatableContent | RichTextContent | SelectContent | SeparatorContent | TableContent | TextContent | TimestampContent;
+//#endregion
+export { NestableContent };
+//# sourceMappingURL=nestable.d.ts.map

package/dist/content/nestable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestable.d.ts","names":[],"sources":["../../src/content/nestable.ts"],"mappings":";;;;;;;;;;;;;;;KAmEY,eAAA,GACT,YAAA,GACA,cAAA,GACA,YAAA,GACA,WAAA,GACA,YAAA,GACA,eAAA,GACA,YAAA,GACA,uBAAA,GACA,WAAA,GACA,aAAA,GACA,YAAA,GACA,iBAAA,GACA,eAAA,GACA,aAAA,GACA,gBAAA,GACA,YAAA,GACA,WAAA,GACA,gBAAA"}

package/dist/content/nestable.js

@@ -0,0 +1,56 @@
+import { BooleanContentSchema, BooleanContentType } from "./boolean.js";
+import { EmbedContentSchema, EmbedContentType } from "./embed.js";
+import { EmptyContentSchema, EmptyContentType } from "./empty.js";
+import { ColorContentSchema, DateContentSchema, FieldContentType, NumberContentSchema, RangeContentSchema, SelectContentSchema, TextContentSchema, TimestampContentSchema } from "./field.js";
+import { GeoPointContentSchema, GeoPointContentType } from "./geopoint.js";
+import { ImageContentSchema, ImageContentType } from "./image.js";
+import { IntegrationFieldContentSchema, IntegrationFieldContentType } from "./integrationField.js";
+import { LinkContentSchema, LinkContentType } from "./link.js";
+import { RepeatableContentSchema, RepeatableContentType } from "./repeatable.js";
+import { RichTextContentSchema, RichTextContentType } from "./richText.js";
+import { SeparatorContentSchema, SeparatorContentType } from "./separator.js";
+import { TableContentSchema, TableContentType } from "./table.js";
+import { z } from "zod/mini";
+//#region src/content/nestable.ts
+const NestableContentSchema = z.union([
+	EmptyContentSchema,
+	BooleanContentSchema,
+	ColorContentSchema,
+	DateContentSchema,
+	EmbedContentSchema,
+	GeoPointContentSchema,
+	ImageContentSchema,
+	IntegrationFieldContentSchema,
+	LinkContentSchema,
+	NumberContentSchema,
+	RangeContentSchema,
+	RepeatableContentSchema,
+	RichTextContentSchema,
+	SelectContentSchema,
+	SeparatorContentSchema,
+	TableContentSchema,
+	TextContentSchema,
+	TimestampContentSchema
+]);
+const NestableContentTypes = [
+	EmptyContentType,
+	BooleanContentType,
+	EmbedContentType,
+	FieldContentType,
+	GeoPointContentType,
+	ImageContentType,
+	IntegrationFieldContentType,
+	LinkContentType,
+	RepeatableContentType,
+	RichTextContentType,
+	SeparatorContentType,
+	TableContentType
+];
+/** @internal */
+function isNestableContent(content) {
+	return NestableContentTypes.includes(content.__TYPE__);
+}
+//#endregion
+export { NestableContentSchema, isNestableContent };
+
+//# sourceMappingURL=nestable.js.map

package/dist/content/nestable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestable.js","names":[],"sources":["../../src/content/nestable.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport type { NestableModel } from \"../model/nestable\"\nimport type { BooleanContent } from \"./boolean\"\nimport { BooleanContentDefaultValue, BooleanContentSchema, BooleanContentType } from \"./boolean\"\nimport type { EmbedContent } from \"./embed\"\nimport { EmbedContentSchema, EmbedContentType } from \"./embed\"\nimport type { EmptyContent } from \"./empty\"\nimport { EmptyContentSchema, EmptyContentType } from \"./empty\"\nimport type {\n\tColorContent,\n\tDateContent,\n\tNumberContent,\n\tRangeContent,\n\tSelectContent,\n\tTextContent,\n\tTimestampContent,\n} from \"./field\"\nimport {\n\tColorContentSchema,\n\tDateContentSchema,\n\tFieldContentType,\n\tNumberContentSchema,\n\tRangeContentSchema,\n\tSelectContentDefaultValue,\n\tSelectContentSchema,\n\tTextContentSchema,\n\tTimestampContentSchema,\n} from \"./field\"\nimport type { GeoPointContent } from \"./geopoint\"\nimport { GeoPointContentSchema, GeoPointContentType } from \"./geopoint\"\nimport type { ImageContent } from \"./image\"\nimport { ImageContentSchema, ImageContentType } from \"./image\"\nimport type { IntegrationFieldContent } from \"./integrationField\"\nimport { IntegrationFieldContentSchema, IntegrationFieldContentType } from \"./integrationField\"\nimport type { LinkContent } from \"./link\"\nimport { LinkContentSchema, LinkContentType } from \"./link\"\nimport type { RepeatableContent } from \"./repeatable\"\nimport { RepeatableContentSchema, RepeatableContentType } from \"./repeatable\"\nimport type { RichTextContent } from \"./richText\"\nimport { RichTextContentSchema, RichTextContentType } from \"./richText\"\nimport type { SeparatorContent } from \"./separator\"\nimport { SeparatorContentSchema, SeparatorContentType } from \"./separator\"\nimport type { TableContent } from \"./table\"\nimport { TableContentSchema, TableContentType } from \"./table\"\n\nexport const NestableContentSchema: z.ZodMiniType<NestableContent> = z.union([\n\tEmptyContentSchema,\n\tBooleanContentSchema,\n\tColorContentSchema,\n\tDateContentSchema,\n\tEmbedContentSchema,\n\tGeoPointContentSchema,\n\tImageContentSchema,\n\tIntegrationFieldContentSchema,\n\tLinkContentSchema,\n\tNumberContentSchema,\n\tRangeContentSchema,\n\tRepeatableContentSchema,\n\tRichTextContentSchema,\n\tSelectContentSchema,\n\tSeparatorContentSchema,\n\tTableContentSchema,\n\tTextContentSchema,\n\tTimestampContentSchema,\n])\n\nexport type NestableContent =\n\t| EmptyContent\n\t| BooleanContent\n\t| ColorContent\n\t| DateContent\n\t| EmbedContent\n\t| GeoPointContent\n\t| ImageContent\n\t| IntegrationFieldContent\n\t| LinkContent\n\t| NumberContent\n\t| RangeContent\n\t| RepeatableContent\n\t| RichTextContent\n\t| SelectContent\n\t| SeparatorContent\n\t| TableContent\n\t| TextContent\n\t| TimestampContent\n\nconst NestableContentTypes = [\n\tEmptyContentType,\n\tBooleanContentType,\n\tEmbedContentType,\n\tFieldContentType,\n\tGeoPointContentType,\n\tImageContentType,\n\tIntegrationFieldContentType,\n\tLinkContentType,\n\tRepeatableContentType,\n\tRichTextContentType,\n\tSeparatorContentType,\n\tTableContentType,\n]\ntype NestableContentType = (typeof NestableContentTypes)[number]\n\n/** @internal */\nexport function isNestableContent(content: {\n\t__TYPE__: string\n}): content is { __TYPE__: NestableContentType } {\n\treturn (NestableContentTypes as string[]).includes(content.__TYPE__)\n}\n\n/**\n * Returns the default value for a nestable widget based on its configuration.\n * Currently only Boolean and Select fields have default values.\n */\nexport const NestableContentDefaultValue = (\n\twidgetDef: NestableModel,\n): NestableContent | undefined => {\n\tswitch (widgetDef.type) {\n\t\tcase \"Boolean\":\n\t\t\treturn BooleanContentDefaultValue(widgetDef)\n\t\tcase \"Select\":\n\t\t\treturn SelectContentDefaultValue(widgetDef)\n\t\tdefault:\n\t\t\treturn undefined\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;AA8CA,MAAa,wBAAwD,EAAE,MAAM;CAC5E;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA,CAAC;AAsBF,MAAM,uBAAuB;CAC5B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;;AAID,SAAgB,kBAAkB,SAEe;AAChD,QAAQ,qBAAkC,SAAS,QAAQ,SAAS"}

package/dist/content/repeatable.d.ts

@@ -0,0 +1,97 @@
+import { LinkValueContent } from "./link.js";
+import { z } from "zod/mini";
+
+//#region src/content/repeatable.d.ts
+declare const RepeatableContentSchema: z.ZodMiniObject<{
+  __TYPE__: z.ZodMiniLiteral<"RepeatableContent">;
+  type: z.ZodMiniLiteral<"Link">;
+  value: z.ZodMiniArray<z.ZodMiniObject<{
+    __TYPE__: z.ZodMiniLiteral<"LinkContent">;
+    key: z.ZodMiniTransform<string, unknown>;
+    value: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>, z.ZodMiniTransform<{
+      text?: unknown;
+      variant?: unknown;
+      value: Record<string, unknown>;
+    }, Record<string, unknown>>>, z.ZodMiniObject<{
+      text: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      variant: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      value: z.ZodMiniType<LinkValueContent, Record<string, unknown>>;
+    }, z.core.$strip>>, z.ZodMiniTransform<{
+      kind: "image";
+      id: string;
+      url: string;
+      height: string;
+      width: string;
+      size: string;
+      name: string;
+      __TYPE__: "ImageLink";
+      date?: string | null | undefined;
+      variant?: string | undefined;
+      text?: string | undefined;
+    } | {
+      kind: "file";
+      id: string;
+      url: string;
+      name: string;
+      size: string;
+      __TYPE__: "FileLink";
+      date?: string | null | undefined;
+      variant?: string | undefined;
+      text?: string | undefined;
+    } | {
+      kind: "document";
+      id: string;
+      __TYPE__: "DocumentLink";
+      variant?: string | undefined;
+      text?: string | undefined;
+    } | {
+      kind: "web";
+      url: string;
+      __TYPE__: "ExternalLink";
+      target?: string | null | undefined;
+      preview?: {
+        title?: string | undefined;
+      } | null | undefined;
+      variant?: string | undefined;
+      text?: string | undefined;
+    } | {
+      kind: "image";
+      __TYPE__: "ImageLink";
+      variant?: string | undefined;
+      text?: string | undefined;
+    } | {
+      kind: "file";
+      __TYPE__: "FileLink";
+      variant?: string | undefined;
+      text?: string | undefined;
+    } | {
+      kind: "media";
+      __TYPE__: "MediaLink";
+      variant?: string | undefined;
+      text?: string | undefined;
+    } | {
+      kind: "document";
+      __TYPE__: "DocumentLink";
+      variant?: string | undefined;
+      text?: string | undefined;
+    } | {
+      kind: "web";
+      __TYPE__: "ExternalLink";
+      variant?: string | undefined;
+      text?: string | undefined;
+    } | {
+      kind: "any";
+      __TYPE__: "AnyLink";
+      variant?: string | undefined;
+      text?: string | undefined;
+    }, {
+      value: LinkValueContent;
+      text?: string | undefined;
+      variant?: string | undefined;
+    }>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type RepeatableContent = z.infer<typeof RepeatableContentSchema>;
+//#endregion
+export { RepeatableContent };
+//# sourceMappingURL=repeatable.d.ts.map

package/dist/content/repeatable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repeatable.d.ts","names":[],"sources":["../../src/content/repeatable.ts"],"mappings":";;;;cAMa,uBAAA,EAAuB,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMxB,iBAAA,GAAoB,CAAA,CAAE,KAAA,QAAa,uBAAA"}

package/dist/content/repeatable.js

@@ -0,0 +1,17 @@
+import { LinkContentSchema, LinkContentType } from "./link.js";
+import { z } from "zod/mini";
+//#region src/content/repeatable.ts
+const RepeatableContentType = "RepeatableContent";
+const RepeatableContentSchema = z.object({
+	__TYPE__: z.literal(RepeatableContentType),
+	type: z.literal("Link"),
+	value: z.array(LinkContentSchema)
+});
+const RepeatableContentTypes = [LinkContentType];
+function isRepeatableContentValue(content) {
+	return RepeatableContentTypes.includes(content.__TYPE__);
+}
+//#endregion
+export { RepeatableContentSchema, RepeatableContentType, isRepeatableContentValue };
+
+//# sourceMappingURL=repeatable.js.map

package/dist/content/repeatable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repeatable.js","names":[],"sources":["../../src/content/repeatable.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { LinkContentSchema, LinkContentType } from \"./link\"\n\nexport const RepeatableContentType = \"RepeatableContent\" as const\n\nexport const RepeatableContentSchema = z.object({\n\t__TYPE__: z.literal(RepeatableContentType),\n\ttype: z.literal(\"Link\"),\n\tvalue: z.array(LinkContentSchema),\n})\n\nexport type RepeatableContent = z.infer<typeof RepeatableContentSchema>\n\nconst RepeatableContentTypes = [LinkContentType]\ntype RepeatableContentType = (typeof RepeatableContentTypes)[number]\nexport function isRepeatableContentValue(content: {\n\t__TYPE__: string\n}): content is { __TYPE__: RepeatableContentType } {\n\treturn (RepeatableContentTypes as string[]).includes(content.__TYPE__)\n}\n"],"mappings":";;;AAIA,MAAa,wBAAwB;AAErC,MAAa,0BAA0B,EAAE,OAAO;CAC/C,UAAU,EAAE,QAAQ,sBAAsB;CAC1C,MAAM,EAAE,QAAQ,OAAO;CACvB,OAAO,EAAE,MAAM,kBAAkB;CACjC,CAAC;AAIF,MAAM,yBAAyB,CAAC,gBAAgB;AAEhD,SAAgB,yBAAyB,SAEU;AAClD,QAAQ,uBAAoC,SAAS,QAAQ,SAAS"}

package/dist/content/richText.d.ts

@@ -0,0 +1,91 @@
+import { FilledLinkValueContent } from "./link.js";
+import { Span } from "./legacy/richText.js";
+import { z } from "zod/mini";
+
+//#region src/content/richText.d.ts
+type RichTextContentSpan = Span<FilledLinkValueContent>;
+declare const TextBlockValueSchema: z.ZodMiniObject<{
+  type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"paragraph">, z.ZodMiniLiteral<"heading1">, z.ZodMiniLiteral<"heading2">, z.ZodMiniLiteral<"heading3">, z.ZodMiniLiteral<"heading4">, z.ZodMiniLiteral<"heading5">, z.ZodMiniLiteral<"heading6">, z.ZodMiniLiteral<"preformatted">, z.ZodMiniLiteral<"o-list-item">, z.ZodMiniLiteral<"list-item">]>;
+  content: z.ZodMiniObject<{
+    text: z.ZodMiniString<string>;
+    spans: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniArray<z.ZodMiniUnknown>, z.ZodMiniTransform<({
+      type: "label";
+      start: number;
+      end: number;
+      data: string;
+    } | {
+      type: "strong" | "em" | "list-item";
+      start: number;
+      end: number;
+    } | {
+      type: "hyperlink";
+      start: number;
+      end: number;
+      data: FilledLinkValueContent;
+    })[], unknown[]>>>;
+  }, z.core.$strip>;
+  label: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  direction: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strip>;
+type TextBlockValue = z.infer<typeof TextBlockValueSchema>;
+declare const ImageBlockValueSchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"image">;
+  data: z.ZodMiniObject<{
+    origin: z.ZodMiniObject<{
+      id: z.ZodMiniString<string>;
+      url: z.ZodMiniString<string>;
+      width: z.ZodMiniNumber<number>;
+      height: z.ZodMiniNumber<number>;
+    }, z.core.$strip>;
+    width: z.ZodMiniNumber<number>;
+    height: z.ZodMiniNumber<number>;
+    edit: z.ZodMiniObject<{
+      zoom: z.ZodMiniNumber<number>;
+      crop: z.ZodMiniObject<{
+        x: z.ZodMiniNumber<number>;
+        y: z.ZodMiniNumber<number>;
+      }, z.core.$strip>;
+      background: z.ZodMiniString<string>;
+    }, z.core.$strip>;
+    url: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    credits: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>, z.ZodMiniTransform<string | null, string | null | undefined>>>;
+    alt: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>, z.ZodMiniTransform<string | null, string | null | undefined>>>;
+    provider: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    linkTo: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniType<FilledLinkValueContent, unknown, z.core.$ZodTypeInternals<FilledLinkValueContent, unknown>>>>;
+  }, z.core.$strip>;
+  label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  direction: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+}, z.core.$strip>;
+type ImageBlockValue = z.infer<typeof ImageBlockValueSchema>;
+declare const EmbedBlockValueSchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"embed">;
+  data: z.ZodMiniObject<{
+    embed_url: z.ZodMiniString<string>;
+    type: z.ZodMiniString<string>;
+    version: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>]>>>;
+    title: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    author_name: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    author_url: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    provider_name: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    provider_url: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    cache_age: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>]>>>;
+    thumbnail_url: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    thumbnail_width: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniNumber<number>>>;
+    thumbnail_height: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniNumber<number>>>;
+    html: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    __TYPE__: z.ZodMiniLiteral<"EmbedContent">;
+    all: z.ZodMiniUnknown;
+  }, z.core.$strip>;
+  label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  direction: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+}, z.core.$strip>;
+type EmbedBlockValue = z.infer<typeof EmbedBlockValueSchema>;
+type RichTextContentBlock = TextBlockValue | ImageBlockValue | EmbedBlockValue;
+declare const RichTextContentType: "StructuredTextContent";
+type RichTextContent = {
+  __TYPE__: typeof RichTextContentType;
+  value: RichTextContentBlock[];
+};
+//#endregion
+export { RichTextContent, RichTextContentBlock, RichTextContentSpan };
+//# sourceMappingURL=richText.d.ts.map

package/dist/content/richText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"richText.d.ts","names":[],"sources":["../../src/content/richText.ts"],"mappings":";;;;;KAeY,mBAAA,GAAsB,IAAA,CAAK,sBAAA;AAAA,cAOjC,oBAAA,EAAoB,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;KACrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA;AAAA,cAE/B,qBAAA,EAAqB,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAItB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA;AAAA,cAEhC,qBAAA,EAAqB,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;KACtB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA;AAAA,KAS1B,oBAAA,GAAuB,cAAA,GAAiB,eAAA,GAAkB,eAAA;AAAA,cAEzD,mBAAA;AAAA,KAED,eAAA;EACX,QAAA,SAAiB,mBAAA;EACjB,KAAA,EAAO,oBAAA;AAAA"}

package/dist/content/richText.js

@@ -0,0 +1,24 @@
+import { EmbedContentSchema } from "./embed.js";
+import { ImageViewContentSchema } from "./image.js";
+import { FilledLinkValueContentSchema } from "./link.js";
+import { getEmbedBlockSchema, getImageBlockSchema, getSpanSchema, getTextBlockSchema } from "./legacy/richText.js";
+import { z } from "zod/mini";
+//#region src/content/richText.ts
+const RichTextContentSpanSchema = getSpanSchema(FilledLinkValueContentSchema);
+const TextBlockValueSchema = getTextBlockSchema(FilledLinkValueContentSchema);
+const ImageBlockValueSchema = getImageBlockSchema(ImageViewContentSchema, FilledLinkValueContentSchema);
+const EmbedBlockValueSchema = getEmbedBlockSchema(EmbedContentSchema);
+const RichTextContentBlockSchema = z.union([
+	TextBlockValueSchema,
+	ImageBlockValueSchema,
+	EmbedBlockValueSchema
+]);
+const RichTextContentType = "StructuredTextContent";
+const RichTextContentSchema = z.object({
+	__TYPE__: z.literal(RichTextContentType),
+	value: z.array(RichTextContentBlockSchema)
+});
+//#endregion
+export { RichTextContentBlockSchema, RichTextContentSchema, RichTextContentSpanSchema, RichTextContentType };
+
+//# sourceMappingURL=richText.js.map

package/dist/content/richText.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"richText.js","names":[],"sources":["../../src/content/richText.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { EmbedContentSchema } from \"./embed\"\nimport { ImageViewContentSchema } from \"./image\"\nimport {\n\tgetEmbedBlockSchema,\n\tgetImageBlockSchema,\n\tgetSpanSchema,\n\tgetTextBlockSchema,\n} from \"./legacy/richText\"\nimport type { Span } from \"./legacy/richText\"\nimport type { FilledLinkValueContent } from \"./link\"\nimport { FilledLinkValueContentSchema } from \"./link\"\n\n// Spans\nexport type RichTextContentSpan = Span<FilledLinkValueContent>\n\nexport const RichTextContentSpanSchema: z.ZodMiniType<RichTextContentSpan> = getSpanSchema(\n\tFilledLinkValueContentSchema,\n)\n\n// Blocks\nconst TextBlockValueSchema = getTextBlockSchema(FilledLinkValueContentSchema)\ntype TextBlockValue = z.infer<typeof TextBlockValueSchema>\n\nconst ImageBlockValueSchema = getImageBlockSchema(\n\tImageViewContentSchema,\n\tFilledLinkValueContentSchema,\n)\ntype ImageBlockValue = z.infer<typeof ImageBlockValueSchema>\n\nconst EmbedBlockValueSchema = getEmbedBlockSchema(EmbedContentSchema)\ntype EmbedBlockValue = z.infer<typeof EmbedBlockValueSchema>\n\nexport const RichTextContentBlockSchema: z.ZodMiniType<RichTextContentBlock> = z.union([\n\tTextBlockValueSchema,\n\tImageBlockValueSchema,\n\tEmbedBlockValueSchema,\n])\n\n// Used by content/codec/richText\nexport type RichTextContentBlock = TextBlockValue | ImageBlockValue | EmbedBlockValue\n\nexport const RichTextContentType = \"StructuredTextContent\" as const\n\nexport type RichTextContent = {\n\t__TYPE__: typeof RichTextContentType\n\tvalue: RichTextContentBlock[]\n}\n\nexport const RichTextContentSchema: z.ZodMiniType<RichTextContent> = z.object({\n\t__TYPE__: z.literal(RichTextContentType),\n\tvalue: z.array(RichTextContentBlockSchema),\n})\n"],"mappings":";;;;;;AAiBA,MAAa,4BAAgE,cAC5E,6BACA;AAGD,MAAM,uBAAuB,mBAAmB,6BAA6B;AAG7E,MAAM,wBAAwB,oBAC7B,wBACA,6BACA;AAGD,MAAM,wBAAwB,oBAAoB,mBAAmB;AAGrE,MAAa,6BAAkE,EAAE,MAAM;CACtF;CACA;CACA;CACA,CAAC;AAKF,MAAa,sBAAsB;AAOnC,MAAa,wBAAwD,EAAE,OAAO;CAC7E,UAAU,EAAE,QAAQ,oBAAoB;CACxC,OAAO,EAAE,MAAM,2BAA2B;CAC1C,CAAC"}

package/dist/content/separator.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod/mini";
+
+//#region src/content/separator.d.ts
+declare const SeparatorContentSchema: z.ZodMiniObject<{
+  __TYPE__: z.ZodMiniLiteral<"SeparatorContent">;
+}, z.core.$strip>;
+type SeparatorContent = z.infer<typeof SeparatorContentSchema>;
+//#endregion
+export { SeparatorContent };
+//# sourceMappingURL=separator.d.ts.map

package/dist/content/separator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"separator.d.ts","names":[],"sources":["../../src/content/separator.ts"],"mappings":";;;cAIa,sBAAA,EAAsB,CAAA,CAAA,aAAA;;;KAIvB,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,sBAAA"}

package/dist/content/separator.js

@@ -0,0 +1,8 @@
+import { z } from "zod/mini";
+//#region src/content/separator.ts
+const SeparatorContentType = "SeparatorContent";
+const SeparatorContentSchema = z.object({ __TYPE__: z.literal(SeparatorContentType) });
+//#endregion
+export { SeparatorContentSchema, SeparatorContentType };
+
+//# sourceMappingURL=separator.js.map

package/dist/content/separator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"separator.js","names":[],"sources":["../../src/content/separator.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nexport const SeparatorContentType = \"SeparatorContent\" as const\n\nexport const SeparatorContentSchema = z.object({\n\t__TYPE__: z.literal(SeparatorContentType),\n})\n\nexport type SeparatorContent = z.infer<typeof SeparatorContentSchema>\n"],"mappings":";;AAEA,MAAa,uBAAuB;AAEpC,MAAa,yBAAyB,EAAE,OAAO,EAC9C,UAAU,EAAE,QAAQ,qBAAqB,EACzC,CAAC"}

package/dist/content/slice.d.ts

@@ -0,0 +1,24 @@
+import { NestableContent } from "./nestable.js";
+import { GroupItemContent, NestableAndGroupContent } from "./group.js";
+import { z } from "zod/mini";
+
+//#region src/content/slice.d.ts
+declare const LegacySliceContentSchema: z.ZodMiniType<NestableAndGroupContent, unknown, z.core.$ZodTypeInternals<NestableAndGroupContent, unknown>>;
+type LegacySliceContent = z.infer<typeof LegacySliceContentSchema>;
+declare const CompositeSliceContentSchema: z.ZodMiniObject<{
+  __TYPE__: z.ZodMiniLiteral<"CompositeSliceContent">;
+  nonRepeat: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniType<NestableContent, unknown, z.core.$ZodTypeInternals<NestableContent, unknown>>>;
+  repeat: z.ZodMiniArray<z.ZodMiniType<GroupItemContent, unknown, z.core.$ZodTypeInternals<GroupItemContent, unknown>>>;
+}, z.core.$strip>;
+type CompositeSliceContent = z.infer<typeof CompositeSliceContentSchema>;
+declare const SharedSliceContentSchema: z.ZodMiniObject<{
+  __TYPE__: z.ZodMiniLiteral<"SharedSliceContent">;
+  variation: z.ZodMiniString<string>;
+  primary: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniType<NestableAndGroupContent, unknown, z.core.$ZodTypeInternals<NestableAndGroupContent, unknown>>>;
+  items: z.ZodMiniArray<z.ZodMiniType<GroupItemContent, unknown, z.core.$ZodTypeInternals<GroupItemContent, unknown>>>;
+}, z.core.$strip>;
+type SharedSliceContent = z.infer<typeof SharedSliceContentSchema>;
+type SliceContent = LegacySliceContent | CompositeSliceContent | SharedSliceContent;
+//#endregion
+export { CompositeSliceContent, LegacySliceContent, SharedSliceContent, SliceContent };
+//# sourceMappingURL=slice.d.ts.map

package/dist/content/slice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slice.d.ts","names":[],"sources":["../../src/content/slice.ts"],"mappings":";;;;;cAMa,wBAAA,EAAwB,CAAA,CAAA,WAAA,CAAgC,uBAAA,WAAhC,CAAA,CAAA,IAAA,CAAA,iBAAA,CAAA,uBAAA;AAAA,KAEzB,kBAAA,GAAqB,CAAA,CAAE,KAAA,QAAa,wBAAA;AAAA,cAKnC,2BAAA,EAA2B,CAAA,CAAA,aAAA;;;;;KAM5B,qBAAA,GAAwB,CAAA,CAAE,KAAA,QAAa,2BAAA;AAAA,cAKtC,wBAAA,EAAwB,CAAA,CAAA,aAAA;;;;;;KAOzB,kBAAA,GAAqB,CAAA,CAAE,KAAA,QAAa,wBAAA;AAAA,KASpC,YAAA,GAAe,kBAAA,GAAqB,qBAAA,GAAwB,kBAAA"}