@prismicio/types-internal 3.17.0 → 4.0.0-canary.72def6d

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

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.ts","names":[],"sources":["../../src/content/document.ts"],"mappings":";;;;cAKa,qBAAA,EAAqB,CAAA,CAAA,aAAA,CAAA,CAAA,CAAA,aAAA,UAAA,CAAA,CAAA,YAAA,WAAA,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEtB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA"}

package/dist/content/document.js

@@ -0,0 +1,9 @@
+import { WidgetKeySchema } from "../common/widgetKey.js";
+import { WidgetContentSchema } from "./widget.js";
+import { z } from "zod/mini";
+//#region src/content/document.ts
+const DocumentContentSchema = z.record(WidgetKeySchema, WidgetContentSchema);
+//#endregion
+export { DocumentContentSchema };
+
+//# sourceMappingURL=document.js.map

package/dist/content/document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.js","names":[],"sources":["../../src/content/document.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { WidgetKeySchema } from \"../common/widgetKey\"\nimport { WidgetContentSchema } from \"./widget\"\n\nexport const DocumentContentSchema = z.record(WidgetKeySchema, WidgetContentSchema)\n\nexport type DocumentContent = z.infer<typeof DocumentContentSchema>\n"],"mappings":";;;;AAKA,MAAa,wBAAwB,EAAE,OAAO,iBAAiB,oBAAoB"}

package/dist/content/embed.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod/mini";
+
+//#region src/content/embed.d.ts
+declare const EmbedContentSchema: 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>;
+type EmbedContent = z.infer<typeof EmbedContentSchema>;
+//#endregion
+export { EmbedContent };
+//# sourceMappingURL=embed.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"embed.d.ts","names":[],"sources":["../../src/content/embed.ts"],"mappings":";;;cAMa,kBAAA,EAAkB,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;KAKnB,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA"}

package/dist/content/embed.js

@@ -0,0 +1,12 @@
+import { EmbedLegacySchema } from "./legacy/embed.js";
+import { z } from "zod/mini";
+//#region src/content/embed.ts
+const EmbedContentType = "EmbedContent";
+const EmbedContentSchema = z.extend(EmbedLegacySchema, {
+	__TYPE__: z.literal(EmbedContentType),
+	all: z.unknown()
+});
+//#endregion
+export { EmbedContentSchema, EmbedContentType };
+
+//# sourceMappingURL=embed.js.map

package/dist/content/embed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embed.js","names":[],"sources":["../../src/content/embed.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { EmbedLegacySchema } from \"./legacy/embed\"\n\nexport const EmbedContentType = \"EmbedContent\" as const\n\nexport const EmbedContentSchema = z.extend(EmbedLegacySchema, {\n\t__TYPE__: z.literal(EmbedContentType),\n\tall: z.unknown(),\n})\n\nexport type EmbedContent = z.infer<typeof EmbedContentSchema>\n"],"mappings":";;;AAIA,MAAa,mBAAmB;AAEhC,MAAa,qBAAqB,EAAE,OAAO,mBAAmB;CAC7D,UAAU,EAAE,QAAQ,iBAAiB;CACrC,KAAK,EAAE,SAAS;CAChB,CAAC"}

package/dist/content/empty.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"empty.d.ts","names":[],"sources":["../../src/content/empty.ts"],"mappings":";;;cAIa,kBAAA,EAAkB,CAAA,CAAA,aAAA;;;;KAKnB,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA"}

package/dist/content/empty.js

@@ -0,0 +1,11 @@
+import { z } from "zod/mini";
+//#region src/content/empty.ts
+const EmptyContentType = "EmptyContent";
+const EmptyContentSchema = z.object({
+	type: z.string(),
+	__TYPE__: z.literal(EmptyContentType)
+});
+//#endregion
+export { EmptyContentSchema, EmptyContentType };
+
+//# sourceMappingURL=empty.js.map

package/dist/content/empty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty.js","names":[],"sources":["../../src/content/empty.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nexport const EmptyContentType = \"EmptyContent\" as const\n\nexport const EmptyContentSchema = z.object({\n\ttype: z.string(),\n\t__TYPE__: z.literal(EmptyContentType),\n})\n\nexport type EmptyContent = z.infer<typeof EmptyContentSchema>\n"],"mappings":";;AAEA,MAAa,mBAAmB;AAEhC,MAAa,qBAAqB,EAAE,OAAO;CAC1C,MAAM,EAAE,QAAQ;CAChB,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC"}

package/dist/content/field.d.ts

