@prismicio/types-internal 3.17.0 → 4.0.0-canary.4689e2d

package/dist/content/link.d.ts

@@ -0,0 +1,140 @@
+import { z } from "zod/mini";
+
+//#region src/content/link.d.ts
+declare const FilledImageLinkContentValueSchema: 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 EmptyImageLinkContentValueSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniLiteral<"image">;
+  __TYPE__: z.ZodMiniLiteral<"ImageLink">;
+}, z.core.$strict>;
+declare const FilledFileLinkContentValueSchema: 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 EmptyFileLinkContentValueSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniLiteral<"file">;
+  __TYPE__: z.ZodMiniLiteral<"FileLink">;
+}, z.core.$strict>;
+declare const EmptyMediaLinkContentValueSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniLiteral<"media">;
+  __TYPE__: z.ZodMiniLiteral<"MediaLink">;
+}, z.core.$strict>;
+declare const FilledDocumentLinkContentValueSchema: 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 EmptyDocumentLinkContentValueSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniLiteral<"document">;
+  __TYPE__: z.ZodMiniLiteral<"DocumentLink">;
+}, z.core.$strict>;
+declare const FilledExternalLinkContentValueSchema: 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 EmptyExternalLinkContentValueSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniLiteral<"web">;
+  __TYPE__: z.ZodMiniLiteral<"ExternalLink">;
+}, z.core.$strict>;
+declare const AnyLinkContentValueSchema: z.ZodMiniObject<{
+  kind: z.ZodMiniTransform<"any", unknown>;
+  __TYPE__: z.ZodMiniLiteral<"AnyLink">;
+}, z.core.$strict>;
+type FilledImageLinkContentValue = z.infer<typeof FilledImageLinkContentValueSchema>;
+type FilledFileLinkContentValue = z.infer<typeof FilledFileLinkContentValueSchema>;
+type FilledDocumentLinkContentValue = z.infer<typeof FilledDocumentLinkContentValueSchema>;
+type FilledExternalLinkContentValue = z.infer<typeof FilledExternalLinkContentValueSchema>;
+type FilledLinkContentValue = FilledImageLinkContentValue | FilledFileLinkContentValue | FilledDocumentLinkContentValue | FilledExternalLinkContentValue;
+type EmptyImageLinkContentValue = z.infer<typeof EmptyImageLinkContentValueSchema>;
+type EmptyFileLinkContentValue = z.infer<typeof EmptyFileLinkContentValueSchema>;
+type EmptyMediaLinkContentValue = z.infer<typeof EmptyMediaLinkContentValueSchema>;
+type EmptyDocumentLinkContentValue = z.infer<typeof EmptyDocumentLinkContentValueSchema>;
+type EmptyExternalLinkContentValue = z.infer<typeof EmptyExternalLinkContentValueSchema>;
+type AnyLinkContentValue = z.infer<typeof AnyLinkContentValueSchema>;
+type EmptyLinkContentValue = EmptyImageLinkContentValue | EmptyFileLinkContentValue | EmptyMediaLinkContentValue | EmptyDocumentLinkContentValue | EmptyExternalLinkContentValue | AnyLinkContentValue;
+type LinkContentValue = FilledLinkContentValue | EmptyLinkContentValue;
+declare const FilledLinkContentSchema: 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<FilledLinkContentValue, Record<string, unknown>, z.core.$ZodTypeInternals<FilledLinkContentValue, Record<string, unknown>>>;
+  }, z.core.$strip>>, z.ZodMiniTransform<{
+    variant?: string | undefined;
+    text?: string | undefined;
+  } & FilledLinkContentValue, {
+    value: FilledLinkContentValue;
+    text?: string | undefined;
+    variant?: string | undefined;
+  }>>;
+}, z.core.$strip>;
+type FilledLinkContent = z.infer<typeof FilledLinkContentSchema>;
+declare const EmptyLinkContentSchema: 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<EmptyLinkContentValue, Record<string, unknown>, z.core.$ZodTypeInternals<EmptyLinkContentValue, Record<string, unknown>>>;
+  }, z.core.$strip>>, z.ZodMiniTransform<{
+    variant?: string | undefined;
+    text?: string | undefined;
+  } & EmptyLinkContentValue, {
+    value: EmptyLinkContentValue;
+    text?: string | undefined;
+    variant?: string | undefined;
+  }>>;
+}, z.core.$strip>;
+type EmptyLinkContent = z.infer<typeof EmptyLinkContentSchema>;
+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<LinkContentValue, Record<string, unknown>, z.core.$ZodTypeInternals<LinkContentValue, Record<string, unknown>>>;
+  }, z.core.$strip>>, z.ZodMiniTransform<{
+    variant?: string | undefined;
+    text?: string | undefined;
+  } & LinkContentValue, {
+    value: LinkContentValue;
+    text?: string | undefined;
+    variant?: string | undefined;
+  }>>;
+}, z.core.$strip>;
+type LinkContent = z.infer<typeof LinkContentSchema>;
+//#endregion
+export { EmptyLinkContent, EmptyLinkContentValue, FilledLinkContent, FilledLinkContentValue, LinkContent, LinkContentValue };
+//# 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,cAyC3C,uBAAA,EAAuB,CAAA,CAAA,aAAA;;;;;;WAlBtB,MAAA;EAAA;;;;;;;;;;;;;KAoBF,iBAAA,GAAoB,CAAA,CAAE,KAAA,QAAa,uBAAA;AAAA,cAElC,sBAAA,EAAsB,CAAA,CAAA,aAAA;;;;;;WAtBrB,MAAA;EAAA;;;;;;;;;;;;;KAwBF,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,sBAAA;AAAA,cAEjC,iBAAA,EAAiB,CAAA,CAAA,aAAA;;;;;;WA1BhB,MAAA;EAAA;;;;;;;;;;;;;KA4BF,WAAA,GAAc,CAAA,CAAE,KAAA,QAAa,iBAAA"}