@@ -0,0 +1,78 @@
+import { z } from "zod/mini";
+
+//#region src/content/field.d.ts
+declare const TextContentSchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Text">;
+  value: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
+}, z.core.$strip>;
+declare const ColorContentSchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Color">;
+  value: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
+}, z.core.$strip>;
+declare const DateContentSchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Date">;
+  value: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
+}, z.core.$strip>;
+declare const TimestampContentSchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Timestamp">;
+  value: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
+}, z.core.$strip>;
+declare const NumberContentSchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Number">;
+  value: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
+}, z.core.$strip>;
+declare const RangeContentSchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Range">;
+  value: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
+}, z.core.$strip>;
+declare const SelectContentSchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Select">;
+  value: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
+}, z.core.$strip>;
+declare const FieldContentSchema: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Text">;
+  value: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
+}, z.core.$strip>, z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Color">;
+  value: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
+}, z.core.$strip>, z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Date">;
+  value: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
+}, z.core.$strip>, z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Timestamp">;
+  value: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
+}, z.core.$strip>, z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Number">;
+  value: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
+}, z.core.$strip>, z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Range">;
+  value: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
+}, z.core.$strip>, z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Select">;
+  value: z.ZodMiniString<string>;
+  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
+}, z.core.$strip>]>;
+type TextContent = z.infer<typeof TextContentSchema>;
+type ColorContent = z.infer<typeof ColorContentSchema>;
+type DateContent = z.infer<typeof DateContentSchema>;
+type TimestampContent = z.infer<typeof TimestampContentSchema>;
+type NumberContent = z.infer<typeof NumberContentSchema>;
+type RangeContent = z.infer<typeof RangeContentSchema>;
+type SelectContent = z.infer<typeof SelectContentSchema>;
+type FieldContent = z.infer<typeof FieldContentSchema>;
+//#endregion
+export { ColorContent, DateContent, FieldContent, NumberContent, RangeContent, SelectContent, TextContent, TimestampContent };
+//# sourceMappingURL=field.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"field.d.ts","names":[],"sources":["../../src/content/field.ts"],"mappings":";;;cAQa,iBAAA,EAAiB,CAAA,CAAA,aAAA;;;;;cAOjB,kBAAA,EAAkB,CAAA,CAAA,aAAA;;;;;cAOlB,iBAAA,EAAiB,CAAA,CAAA,aAAA;;;;;cAOjB,sBAAA,EAAsB,CAAA,CAAA,aAAA;;;;;cAOtB,mBAAA,EAAmB,CAAA,CAAA,aAAA;;;;;cAOnB,kBAAA,EAAkB,CAAA,CAAA,aAAA;;;;;cAOlB,mBAAA,EAAmB,CAAA,CAAA,aAAA;;;;;cAOnB,kBAAA,EAAkB,CAAA,CAAA,YAAA,WAAA,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAUnB,WAAA,GAAc,CAAA,CAAE,KAAA,QAAa,iBAAA;AAAA,KAC7B,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA;AAAA,KAC9B,WAAA,GAAc,CAAA,CAAE,KAAA,QAAa,iBAAA;AAAA,KAC7B,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,sBAAA;AAAA,KAClC,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,KAC/B,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA;AAAA,KAC9B,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,KAC/B,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA"}

package/dist/content/field.js

@@ -0,0 +1,52 @@
+import { z } from "zod/mini";
+//#region src/content/field.ts
+const FieldContentType = "FieldContent";
+const SelectFieldType = "Select";
+const TextContentSchema = z.object({
+	type: z.literal("Text"),
+	value: z.string().check(z.trim()),
+	__TYPE__: z.literal(FieldContentType)
+});
+const ColorContentSchema = z.object({
+	type: z.literal("Color"),
+	value: z.string().check(z.trim()),
+	__TYPE__: z.literal(FieldContentType)
+});
+const DateContentSchema = z.object({
+	type: z.literal("Date"),
+	value: z.string().check(z.trim()),
+	__TYPE__: z.literal(FieldContentType)
+});
+const TimestampContentSchema = z.object({
+	type: z.literal("Timestamp"),
+	value: z.string().check(z.trim()),
+	__TYPE__: z.literal(FieldContentType)
+});
+const NumberContentSchema = z.object({
+	type: z.literal("Number"),
+	value: z.string().check(z.trim()),
+	__TYPE__: z.literal(FieldContentType)
+});
+const RangeContentSchema = z.object({
+	type: z.literal("Range"),
+	value: z.string().check(z.trim()),
+	__TYPE__: z.literal(FieldContentType)
+});
+const SelectContentSchema = z.object({
+	type: z.literal(SelectFieldType),
+	value: z.string().check(z.trim()),
+	__TYPE__: z.literal(FieldContentType)
+});
+const FieldContentSchema = z.union([
+	TextContentSchema,
+	ColorContentSchema,
+	DateContentSchema,
+	TimestampContentSchema,
+	NumberContentSchema,
+	RangeContentSchema,
+	SelectContentSchema
+]);
+//#endregion
+export { ColorContentSchema, DateContentSchema, FieldContentSchema, FieldContentType, NumberContentSchema, RangeContentSchema, SelectContentSchema, TextContentSchema, TimestampContentSchema };
+
+//# sourceMappingURL=field.js.map