package/dist/content/link.js

@@ -0,0 +1,53 @@
+import { AnyLinkLegacySchema, EmptyDocumentLinkLegacyValueSchema, EmptyExternalLinkLegacyValueSchema, EmptyFileLinkLegacyValueSchema, EmptyImageLinkLegacyValueSchema, EmptyMediaLinkLegacyValueSchema, FilledDocumentLinkLegacyValueSchema, FilledExternalLinkLegacyValueSchema, FilledFileLinkLegacyValueSchema, FilledImageLinkLegacyValueSchema, LinkType } from "./legacy/link.js";
+import { z } from "zod/mini";
+//#region src/content/link.ts
+const FilledImageLinkContentValueSchema = z.extend(FilledImageLinkLegacyValueSchema, { __TYPE__: z.literal(LinkType.Image) });
+const EmptyImageLinkContentValueSchema = z.extend(EmptyImageLinkLegacyValueSchema, { __TYPE__: z.literal(LinkType.Image) });
+const FilledFileLinkContentValueSchema = z.extend(FilledFileLinkLegacyValueSchema, { __TYPE__: z.literal(LinkType.File) });
+const EmptyFileLinkContentValueSchema = z.extend(EmptyFileLinkLegacyValueSchema, { __TYPE__: z.literal(LinkType.File) });
+const EmptyMediaLinkContentValueSchema = z.extend(EmptyMediaLinkLegacyValueSchema, { __TYPE__: z.literal(LinkType.Media) });
+const FilledDocumentLinkContentValueSchema = z.extend(FilledDocumentLinkLegacyValueSchema, { __TYPE__: z.literal(LinkType.Document) });
+const EmptyDocumentLinkContentValueSchema = z.extend(EmptyDocumentLinkLegacyValueSchema, { __TYPE__: z.literal(LinkType.Document) });
+const FilledExternalLinkContentValueSchema = z.extend(FilledExternalLinkLegacyValueSchema, { __TYPE__: z.literal(LinkType.External) });
+const EmptyExternalLinkContentValueSchema = z.extend(EmptyExternalLinkLegacyValueSchema, { __TYPE__: z.literal(LinkType.External) });
+const AnyLinkContentValueSchema = z.extend(AnyLinkLegacySchema, { __TYPE__: z.literal(LinkType.Any) });
+const FilledLinkContentValueSchema = z.union([
+	FilledImageLinkContentValueSchema,
+	FilledFileLinkContentValueSchema,
+	FilledDocumentLinkContentValueSchema,
+	FilledExternalLinkContentValueSchema
+]);
+const EmptyLinkContentValueSchema = z.union([
+	EmptyImageLinkContentValueSchema,
+	EmptyFileLinkContentValueSchema,
+	EmptyMediaLinkContentValueSchema,
+	EmptyDocumentLinkContentValueSchema,
+	EmptyExternalLinkContentValueSchema,
+	AnyLinkContentValueSchema
+]);
+const LinkContentValueSchema = z.union([FilledLinkContentValueSchema, EmptyLinkContentValueSchema]);
+const LinkContentType = "LinkContent";
+const getLinkContentSchema = (value) => 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
+	})), z.transform(({ text, variant, value }) => ({
+		...text ? { text } : {},
+		...variant ? { variant } : {},
+		...value
+	})))
+});
+const FilledLinkContentSchema = getLinkContentSchema(FilledLinkContentValueSchema);
+const EmptyLinkContentSchema = getLinkContentSchema(EmptyLinkContentValueSchema);
+const LinkContentSchema = getLinkContentSchema(LinkContentValueSchema);
+//#endregion
+export { EmptyLinkContentSchema, FilledLinkContentSchema, FilledLinkContentValueSchema, 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\tEmptyDocumentLinkLegacyValueSchema,\n\tEmptyImageLinkLegacyValueSchema,\n\tFilledDocumentLinkLegacyValueSchema,\n\tFilledFileLinkLegacyValueSchema,\n\tFilledImageLinkLegacyValueSchema,\n\tEmptyMediaLinkLegacyValueSchema,\n\tFilledExternalLinkLegacyValueSchema,\n\tEmptyExternalLinkLegacyValueSchema,\n\tAnyLinkLegacySchema,\n\tLinkType,\n\tEmptyFileLinkLegacyValueSchema,\n} from \"./legacy/link\"\n\n// Image\nconst FilledImageLinkContentValueSchema = z.extend(FilledImageLinkLegacyValueSchema, {\n\t__TYPE__: z.literal(LinkType.Image),\n})\n\nconst EmptyImageLinkContentValueSchema = z.extend(EmptyImageLinkLegacyValueSchema, {\n\t__TYPE__: z.literal(LinkType.Image),\n})\n\n// File\nconst FilledFileLinkContentValueSchema = z.extend(FilledFileLinkLegacyValueSchema, {\n\t__TYPE__: z.literal(LinkType.File),\n})\n\nconst EmptyFileLinkContentValueSchema = z.extend(EmptyFileLinkLegacyValueSchema, {\n\t__TYPE__: z.literal(LinkType.File),\n})\n\n// Media\nconst EmptyMediaLinkContentValueSchema = z.extend(EmptyMediaLinkLegacyValueSchema, {\n\t__TYPE__: z.literal(LinkType.Media),\n})\n\n// Document\nconst FilledDocumentLinkContentValueSchema = z.extend(FilledDocumentLinkLegacyValueSchema, {\n\t__TYPE__: z.literal(LinkType.Document),\n})\n\nconst EmptyDocumentLinkContentValueSchema = z.extend(EmptyDocumentLinkLegacyValueSchema, {\n\t__TYPE__: z.literal(LinkType.Document),\n})\n\n// External\nconst FilledExternalLinkContentValueSchema = z.extend(FilledExternalLinkLegacyValueSchema, {\n\t__TYPE__: z.literal(LinkType.External),\n})\n\nconst EmptyExternalLinkContentValueSchema = z.extend(EmptyExternalLinkLegacyValueSchema, {\n\t__TYPE__: z.literal(LinkType.External),\n})\n\n// Any\nconst AnyLinkContentValueSchema = z.extend(AnyLinkLegacySchema, {\n\t__TYPE__: z.literal(LinkType.Any),\n})\n\n// All\n\n// Used by content/richText\nexport const FilledLinkContentValueSchema: z.ZodMiniType<FilledLinkContentValue> = z.union([\n\tFilledImageLinkContentValueSchema,\n\tFilledFileLinkContentValueSchema,\n\tFilledDocumentLinkContentValueSchema,\n\tFilledExternalLinkContentValueSchema,\n])\n\n// Used by content/legacy/link\ntype FilledImageLinkContentValue = z.infer<typeof FilledImageLinkContentValueSchema>\ntype FilledFileLinkContentValue = z.infer<typeof FilledFileLinkContentValueSchema>\ntype FilledDocumentLinkContentValue = z.infer<typeof FilledDocumentLinkContentValueSchema>\ntype FilledExternalLinkContentValue = z.infer<typeof FilledExternalLinkContentValueSchema>\nexport type FilledLinkContentValue =\n\t| FilledImageLinkContentValue\n\t| FilledFileLinkContentValue\n\t| FilledDocumentLinkContentValue\n\t| FilledExternalLinkContentValue\n\nconst EmptyLinkContentValueSchema: z.ZodMiniType<EmptyLinkContentValue> = z.union([\n\tEmptyImageLinkContentValueSchema,\n\tEmptyFileLinkContentValueSchema,\n\tEmptyMediaLinkContentValueSchema,\n\tEmptyDocumentLinkContentValueSchema,\n\tEmptyExternalLinkContentValueSchema,\n\tAnyLinkContentValueSchema,\n])\n\n// Used by content/codec/link\ntype EmptyImageLinkContentValue = z.infer<typeof EmptyImageLinkContentValueSchema>\ntype EmptyFileLinkContentValue = z.infer<typeof EmptyFileLinkContentValueSchema>\ntype EmptyMediaLinkContentValue = z.infer<typeof EmptyMediaLinkContentValueSchema>\ntype EmptyDocumentLinkContentValue = z.infer<typeof EmptyDocumentLinkContentValueSchema>\ntype EmptyExternalLinkContentValue = z.infer<typeof EmptyExternalLinkContentValueSchema>\ntype AnyLinkContentValue = z.infer<typeof AnyLinkContentValueSchema>\nexport type EmptyLinkContentValue =\n\t| EmptyImageLinkContentValue\n\t| EmptyFileLinkContentValue\n\t| EmptyMediaLinkContentValue\n\t| EmptyDocumentLinkContentValue\n\t| EmptyExternalLinkContentValue\n\t| AnyLinkContentValue\n\nconst LinkContentValueSchema: z.ZodMiniType<LinkContentValue> = z.union([\n\tFilledLinkContentValueSchema,\n\tEmptyLinkContentValueSchema,\n])\n\n// Used by content/codec/link\nexport type LinkContentValue = FilledLinkContentValue | EmptyLinkContentValue\n\n// Content\nexport const LinkContentType = \"LinkContent\" as const\n\nconst getLinkContentSchema = <TValue extends LinkContentValue>(value: z.ZodMiniType<TValue>) =>\n\tz.object({\n\t\t__TYPE__: z.literal(LinkContentType),\n\t\tkey: z.transform((value) => z.uuidv4().safeParse(value).data || crypto.randomUUID()),\n\t\t// We cannot use z.extend here because we're working with unions.\n\t\t// z.intersection wouldn't work also for the same reason.\n\t\tvalue: z.pipe(\n\t\t\tz.pipe(\n\t\t\t\tz.pipe(\n\t\t\t\t\tz.record(z.string(), z.unknown()),\n\t\t\t\t\tz.transform(\n\t\t\t\t\t\t({\n\t\t\t\t\t\t\ttext,\n\t\t\t\t\t\t\tvariant,\n\t\t\t\t\t\t\t...value\n\t\t\t\t\t\t}): {\n\t\t\t\t\t\t\ttext?: unknown\n\t\t\t\t\t\t\tvariant?: unknown\n\t\t\t\t\t\t\tvalue: Record<string, unknown>\n\t\t\t\t\t\t} => ({ text, variant, value }),\n\t\t\t\t\t),\n\t\t\t\t),\n\t\t\t\tz.object({\n\t\t\t\t\ttext: z.optional(z.string()),\n\t\t\t\t\tvariant: z.optional(z.string()),\n\t\t\t\t\tvalue: value as z.ZodMiniType<TValue, Record<string, unknown>>,\n\t\t\t\t}),\n\t\t\t),\n\t\t\tz.transform(({ text, variant, value }) => ({\n\t\t\t\t...(text ? { text } : {}),\n\t\t\t\t...(variant ? { variant } : {}),\n\t\t\t\t...value,\n\t\t\t})),\n\t\t),\n\t})\n\nexport const FilledLinkContentSchema = getLinkContentSchema(FilledLinkContentValueSchema)\n\nexport type FilledLinkContent = z.infer<typeof FilledLinkContentSchema>\n\nexport const EmptyLinkContentSchema = getLinkContentSchema(EmptyLinkContentValueSchema)\n\nexport type EmptyLinkContent = z.infer<typeof EmptyLinkContentSchema>\n\nexport const LinkContentSchema = getLinkContentSchema(LinkContentValueSchema)\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,MAAM,wBAAyD,UAC9D,EAAE,OAAO;CACR,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;EACxB;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;AAEH,MAAa,0BAA0B,qBAAqB,6BAA6B;AAIzF,MAAa,yBAAyB,qBAAqB,4BAA4B;AAIvF,MAAa,oBAAoB,qBAAqB,uBAAuB"}

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":";;;;;;;;;;;;;;;KAiEY,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 { EmbedContentSchema, EmbedContentType } from "./embed.js";
+import { ImageContentSchema, ImageContentType } from "./image.js";
+import { LinkContentSchema, LinkContentType } from "./link.js";
+import { RichTextContentSchema, RichTextContentType } from "./richText.js";
+import { BooleanContentSchema, BooleanContentType } from "./boolean.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 { IntegrationFieldContentSchema, IntegrationFieldContentType } from "./integrationField.js";
+import { RepeatableContentSchema, RepeatableContentType } from "./repeatable.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 { BooleanContent } from \"./boolean\"\nimport { 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\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"],"mappings":";;;;;;;;;;;;;;AA4CA,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,32 @@
+import { LinkContentValue } 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<LinkContentValue, Record<string, unknown>, z.core.$ZodTypeInternals<LinkContentValue, Record<string, unknown>>>;
+    }, z.core.$strip>>, z.ZodMiniTransform<{
+      variant?: string | undefined;
+      text?: string | undefined;
+    } & LinkContentValue, {
+      value: LinkContentValue;
+      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 { FilledLinkContentValue } from "./link.js";
+import { RichTextNodeType, RichTextNodeTypes, Span } from "./legacy/richText.js";
+import { z } from "zod/mini";
+
+//#region src/content/richText.d.ts
+type RichTextContentSpan = Span<FilledLinkContentValue>;
+declare const RichTextContentTextBlockSchema: 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: FilledLinkContentValue;
+    })[], unknown[]>>>;
+  }, z.core.$strip>;
+  label: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  direction: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strip>;
+type RichTextContentTextBlock = z.infer<typeof RichTextContentTextBlockSchema>;
+declare const RichTextContentImageBlockSchema: 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<FilledLinkContentValue, unknown, z.core.$ZodTypeInternals<FilledLinkContentValue, unknown>>>>;
+  }, z.core.$strip>;
+  label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  direction: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+}, z.core.$strip>;
+type RichTextContentImageBlock = z.infer<typeof RichTextContentImageBlockSchema>;
+declare const RichTextContentEmbedBlockSchema: 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 RichTextContentEmbedBlock = z.infer<typeof RichTextContentEmbedBlockSchema>;
+type RichTextContentBlock = RichTextContentTextBlock | RichTextContentImageBlock | RichTextContentEmbedBlock;
+declare const RichTextContentType: "StructuredTextContent";
+type RichTextContent = {
+  __TYPE__: typeof RichTextContentType;
+  value: RichTextContentBlock[];
+};
+//#endregion
+export { RichTextContent, RichTextContentBlock, RichTextContentEmbedBlock, RichTextContentImageBlock, RichTextContentSpan, RichTextContentTextBlock };
+//# 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":";;;;;KAkBY,mBAAA,GAAsB,IAAA,CAAK,sBAAA;AAAA,cAOjC,8BAAA,EAA8B,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;KACxB,wBAAA,GAA2B,CAAA,CAAE,KAAA,QAAa,8BAAA;AAAA,cAEhD,+BAAA,EAA+B,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAIzB,yBAAA,GAA4B,CAAA,CAAE,KAAA,QAAa,+BAAA;AAAA,cAEjD,+BAAA,EAA+B,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;KACzB,yBAAA,GAA4B,CAAA,CAAE,KAAA,QAAa,+BAAA;AAAA,KAS3C,oBAAA,GACT,wBAAA,GACA,yBAAA,GACA,yBAAA;AAAA,cAEU,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 { ImageContentViewSchema } from "./image.js";
+import { getEmbedBlockSchema, getImageBlockSchema, getSpanSchema, getTextBlockSchema } from "./legacy/richText.js";
+import { FilledLinkContentValueSchema } from "./link.js";
+import { z } from "zod/mini";
+//#region src/content/richText.ts
+const RichTextContentSpanSchema = getSpanSchema(FilledLinkContentValueSchema);
+const RichTextContentTextBlockSchema = getTextBlockSchema(FilledLinkContentValueSchema);
+const RichTextContentImageBlockSchema = getImageBlockSchema(ImageContentViewSchema, FilledLinkContentValueSchema);
+const RichTextContentEmbedBlockSchema = getEmbedBlockSchema(EmbedContentSchema);
+const RichTextContentBlockSchema = z.union([
+	RichTextContentTextBlockSchema,
+	RichTextContentImageBlockSchema,
+	RichTextContentEmbedBlockSchema
+]);
+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 { ImageContentViewSchema } from \"./image\"\nimport {\n\tgetEmbedBlockSchema,\n\tgetImageBlockSchema,\n\tgetSpanSchema,\n\tgetTextBlockSchema,\n} from \"./legacy/richText\"\nimport type { Span } from \"./legacy/richText\"\nimport type { FilledLinkContentValue } from \"./link\"\nimport { FilledLinkContentValueSchema } from \"./link\"\n\nexport { RichTextNodeType } from \"./legacy/richText\"\nexport type { RichTextNodeTypes } from \"./legacy/richText\"\n\n// Spans\nexport type RichTextContentSpan = Span<FilledLinkContentValue>\n\nexport const RichTextContentSpanSchema: z.ZodMiniType<RichTextContentSpan> = getSpanSchema(\n\tFilledLinkContentValueSchema,\n)\n\n// Blocks\nconst RichTextContentTextBlockSchema = getTextBlockSchema(FilledLinkContentValueSchema)\nexport type RichTextContentTextBlock = z.infer<typeof RichTextContentTextBlockSchema>\n\nconst RichTextContentImageBlockSchema = getImageBlockSchema(\n\tImageContentViewSchema,\n\tFilledLinkContentValueSchema,\n)\nexport type RichTextContentImageBlock = z.infer<typeof RichTextContentImageBlockSchema>\n\nconst RichTextContentEmbedBlockSchema = getEmbedBlockSchema(EmbedContentSchema)\nexport type RichTextContentEmbedBlock = z.infer<typeof RichTextContentEmbedBlockSchema>\n\nexport const RichTextContentBlockSchema: z.ZodMiniType<RichTextContentBlock> = z.union([\n\tRichTextContentTextBlockSchema,\n\tRichTextContentImageBlockSchema,\n\tRichTextContentEmbedBlockSchema,\n])\n\n// Used by content/codec/richText\nexport type RichTextContentBlock =\n\t| RichTextContentTextBlock\n\t| RichTextContentImageBlock\n\t| RichTextContentEmbedBlock\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":";;;;;;AAoBA,MAAa,4BAAgE,cAC5E,6BACA;AAGD,MAAM,iCAAiC,mBAAmB,6BAA6B;AAGvF,MAAM,kCAAkC,oBACvC,wBACA,6BACA;AAGD,MAAM,kCAAkC,oBAAoB,mBAAmB;AAG/E,MAAa,6BAAkE,EAAE,MAAM;CACtF;CACA;CACA;CACA,CAAC;AAQF,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"}