package/dist/content/field.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.js","names":[],"sources":["../../src/content/field.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport type { SelectModel } from \"../model/select\"\n\nexport const FieldContentType = \"FieldContent\" as const\nexport const SelectFieldType = \"Select\" as const\n\n// Text\nexport const TextContentSchema = z.object({\n\ttype: z.literal(\"Text\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Color\nexport const ColorContentSchema = z.object({\n\ttype: z.literal(\"Color\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Date\nexport const DateContentSchema = z.object({\n\ttype: z.literal(\"Date\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Timestamp\nexport const TimestampContentSchema = z.object({\n\ttype: z.literal(\"Timestamp\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Number\nexport const NumberContentSchema = z.object({\n\ttype: z.literal(\"Number\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Range\nexport const RangeContentSchema = z.object({\n\ttype: z.literal(\"Range\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Select\nexport const SelectContentSchema = z.object({\n\ttype: z.literal(SelectFieldType),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Fields\nexport const FieldContentSchema = z.union([\n\tTextContentSchema,\n\tColorContentSchema,\n\tDateContentSchema,\n\tTimestampContentSchema,\n\tNumberContentSchema,\n\tRangeContentSchema,\n\tSelectContentSchema,\n])\n\nexport type TextContent = z.infer<typeof TextContentSchema>\nexport type ColorContent = z.infer<typeof ColorContentSchema>\nexport type DateContent = z.infer<typeof DateContentSchema>\nexport type TimestampContent = z.infer<typeof TimestampContentSchema>\nexport type NumberContent = z.infer<typeof NumberContentSchema>\nexport type RangeContent = z.infer<typeof RangeContentSchema>\nexport type SelectContent = z.infer<typeof SelectContentSchema>\nexport type FieldContent = z.infer<typeof FieldContentSchema>\n\n/**\n * Returns the default value for a Select field based on its configuration.\n */\nexport const SelectContentDefaultValue = (field: SelectModel): SelectContent | undefined =>\n\tfield.config?.default_value\n\t\t? {\n\t\t\t\t__TYPE__: FieldContentType,\n\t\t\t\ttype: SelectFieldType,\n\t\t\t\tvalue: field.config.default_value || \"\",\n\t\t\t}\n\t\t: undefined\n"],"mappings":";;AAIA,MAAa,mBAAmB;AAChC,MAAa,kBAAkB;AAG/B,MAAa,oBAAoB,EAAE,OAAO;CACzC,MAAM,EAAE,QAAQ,OAAO;CACvB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,qBAAqB,EAAE,OAAO;CAC1C,MAAM,EAAE,QAAQ,QAAQ;CACxB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,oBAAoB,EAAE,OAAO;CACzC,MAAM,EAAE,QAAQ,OAAO;CACvB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,yBAAyB,EAAE,OAAO;CAC9C,MAAM,EAAE,QAAQ,YAAY;CAC5B,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,sBAAsB,EAAE,OAAO;CAC3C,MAAM,EAAE,QAAQ,SAAS;CACzB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,qBAAqB,EAAE,OAAO;CAC1C,MAAM,EAAE,QAAQ,QAAQ;CACxB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,sBAAsB,EAAE,OAAO;CAC3C,MAAM,EAAE,QAAQ,gBAAgB;CAChC,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,qBAAqB,EAAE,MAAM;CACzC;CACA;CACA;CACA;CACA;CACA;CACA;CACA,CAAC"}

package/dist/content/geopoint.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod/mini";
+
+//#region src/content/geopoint.d.ts
+declare const GeoPointContentSchema: z.ZodMiniObject<{
+  position: z.ZodMiniObject<{
+    lat: z.ZodMiniNumber<number>;
+    lng: z.ZodMiniNumber<number>;
+  }, z.core.$strip>;
+  __TYPE__: z.ZodMiniLiteral<"GeoPointContent">;
+}, z.core.$strip>;
+type GeoPointContent = z.infer<typeof GeoPointContentSchema>;
+//#endregion
+export { GeoPointContent };
+//# sourceMappingURL=geopoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geopoint.d.ts","names":[],"sources":["../../src/content/geopoint.ts"],"mappings":";;;cAMa,qBAAA,EAAqB,CAAA,CAAA,aAAA;;;;;;;KAItB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA"}

package/dist/content/geopoint.js

@@ -0,0 +1,9 @@
+import { GeoPointLegacySchema } from "./legacy/geopoint.js";
+import { z } from "zod/mini";
+//#region src/content/geopoint.ts
+const GeoPointContentType = "GeoPointContent";
+const GeoPointContentSchema = z.extend(GeoPointLegacySchema, { __TYPE__: z.literal(GeoPointContentType) });
+//#endregion
+export { GeoPointContentSchema, GeoPointContentType };
+
+//# sourceMappingURL=geopoint.js.map

package/dist/content/geopoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geopoint.js","names":[],"sources":["../../src/content/geopoint.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { GeoPointLegacySchema } from \"./legacy/geopoint\"\n\nexport const GeoPointContentType = \"GeoPointContent\" as const\n\nexport const GeoPointContentSchema = z.extend(GeoPointLegacySchema, {\n\t__TYPE__: z.literal(GeoPointContentType),\n})\n\nexport type GeoPointContent = z.infer<typeof GeoPointContentSchema>\n"],"mappings":";;;AAIA,MAAa,sBAAsB;AAEnC,MAAa,wBAAwB,EAAE,OAAO,sBAAsB,EACnE,UAAU,EAAE,QAAQ,oBAAoB,EACxC,CAAC"}

package/dist/content/group.d.ts

@@ -0,0 +1,18 @@
+import { NestableContent } from "./nestable.js";
+import { z } from "zod/mini";
+
+//#region src/content/group.d.ts
+declare const GroupItemContentType: "GroupItemContent";
+type GroupItemContent = {
+  __TYPE__: typeof GroupItemContentType;
+  key: string;
+  value: [string, NestableContent | GroupContent][];
+};
+declare const GroupContentSchema: z.ZodMiniObject<{
+  __TYPE__: z.ZodMiniLiteral<"GroupContentType">;
+  value: z.ZodMiniArray<z.ZodMiniType<GroupItemContent, unknown, z.core.$ZodTypeInternals<GroupItemContent, unknown>>>;
+}, z.core.$strip>;
+type GroupContent = z.infer<typeof GroupContentSchema>;
+//#endregion
+export { GroupContent, GroupItemContent };
+//# sourceMappingURL=group.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"group.d.ts","names":[],"sources":["../../src/content/group.ts"],"mappings":";;;;cAOa,oBAAA;AAAA,KAkBD,gBAAA;EACX,QAAA,SAAiB,oBAAA;EACjB,GAAA;EACA,KAAA,WAAgB,eAAA,GAAkB,YAAA;AAAA;AAAA,cAMtB,kBAAA,EAAkB,CAAA,CAAA,aAAA;;;;KAKnB,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA"}

package/dist/content/group.js

@@ -0,0 +1,19 @@
+import { NestableContentSchema } from "./nestable.js";
+import { z } from "zod/mini";
+//#region src/content/group.ts
+const GroupItemContentType = "GroupItemContent";
+const GroupItemContentSchema = z.object({
+	__TYPE__: z.literal(GroupItemContentType),
+	key: z.string(),
+	value: z.array(z.tuple([z.string(), z.union([NestableContentSchema, z.lazy(() => GroupContentSchema)])]))
+});
+const GroupContentType = "GroupContentType";
+const GroupContentSchema = z.object({
+	__TYPE__: z.literal(GroupContentType),
+	value: z.array(GroupItemContentSchema)
+});
+const NestableAndGroupContentSchema = z.union([NestableContentSchema, GroupContentSchema]);
+//#endregion
+export { GroupContentSchema, GroupContentType, GroupItemContentSchema, GroupItemContentType, NestableAndGroupContentSchema };
+
+//# sourceMappingURL=group.js.map

package/dist/content/group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.js","names":[],"sources":["../../src/content/group.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport type { GroupModel } from \"../model/group\"\nimport { NestableContentDefaultValue, NestableContentSchema } from \"./nestable\"\nimport type { NestableContent } from \"./nestable\"\n\n// Item\nexport const GroupItemContentType = \"GroupItemContent\" as const\n\nexport const GroupItemContentSchema: z.ZodMiniType<GroupItemContent> = z.object({\n\t__TYPE__: z.literal(GroupItemContentType),\n\tkey: z.string(),\n\tvalue: z.array(\n\t\tz.tuple([\n\t\t\tz.string(),\n\t\t\tz.union([\n\t\t\t\tNestableContentSchema,\n\t\t\t\t// `lazy` is used to handle circular dependency on GroupContentSchema\n\t\t\t\tz.lazy(() => GroupContentSchema),\n\t\t\t]),\n\t\t]),\n\t),\n})\n\n// Manual type definition to handle circular dependency on GroupItemContentSchema\nexport type GroupItemContent = {\n\t__TYPE__: typeof GroupItemContentType\n\tkey: string\n\tvalue: [string, NestableContent | GroupContent][]\n}\n\n// Group\nexport const GroupContentType = \"GroupContentType\" as const\n\nexport const GroupContentSchema = z.object({\n\t__TYPE__: z.literal(GroupContentType),\n\tvalue: z.array(GroupItemContentSchema),\n})\n\nexport type GroupContent = z.infer<typeof GroupContentSchema>\n\nexport const NestableAndGroupContentSchema = z.union([NestableContentSchema, GroupContentSchema])\n\nexport type NestableAndGroupContent = z.infer<typeof NestableAndGroupContentSchema>\n\n// Default values for GroupContent\nexport function groupContentWithDefaultValues(\n\tcustomType: GroupModel,\n\tcontent: GroupContent,\n): GroupContent {\n\tconst fields = customType.config?.fields\n\tif (!fields) return content\n\n\treturn {\n\t\t...content,\n\t\tvalue: content.value.map((groupItem) => {\n\t\t\tconst updatedValue = Object.entries(fields).reduce<GroupItemContent[\"value\"]>(\n\t\t\t\t(acc, [fieldKey, fieldDef]) => {\n\t\t\t\t\tconst existingField = groupItem.value.find(([key]) => key === fieldKey)\n\n\t\t\t\t\tif (existingField) {\n\t\t\t\t\t\treturn [...acc, existingField]\n\t\t\t\t\t}\n\n\t\t\t\t\t// Field is missing, check if we can add a default value\n\t\t\t\t\tif (fieldDef.type === \"Group\") {\n\t\t\t\t\t\t// Recursively apply defaults to nested groups\n\t\t\t\t\t\treturn [\n\t\t\t\t\t\t\t...acc,\n\t\t\t\t\t\t\t[\n\t\t\t\t\t\t\t\tfieldKey,\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t__TYPE__: GroupContentType,\n\t\t\t\t\t\t\t\t\tvalue: [],\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t],\n\t\t\t\t\t\t]\n\t\t\t\t\t}\n\n\t\t\t\t\tconst defaultValue = NestableContentDefaultValue(fieldDef)\n\t\t\t\t\tif (defaultValue) {\n\t\t\t\t\t\treturn [...acc, [fieldKey, defaultValue]]\n\t\t\t\t\t}\n\n\t\t\t\t\treturn acc\n\t\t\t\t},\n\t\t\t\t[],\n\t\t\t)\n\n\t\t\treturn {\n\t\t\t\t...groupItem,\n\t\t\t\tvalue: updatedValue,\n\t\t\t}\n\t\t}),\n\t}\n}\n"],"mappings":";;;AAOA,MAAa,uBAAuB;AAEpC,MAAa,yBAA0D,EAAE,OAAO;CAC/E,UAAU,EAAE,QAAQ,qBAAqB;CACzC,KAAK,EAAE,QAAQ;CACf,OAAO,EAAE,MACR,EAAE,MAAM,CACP,EAAE,QAAQ,EACV,EAAE,MAAM,CACP,uBAEA,EAAE,WAAW,mBAAmB,CAChC,CAAC,CACF,CAAC,CACF;CACD,CAAC;AAUF,MAAa,mBAAmB;AAEhC,MAAa,qBAAqB,EAAE,OAAO;CAC1C,UAAU,EAAE,QAAQ,iBAAiB;CACrC,OAAO,EAAE,MAAM,uBAAuB;CACtC,CAAC;AAIF,MAAa,gCAAgC,EAAE,MAAM,CAAC,uBAAuB,mBAAmB,CAAC"}

package/dist/content/image.d.ts