package/dist/content/slice.js

@@ -0,0 +1,27 @@
+import { NestableContentSchema } from "./nestable.js";
+import { GroupItemContentSchema, NestableAndGroupContentSchema } from "./group.js";
+import { z } from "zod/mini";
+//#region src/content/slice.ts
+const LegacySliceContentSchema = NestableAndGroupContentSchema;
+const CompositeSliceContentType = "CompositeSliceContent";
+const CompositeSliceContentSchema = z.object({
+	__TYPE__: z.literal(CompositeSliceContentType),
+	nonRepeat: z.record(z.string(), NestableContentSchema),
+	repeat: z.array(GroupItemContentSchema)
+});
+const SharedSliceContentType = "SharedSliceContent";
+const SharedSliceContentSchema = z.object({
+	__TYPE__: z.literal(SharedSliceContentType),
+	variation: z.string(),
+	primary: z.record(z.string(), NestableAndGroupContentSchema),
+	items: z.array(GroupItemContentSchema)
+});
+const SliceContentSchema = z.union([
+	LegacySliceContentSchema,
+	CompositeSliceContentSchema,
+	SharedSliceContentSchema
+]);
+//#endregion
+export { CompositeSliceContentSchema, CompositeSliceContentType, LegacySliceContentSchema, SharedSliceContentSchema, SharedSliceContentType, SliceContentSchema };
+
+//# sourceMappingURL=slice.js.map