@@ -0,0 +1,52 @@
+import { z } from "zod/mini";
+
+//#region src/content/image.d.ts
+declare const ImageContentSchema: 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>>>;
+  thumbnails: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, 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>>>;
+  }, z.core.$strip>>>;
+  __TYPE__: z.ZodMiniLiteral<"ImageContent">;
+}, z.core.$strip>;
+type ImageContent = z.infer<typeof ImageContentSchema>;
+//#endregion
+export { ImageContent };
+//# sourceMappingURL=image.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","names":[],"sources":["../../src/content/image.ts"],"mappings":";;;cAUa,kBAAA,EAAkB,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAInB,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA"}

package/dist/content/image.js

@@ -0,0 +1,10 @@
+import { ImageLegacySchema, ImageViewLegacySchema } from "./legacy/image.js";
+import { z } from "zod/mini";
+//#region src/content/image.ts
+const ImageContentType = "ImageContent";
+const ImageViewContentSchema = ImageViewLegacySchema;
+const ImageContentSchema = z.extend(ImageLegacySchema, { __TYPE__: z.literal(ImageContentType) });
+//#endregion
+export { ImageContentSchema, ImageContentType, ImageViewContentSchema };
+
+//# sourceMappingURL=image.js.map

package/dist/content/image.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.js","names":[],"sources":["../../src/content/image.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { ImageViewLegacySchema, ImageLegacySchema } from \"./legacy/image\"\n\nexport const ImageContentType = \"ImageContent\" as const\n\nexport const ImageViewContentSchema = ImageViewLegacySchema\n\ntype ImageViewContent = z.infer<typeof ImageViewLegacySchema>\n\nexport const ImageContentSchema = z.extend(ImageLegacySchema, {\n\t__TYPE__: z.literal(ImageContentType),\n})\n\nexport type ImageContent = z.infer<typeof ImageContentSchema>\n\n// Helpers\n\nexport interface CroppedImage {\n\tzoom: number\n\t/** X coordinate of the crop rect on the original image */\n\tx: number\n\t/** Y coordinate of the crop rect on the original image */\n\ty: number\n\n\t/** The width of the crop rect over the original image */\n\tcropWidth: number\n\t/** The height of the crop rect over the original image */\n\tcropHeight: number\n\n\t/** Final (user defined via W input) width of the image */\n\twidth: number\n\t/** Final (user defined via H input) height of the image */\n\theight: number\n}\n\ninterface BuildCropUrlArgs {\n\torigin: ImageContent[\"origin\"]\n\t/** Image crop parameters */\n\tcroppedImage: CroppedImage\n}\n\nexport function buildCropUrl(args: BuildCropUrlArgs): string {\n\tconst { origin, croppedImage } = args\n\tconst { x, y, width, height, cropHeight, cropWidth } = croppedImage\n\n\tconst url = new URL(origin.url)\n\n\tconst hasResize = origin.height !== height || origin.width !== width\n\n\tconst hasCrop = x !== 0 || y !== 0 || cropHeight !== origin.height || cropWidth !== origin.width\n\n\tif (hasCrop) {\n\t\tconst crop = [x, y, cropWidth, cropHeight].map(Math.round).join(\",\")\n\n\t\turl.searchParams.set(\"rect\", crop)\n\t\turl.searchParams.set(\"w\", width.toString())\n\t\turl.searchParams.set(\"h\", height.toString())\n\t}\n\n\tif (hasResize) {\n\t\turl.searchParams.set(\"w\", width.toString())\n\t\turl.searchParams.set(\"h\", height.toString())\n\t}\n\n\treturn url.toString()\n}\n\nexport function getCroppedImage({ contentView }: { contentView: ImageViewContent }): CroppedImage {\n\tconst {\n\t\tedit: {\n\t\t\tcrop: { x, y },\n\t\t\tzoom,\n\t\t},\n\t\twidth,\n\t\theight,\n\t\torigin: { width: originWidth, height: originHeight },\n\t} = contentView\n\n\tlet cropWidth\n\tlet cropHeight\n\tconst originAspect = originWidth / originHeight\n\tconst cropAspect = width / height\n\tif (cropAspect >= originAspect) {\n\t\t// crop and origin image would be the same width if zoom was equal to 1\n\t\tcropWidth = originWidth / zoom\n\t\tcropHeight = cropWidth / cropAspect\n\t} else {\n\t\t// crop and origin image would be the same height if zoom was equal to 1\n\t\tcropHeight = originHeight / zoom\n\t\tcropWidth = cropHeight * cropAspect\n\t}\n\n\treturn {\n\t\tx,\n\t\ty,\n\t\twidth,\n\t\theight,\n\t\tzoom,\n\t\tcropWidth,\n\t\tcropHeight,\n\t}\n}\n"],"mappings":";;;AAIA,MAAa,mBAAmB;AAEhC,MAAa,yBAAyB;AAItC,MAAa,qBAAqB,EAAE,OAAO,mBAAmB,EAC7D,UAAU,EAAE,QAAQ,iBAAiB,EACrC,CAAC"}

package/dist/content/integrationField.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod/mini";
+
+//#region src/content/integrationField.d.ts
+declare const IntegrationFieldContentSchema: z.ZodMiniObject<{
+  __TYPE__: z.ZodMiniLiteral<"IntegrationFieldsContent">;
+  value: z.ZodMiniString<string>;
+}, z.core.$strip>;
+type IntegrationFieldContent = z.infer<typeof IntegrationFieldContentSchema>;
+//#endregion
+export { IntegrationFieldContent };
+//# sourceMappingURL=integrationField.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integrationField.d.ts","names":[],"sources":["../../src/content/integrationField.ts"],"mappings":";;;cAIa,6BAAA,EAA6B,CAAA,CAAA,aAAA;;;;KAK9B,uBAAA,GAA0B,CAAA,CAAE,KAAA,QAAa,6BAAA"}

package/dist/content/integrationField.js

@@ -0,0 +1,11 @@
+import { z } from "zod/mini";
+//#region src/content/integrationField.ts
+const IntegrationFieldContentType = "IntegrationFieldsContent";
+const IntegrationFieldContentSchema = z.object({
+	__TYPE__: z.literal(IntegrationFieldContentType),
+	value: z.string()
+});
+//#endregion
+export { IntegrationFieldContentSchema, IntegrationFieldContentType };
+
+//# sourceMappingURL=integrationField.js.map

package/dist/content/integrationField.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrationField.js","names":[],"sources":["../../src/content/integrationField.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nexport const IntegrationFieldContentType = \"IntegrationFieldsContent\" as const\n\nexport const IntegrationFieldContentSchema = z.object({\n\t__TYPE__: z.literal(IntegrationFieldContentType),\n\tvalue: z.string(),\n})\n\nexport type IntegrationFieldContent = z.infer<typeof IntegrationFieldContentSchema>\n"],"mappings":";;AAEA,MAAa,8BAA8B;AAE3C,MAAa,gCAAgC,EAAE,OAAO;CACrD,UAAU,EAAE,QAAQ,4BAA4B;CAChD,OAAO,EAAE,QAAQ;CACjB,CAAC"}

package/dist/content/legacy/boolean.js

@@ -0,0 +1,7 @@
+import { z } from "zod/mini";
+//#region src/content/legacy/boolean.ts
+const BooleanLegacySchema = z.boolean();
+//#endregion
+export { BooleanLegacySchema };
+
+//# sourceMappingURL=boolean.js.map

package/dist/content/legacy/boolean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.js","names":[],"sources":["../../../src/content/legacy/boolean.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nexport const BooleanLegacySchema = z.boolean()\n\nexport type BooleanLegacy = z.infer<typeof BooleanLegacySchema>\n"],"mappings":";;AAEA,MAAa,sBAAsB,EAAE,SAAS"}

package/dist/content/legacy/document.js

@@ -0,0 +1,15 @@
+import { WidgetKeySchema } from "../../common/widgetKey.js";
+import { z } from "zod/mini";
+//#region src/content/legacy/document.ts
+const DocumentLegacySchema = z.pipe(z.record(z.string(), z.unknown()), z.transform((value) => {
+	const documentLegacy = {};
+	for (const [widgetKey, widgetValue] of Object.entries(value)) {
+		const result = WidgetKeySchema.safeParse(widgetKey);
+		if (result.success) documentLegacy[result.data] = widgetValue;
+	}
+	return documentLegacy;
+}));
+//#endregion
+export { DocumentLegacySchema };
+
+//# sourceMappingURL=document.js.map

package/dist/content/legacy/document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.js","names":[],"sources":["../../../src/content/legacy/document.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { WidgetKeySchema } from \"../../common/widgetKey\"\nimport type { WidgetKey } from \"../../common/widgetKey\"\n\nexport const DocumentLegacySchema = z.pipe(\n\tz.record(z.string(), z.unknown()),\n\tz.transform((value) => {\n\t\tconst documentLegacy: Record<WidgetKey, unknown> = {}\n\n\t\tfor (const [widgetKey, widgetValue] of Object.entries(value)) {\n\t\t\t// Keep v3 behavior: invalid widget keys are dropped, but the document\n\t\t\t// decode still succeeds. Widget value validation happens later in\n\t\t\t// DocumentLegacyCodec via WidgetLegacyCodec.\n\t\t\tconst result = WidgetKeySchema.safeParse(widgetKey)\n\t\t\tif (result.success) {\n\t\t\t\tdocumentLegacy[result.data] = widgetValue\n\t\t\t}\n\t\t}\n\n\t\treturn documentLegacy\n\t}),\n)\n\nexport type DocumentLegacy = z.infer<typeof DocumentLegacySchema>\n"],"mappings":";;;AAKA,MAAa,uBAAuB,EAAE,KACrC,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,EACjC,EAAE,WAAW,UAAU;CACtB,MAAM,iBAA6C,EAAE;AAErD,MAAK,MAAM,CAAC,WAAW,gBAAgB,OAAO,QAAQ,MAAM,EAAE;EAI7D,MAAM,SAAS,gBAAgB,UAAU,UAAU;AACnD,MAAI,OAAO,QACV,gBAAe,OAAO,QAAQ;;AAIhC,QAAO;EACN,CACF"}

package/dist/content/legacy/embed.js

@@ -0,0 +1,23 @@
+import { z } from "zod/mini";
+//#region src/content/legacy/embed.ts
+const EmbedShape = {
+	embed_url: z.string(),
+	type: z.string(),
+	version: z.nullish(z.union([z.string(), z.number()])),
+	title: z.nullish(z.string()),
+	author_name: z.nullish(z.string()),
+	author_url: z.nullish(z.string()),
+	provider_name: z.nullish(z.string()),
+	provider_url: z.nullish(z.string()),
+	cache_age: z.nullish(z.union([z.string(), z.number()])),
+	thumbnail_url: z.nullish(z.string()),
+	thumbnail_width: z.nullish(z.number()),
+	thumbnail_height: z.nullish(z.number()),
+	html: z.nullish(z.string())
+};
+const EmbedLegacySchema = z.object(EmbedShape);
+const EmbedLegacyLooseSchema = z.looseObject(EmbedShape);
+//#endregion
+export { EmbedLegacyLooseSchema, EmbedLegacySchema };
+
+//# sourceMappingURL=embed.js.map