package/dist/content/slice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slice.js","names":[],"sources":["../../src/content/slice.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { GroupItemContentSchema, NestableAndGroupContentSchema } from \"./group\"\nimport { NestableContentSchema } from \"./nestable\"\n\n// Legacy (before 2020)\nexport const LegacySliceContentSchema = NestableAndGroupContentSchema\n\nexport type LegacySliceContent = z.infer<typeof LegacySliceContentSchema>\n\n// Composite (2020 to 2021)\nexport const CompositeSliceContentType = \"CompositeSliceContent\" as const\n\nexport const CompositeSliceContentSchema = z.object({\n\t__TYPE__: z.literal(CompositeSliceContentType),\n\tnonRepeat: z.record(z.string(), NestableContentSchema),\n\trepeat: z.array(GroupItemContentSchema),\n})\n\nexport type CompositeSliceContent = z.infer<typeof CompositeSliceContentSchema>\n\n// Shared (2021 to present)\nexport const SharedSliceContentType = \"SharedSliceContent\" as const\n\nexport const SharedSliceContentSchema = z.object({\n\t__TYPE__: z.literal(SharedSliceContentType),\n\tvariation: z.string(),\n\tprimary: z.record(z.string(), NestableAndGroupContentSchema),\n\titems: z.array(GroupItemContentSchema),\n})\n\nexport type SharedSliceContent = z.infer<typeof SharedSliceContentSchema>\n\n// All\nexport const SliceContentSchema: z.ZodMiniType<SliceContent> = z.union([\n\tLegacySliceContentSchema,\n\tCompositeSliceContentSchema,\n\tSharedSliceContentSchema,\n])\n\nexport type SliceContent = LegacySliceContent | CompositeSliceContent | SharedSliceContent\n"],"mappings":";;;;AAMA,MAAa,2BAA2B;AAKxC,MAAa,4BAA4B;AAEzC,MAAa,8BAA8B,EAAE,OAAO;CACnD,UAAU,EAAE,QAAQ,0BAA0B;CAC9C,WAAW,EAAE,OAAO,EAAE,QAAQ,EAAE,sBAAsB;CACtD,QAAQ,EAAE,MAAM,uBAAuB;CACvC,CAAC;AAKF,MAAa,yBAAyB;AAEtC,MAAa,2BAA2B,EAAE,OAAO;CAChD,UAAU,EAAE,QAAQ,uBAAuB;CAC3C,WAAW,EAAE,QAAQ;CACrB,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,8BAA8B;CAC5D,OAAO,EAAE,MAAM,uBAAuB;CACtC,CAAC;AAKF,MAAa,qBAAkD,EAAE,MAAM;CACtE;CACA;CACA;CACA,CAAC"}