package/dist/content/legacy/embed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embed.js","names":[],"sources":["../../../src/content/legacy/embed.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nconst EmbedShape = {\n\tembed_url: z.string(),\n\ttype: z.string(),\n\tversion: z.nullish(z.union([z.string(), z.number()])),\n\ttitle: z.nullish(z.string()),\n\tauthor_name: z.nullish(z.string()),\n\tauthor_url: z.nullish(z.string()),\n\tprovider_name: z.nullish(z.string()),\n\tprovider_url: z.nullish(z.string()),\n\tcache_age: z.nullish(z.union([z.string(), z.number()])),\n\tthumbnail_url: z.nullish(z.string()),\n\tthumbnail_width: z.nullish(z.number()),\n\tthumbnail_height: z.nullish(z.number()),\n\thtml: z.nullish(z.string()),\n}\n\nexport const EmbedLegacySchema = z.object(EmbedShape)\n\nexport const EmbedLegacyLooseSchema = z.looseObject(EmbedShape)\n\nexport type EmbedLegacy = z.infer<typeof EmbedLegacySchema>\n"],"mappings":";;AAEA,MAAM,aAAa;CAClB,WAAW,EAAE,QAAQ;CACrB,MAAM,EAAE,QAAQ;CAChB,SAAS,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC;CACrD,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC5B,aAAa,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAClC,YAAY,EAAE,QAAQ,EAAE,QAAQ,CAAC;CACjC,eAAe,EAAE,QAAQ,EAAE,QAAQ,CAAC;CACpC,cAAc,EAAE,QAAQ,EAAE,QAAQ,CAAC;CACnC,WAAW,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC;CACvD,eAAe,EAAE,QAAQ,EAAE,QAAQ,CAAC;CACpC,iBAAiB,EAAE,QAAQ,EAAE,QAAQ,CAAC;CACtC,kBAAkB,EAAE,QAAQ,EAAE,QAAQ,CAAC;CACvC,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC3B;AAED,MAAa,oBAAoB,EAAE,OAAO,WAAW;AAErD,MAAa,yBAAyB,EAAE,YAAY,WAAW"}

package/dist/content/legacy/empty.js

@@ -0,0 +1,7 @@
+import { z } from "zod/mini";
+//#region src/content/legacy/empty.ts
+const EmptyLegacySchema = z.union([z.null(), z.object({ value: z.null() })]);
+//#endregion
+export { EmptyLegacySchema };
+
+//# sourceMappingURL=empty.js.map

package/dist/content/legacy/empty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty.js","names":[],"sources":["../../../src/content/legacy/empty.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nexport const EmptyLegacySchema = z.union([\n\tz.null(),\n\tz.object({\n\t\tvalue: z.null(),\n\t}),\n])\n\nexport type EmptyLegacy = z.infer<typeof EmptyLegacySchema>\n"],"mappings":";;AAEA,MAAa,oBAAoB,EAAE,MAAM,CACxC,EAAE,MAAM,EACR,EAAE,OAAO,EACR,OAAO,EAAE,MAAM,EACf,CAAC,CACF,CAAC"}

package/dist/content/legacy/field.js

@@ -0,0 +1,7 @@
+import { z } from "zod/mini";
+//#region src/content/legacy/field.ts
+const StringLegacySchema = z.pipe(z.string(), z.transform((s) => s.trim()));
+//#endregion
+export { StringLegacySchema };
+
+//# sourceMappingURL=field.js.map

package/dist/content/legacy/field.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.js","names":[],"sources":["../../../src/content/legacy/field.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nexport const StringLegacySchema = z.pipe(\n\tz.string(),\n\tz.transform((s: string) => s.trim()),\n)\n\nexport type StringLegacy = z.infer<typeof StringLegacySchema>\n"],"mappings":";;AAEA,MAAa,qBAAqB,EAAE,KACnC,EAAE,QAAQ,EACV,EAAE,WAAW,MAAc,EAAE,MAAM,CAAC,CACpC"}

package/dist/content/legacy/geopoint.js

@@ -0,0 +1,10 @@
+import { z } from "zod/mini";
+//#region src/content/legacy/geopoint.ts
+const GeoPointLegacySchema = z.object({ position: z.object({
+	lat: z.number(),
+	lng: z.number()
+}) });
+//#endregion
+export { GeoPointLegacySchema };
+
+//# sourceMappingURL=geopoint.js.map

package/dist/content/legacy/geopoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geopoint.js","names":[],"sources":["../../../src/content/legacy/geopoint.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nexport const GeoPointLegacySchema = z.object({\n\tposition: z.object({\n\t\tlat: z.number(),\n\t\tlng: z.number(),\n\t}),\n})\n\nexport type GeoPointLegacy = z.infer<typeof GeoPointLegacySchema>\n"],"mappings":";;AAEA,MAAa,uBAAuB,EAAE,OAAO,EAC5C,UAAU,EAAE,OAAO;CAClB,KAAK,EAAE,QAAQ;CACf,KAAK,EAAE,QAAQ;CACf,CAAC,EACF,CAAC"}

package/dist/content/legacy/group.js

@@ -0,0 +1,10 @@
+import { NestableLegacySchema } from "./nestable.js";
+import { z } from "zod/mini";
+//#region src/content/legacy/group.ts
+const GroupItemLegacySchema = z.record(z.string(), z.unknown());
+const GroupLegacySchema = z.array(z.union([GroupItemLegacySchema, z.null()]));
+const NestableAndGroupLegacySchema = z.union([NestableLegacySchema, GroupLegacySchema]);
+//#endregion
+export { GroupItemLegacySchema, GroupLegacySchema, NestableAndGroupLegacySchema };
+
+//# sourceMappingURL=group.js.map

package/dist/content/legacy/group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.js","names":[],"sources":["../../../src/content/legacy/group.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { NestableLegacySchema } from \"./nestable\"\n\nexport const GroupItemLegacySchema = z.record(z.string(), z.unknown())\n\nexport type GroupItemLegacy = z.infer<typeof GroupItemLegacySchema>\n\nexport const GroupLegacySchema = z.array(z.union([GroupItemLegacySchema, z.null()]))\n\nexport type GroupLegacy = z.infer<typeof GroupLegacySchema>\n\nexport const NestableAndGroupLegacySchema = z.union([NestableLegacySchema, GroupLegacySchema])\n\nexport type NestableAndGroupLegacy = z.infer<typeof NestableAndGroupLegacySchema>\n"],"mappings":";;;AAIA,MAAa,wBAAwB,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC;AAItE,MAAa,oBAAoB,EAAE,MAAM,EAAE,MAAM,CAAC,uBAAuB,EAAE,MAAM,CAAC,CAAC,CAAC;AAIpF,MAAa,+BAA+B,EAAE,MAAM,CAAC,sBAAsB,kBAAkB,CAAC"}

package/dist/content/legacy/image.d.ts

@@ -0,0 +1 @@
+import { z } from "zod/mini";

package/dist/content/legacy/image.js

@@ -0,0 +1,33 @@
+import { z } from "zod/mini";
+//#region src/content/legacy/image.ts
+const OriginSchema = z.object({
+	id: z.string(),
+	url: z.string(),
+	width: z.number(),
+	height: z.number()
+});
+const CropSchema = z.object({
+	x: z.number(),
+	y: z.number()
+});
+const EditSchema = z.object({
+	zoom: z.number(),
+	crop: CropSchema,
+	background: z.string()
+});
+const NonEmptyStringOrNullSchema = z.pipe(z.nullish(z.string()), z.transform((value) => typeof value === "string" && value.length > 0 ? value : null));
+const ImageViewLegacySchema = z.object({
+	origin: OriginSchema,
+	width: z.number(),
+	height: z.number(),
+	edit: EditSchema,
+	url: z.optional(z.string()),
+	credits: z.optional(NonEmptyStringOrNullSchema),
+	alt: z.optional(NonEmptyStringOrNullSchema),
+	provider: z.nullish(z.string())
+});
+const ImageLegacySchema = z.extend(ImageViewLegacySchema, { thumbnails: z.optional(z.record(z.string(), ImageViewLegacySchema)) });
+//#endregion
+export { ImageLegacySchema, ImageViewLegacySchema };
+
+//# sourceMappingURL=image.js.map

package/dist/content/legacy/image.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.js","names":[],"sources":["../../../src/content/legacy/image.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nconst OriginSchema = z.object({\n\tid: z.string(),\n\turl: z.string(),\n\twidth: z.number(),\n\theight: z.number(),\n})\n\nconst CropSchema = z.object({\n\tx: z.number(),\n\ty: z.number(),\n})\n\nconst EditSchema = z.object({\n\tzoom: z.number(),\n\tcrop: CropSchema,\n\tbackground: z.string(),\n})\n\nconst NonEmptyStringOrNullSchema = z.pipe(\n\tz.nullish(z.string()),\n\tz.transform((value) => (typeof value === \"string\" && value.length > 0 ? value : null)),\n)\n\nexport const ImageViewLegacySchema = z.object({\n\torigin: OriginSchema,\n\twidth: z.number(),\n\theight: z.number(),\n\tedit: EditSchema,\n\turl: z.optional(z.string()),\n\tcredits: z.optional(NonEmptyStringOrNullSchema),\n\talt: z.optional(NonEmptyStringOrNullSchema),\n\tprovider: z.nullish(z.string()),\n})\n\nexport type ImageLegacyView = z.infer<typeof ImageViewLegacySchema>\n\nexport const ImageLegacySchema = z.extend(ImageViewLegacySchema, {\n\tthumbnails: z.optional(z.record(z.string(), ImageViewLegacySchema)),\n})\n\nexport type ImageLegacy = z.infer<typeof ImageLegacySchema>\n"],"mappings":";;AAEA,MAAM,eAAe,EAAE,OAAO;CAC7B,IAAI,EAAE,QAAQ;CACd,KAAK,EAAE,QAAQ;CACf,OAAO,EAAE,QAAQ;CACjB,QAAQ,EAAE,QAAQ;CAClB,CAAC;AAEF,MAAM,aAAa,EAAE,OAAO;CAC3B,GAAG,EAAE,QAAQ;CACb,GAAG,EAAE,QAAQ;CACb,CAAC;AAEF,MAAM,aAAa,EAAE,OAAO;CAC3B,MAAM,EAAE,QAAQ;CAChB,MAAM;CACN,YAAY,EAAE,QAAQ;CACtB,CAAC;AAEF,MAAM,6BAA6B,EAAE,KACpC,EAAE,QAAQ,EAAE,QAAQ,CAAC,EACrB,EAAE,WAAW,UAAW,OAAO,UAAU,YAAY,MAAM,SAAS,IAAI,QAAQ,KAAM,CACtF;AAED,MAAa,wBAAwB,EAAE,OAAO;CAC7C,QAAQ;CACR,OAAO,EAAE,QAAQ;CACjB,QAAQ,EAAE,QAAQ;CAClB,MAAM;CACN,KAAK,EAAE,SAAS,EAAE,QAAQ,CAAC;CAC3B,SAAS,EAAE,SAAS,2BAA2B;CAC/C,KAAK,EAAE,SAAS,2BAA2B;CAC3C,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC/B,CAAC;AAIF,MAAa,oBAAoB,EAAE,OAAO,uBAAuB,EAChE,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,sBAAsB,CAAC,EACnE,CAAC"}