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

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

@@ -0,0 +1 @@
+{"version":3,"file":"slice.d.ts","names":[],"sources":["../../src/model/slice.ts"],"mappings":"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"}

package/dist/model/slice.js

@@ -0,0 +1,68 @@
+import { WidgetKeySchema } from "../common/widgetKey.js";
+import { NestableModelSchema } from "./nestable.js";
+import { GroupModelSchema, NestedGroupModelSchema } from "./group.js";
+import { z } from "zod/mini";
+//#region src/model/slice.ts
+const LegacySliceModelSchema = z.union([NestableModelSchema, NestedGroupModelSchema]);
+const CompositeSliceType = "Slice";
+const CompositeSliceConfigSchema = z.object({ label: z.nullish(z.string()) });
+const CompositeSliceModelSchema = z.object({
+	type: z.literal(CompositeSliceType),
+	fieldset: z.nullish(z.string()),
+	description: z.optional(z.string()),
+	icon: z.optional(z.string()),
+	display: z.optional(z.string()),
+	"non-repeat": z.optional(z.record(WidgetKeySchema, NestableModelSchema)),
+	repeat: z.optional(z.record(WidgetKeySchema, NestableModelSchema)),
+	config: z.optional(CompositeSliceConfigSchema)
+});
+const SharedSliceType = "SharedSlice";
+const SharedSliceVariationSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string(),
+	imageUrl: z._default(z.string(), "https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format"),
+	docURL: z.string(),
+	version: z.string(),
+	display: z.optional(z.string()),
+	primary: z.optional(z.record(z.string(), z.union([NestableModelSchema, GroupModelSchema]))),
+	items: z.optional(z.record(z.string(), NestableModelSchema))
+});
+const SharedSliceModelSchema = z.object({
+	id: z.string(),
+	type: z.literal(SharedSliceType),
+	name: z.string(),
+	variations: z.array(SharedSliceVariationSchema),
+	description: z.optional(z.string()),
+	legacyPaths: z.optional(z.record(z.string(), z.string()))
+});
+const SharedSliceRefModelSchema = z.object({ type: z.literal(SharedSliceType) });
+const SharedSliceVariationContentModelSchema = z.object({
+	type: z.literal(SharedSliceType),
+	sliceName: z.string(),
+	variationID: z.string(),
+	fields: z.pick(SharedSliceVariationSchema, {
+		primary: true,
+		items: true
+	})
+});
+const DynamicSliceModelSchema = z.union([
+	CompositeSliceModelSchema,
+	LegacySliceModelSchema,
+	SharedSliceRefModelSchema
+]);
+const StaticSliceModelSchema = z.union([
+	CompositeSliceModelSchema,
+	LegacySliceModelSchema,
+	SharedSliceModelSchema
+]);
+const SliceContentModelSchema = z.union([
+	CompositeSliceModelSchema,
+	LegacySliceModelSchema,
+	SharedSliceVariationContentModelSchema
+]);
+const SliceModelTypeSchema = z.union([z.literal(CompositeSliceType), z.literal(SharedSliceType)]);
+//#endregion
+export { CompositeSliceModelSchema, DynamicSliceModelSchema, LegacySliceModelSchema, SharedSliceModelSchema, SharedSliceRefModelSchema, SliceContentModelSchema, SliceModelTypeSchema, StaticSliceModelSchema };
+
+//# sourceMappingURL=slice.js.map

package/dist/model/slice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slice.js","names":[],"sources":["../../src/model/slice.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { WidgetKeySchema } from \"../common/widgetKey\"\nimport type { NestedGroupModel } from \"./group\"\nimport { GroupModelSchema, NestedGroupModelSchema } from \"./group\"\nimport type { NestableModel } from \"./nestable\"\nimport { NestableModelSchema } from \"./nestable\"\n\n// Simple (before 2020)\nexport const LegacySliceModelSchema: z.ZodMiniType<LegacySliceModel> = z.union([\n\tNestableModelSchema,\n\tNestedGroupModelSchema,\n])\n\nexport type LegacySliceModel = NestableModel | NestedGroupModel\n\n// Composite (2020 to 2021)\nexport const CompositeSliceType = \"Slice\" as const\n\nconst CompositeSliceConfigSchema = z.object({\n\tlabel: z.nullish(z.string()),\n})\n\nexport const CompositeSliceModelSchema = z.object({\n\ttype: z.literal(CompositeSliceType),\n\tfieldset: z.nullish(z.string()),\n\tdescription: z.optional(z.string()),\n\ticon: z.optional(z.string()),\n\tdisplay: z.optional(z.string()),\n\t\"non-repeat\": z.optional(z.record(WidgetKeySchema, NestableModelSchema)),\n\trepeat: z.optional(z.record(WidgetKeySchema, NestableModelSchema)),\n\tconfig: z.optional(CompositeSliceConfigSchema),\n})\n\nexport type CompositeSliceModel = z.infer<typeof CompositeSliceModelSchema>\n\n// Shared (2021 to present)\nexport const SharedSliceType = \"SharedSlice\" as const\n\nconst IMAGE_PLACEHOLDER_URL =\n\t\"https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format\"\n\nexport const SharedSliceVariationSchema = z.object({\n\tid: z.string(),\n\tname: z.string(),\n\tdescription: z.string(),\n\timageUrl: z._default(z.string(), IMAGE_PLACEHOLDER_URL),\n\tdocURL: z.string(),\n\tversion: z.string(),\n\tdisplay: z.optional(z.string()),\n\tprimary: z.optional(\n\t\tz.record(\n\t\t\tz.string(),\n\t\t\tz.union([NestableModelSchema, GroupModelSchema]) as z.ZodMiniType<\n\t\t\t\tNestableModel | NestedGroupModel\n\t\t\t>,\n\t\t),\n\t),\n\titems: z.optional(z.record(z.string(), NestableModelSchema)),\n})\n\nexport type SharedSliceVariation = z.infer<typeof SharedSliceVariationSchema>\n\nexport const SharedSliceModelSchema = z.object({\n\tid: z.string(),\n\ttype: z.literal(SharedSliceType),\n\tname: z.string(),\n\tvariations: z.array(SharedSliceVariationSchema),\n\tdescription: z.optional(z.string()),\n\tlegacyPaths: z.optional(z.record(z.string(), z.string())),\n})\n\nexport type SharedSliceModel = z.infer<typeof SharedSliceModelSchema>\n\nexport const SharedSliceRefModelSchema = z.object({\n\ttype: z.literal(SharedSliceType),\n})\n\nexport type SharedSliceRefModel = z.infer<typeof SharedSliceRefModelSchema>\n\n// Used to represent a shared slice content which can only be\n// of a given shared slice variation type.\nexport const SharedSliceVariationContentModelSchema = z.object({\n\ttype: z.literal(SharedSliceType),\n\tsliceName: z.string(),\n\tvariationID: z.string(),\n\tfields: z.pick(SharedSliceVariationSchema, { primary: true, items: true }),\n})\n\nexport type SharedSliceVariationContentModel = z.infer<\n\ttypeof SharedSliceVariationContentModelSchema\n>\n\n// All\n\n// Used when slices reference SharedSlice by ref (not full definition)\nexport const DynamicSliceModelSchema: z.ZodMiniType<DynamicSliceModel> = z.union([\n\tCompositeSliceModelSchema,\n\tLegacySliceModelSchema,\n\tSharedSliceRefModelSchema,\n])\n\nexport type DynamicSliceModel = CompositeSliceModel | LegacySliceModel | SharedSliceRefModel\n\n// Used when slices include full SharedSlice definition\nexport const StaticSliceModelSchema: z.ZodMiniType<StaticSliceModel> = z.union([\n\tCompositeSliceModelSchema,\n\tLegacySliceModelSchema,\n\tSharedSliceModelSchema,\n])\n\nexport type StaticSliceModel = CompositeSliceModel | LegacySliceModel | SharedSliceModel\n\n// Used to represent a slice content model as shared slice variations\n// can only be of a given shared slice variation type.\nexport const SliceContentModelSchema: z.ZodMiniType<SliceContentModel> = z.union([\n\tCompositeSliceModelSchema,\n\tLegacySliceModelSchema,\n\tSharedSliceVariationContentModelSchema,\n])\n\nexport type SliceContentModel =\n\t| CompositeSliceModel\n\t| LegacySliceModel\n\t| SharedSliceVariationContentModel\n\n// Model types\nexport const SliceModelTypeSchema = z.union([\n\tz.literal(CompositeSliceType),\n\tz.literal(SharedSliceType),\n])\n\nexport type SliceModelType = z.infer<typeof SliceModelTypeSchema>\n"],"mappings":";;;;;AASA,MAAa,yBAA0D,EAAE,MAAM,CAC9E,qBACA,uBACA,CAAC;AAKF,MAAa,qBAAqB;AAElC,MAAM,6BAA6B,EAAE,OAAO,EAC3C,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAC5B,CAAC;AAEF,MAAa,4BAA4B,EAAE,OAAO;CACjD,MAAM,EAAE,QAAQ,mBAAmB;CACnC,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC/B,aAAa,EAAE,SAAS,EAAE,QAAQ,CAAC;CACnC,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC;CAC5B,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC;CAC/B,cAAc,EAAE,SAAS,EAAE,OAAO,iBAAiB,oBAAoB,CAAC;CACxE,QAAQ,EAAE,SAAS,EAAE,OAAO,iBAAiB,oBAAoB,CAAC;CAClE,QAAQ,EAAE,SAAS,2BAA2B;CAC9C,CAAC;AAKF,MAAa,kBAAkB;AAK/B,MAAa,6BAA6B,EAAE,OAAO;CAClD,IAAI,EAAE,QAAQ;CACd,MAAM,EAAE,QAAQ;CAChB,aAAa,EAAE,QAAQ;CACvB,UAAU,EAAE,SAAS,EAAE,QAAQ,EAN/B,mHAMuD;CACvD,QAAQ,EAAE,QAAQ;CAClB,SAAS,EAAE,QAAQ;CACnB,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC;CAC/B,SAAS,EAAE,SACV,EAAE,OACD,EAAE,QAAQ,EACV,EAAE,MAAM,CAAC,qBAAqB,iBAAiB,CAAC,CAGhD,CACD;CACD,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,oBAAoB,CAAC;CAC5D,CAAC;AAIF,MAAa,yBAAyB,EAAE,OAAO;CAC9C,IAAI,EAAE,QAAQ;CACd,MAAM,EAAE,QAAQ,gBAAgB;CAChC,MAAM,EAAE,QAAQ;CAChB,YAAY,EAAE,MAAM,2BAA2B;CAC/C,aAAa,EAAE,SAAS,EAAE,QAAQ,CAAC;CACnC,aAAa,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,QAAQ,CAAC,CAAC;CACzD,CAAC;AAIF,MAAa,4BAA4B,EAAE,OAAO,EACjD,MAAM,EAAE,QAAQ,gBAAgB,EAChC,CAAC;AAMF,MAAa,yCAAyC,EAAE,OAAO;CAC9D,MAAM,EAAE,QAAQ,gBAAgB;CAChC,WAAW,EAAE,QAAQ;CACrB,aAAa,EAAE,QAAQ;CACvB,QAAQ,EAAE,KAAK,4BAA4B;EAAE,SAAS;EAAM,OAAO;EAAM,CAAC;CAC1E,CAAC;AASF,MAAa,0BAA4D,EAAE,MAAM;CAChF;CACA;CACA;CACA,CAAC;AAKF,MAAa,yBAA0D,EAAE,MAAM;CAC9E;CACA;CACA;CACA,CAAC;AAMF,MAAa,0BAA4D,EAAE,MAAM;CAChF;CACA;CACA;CACA,CAAC;AAQF,MAAa,uBAAuB,EAAE,MAAM,CAC3C,EAAE,QAAQ,mBAAmB,EAC7B,EAAE,QAAQ,gBAAgB,CAC1B,CAAC"}

package/dist/model/slices.d.ts

@@ -0,0 +1,33 @@
+import { DynamicSliceModel, StaticSliceModel } from "./slice.js";
+import { z } from "zod/mini";
+
+//#region src/model/slices.d.ts
+declare const StaticSlicesModelSchema: z.ZodMiniObject<{
+  type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Slices">, z.ZodMiniLiteral<"Choice">]>;
+  fieldset: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  config: z.ZodMiniOptional<z.ZodMiniObject<{
+    label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    labels: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniObject<{
+      name: z.ZodMiniString<string>;
+      display: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strip>>>, z.ZodMiniNull]>>;
+    choices: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniType<StaticSliceModel, unknown, z.core.$ZodTypeInternals<StaticSliceModel, unknown>>>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type StaticSlicesModel = z.infer<typeof StaticSlicesModelSchema>;
+declare const DynamicSlicesModelSchema: z.ZodMiniObject<{
+  type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Slices">, z.ZodMiniLiteral<"Choice">]>;
+  fieldset: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  config: z.ZodMiniOptional<z.ZodMiniObject<{
+    label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    labels: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniObject<{
+      name: z.ZodMiniString<string>;
+      display: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strip>>>, z.ZodMiniNull]>>;
+    choices: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniType<DynamicSliceModel, unknown, z.core.$ZodTypeInternals<DynamicSliceModel, unknown>>>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type DynamicSlicesModel = z.infer<typeof DynamicSlicesModelSchema>;
+//#endregion
+export { DynamicSlicesModel, StaticSlicesModel };
+//# sourceMappingURL=slices.d.ts.map

package/dist/model/slices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slices.d.ts","names":[],"sources":["../../src/model/slices.ts"],"mappings":";;;;cA+Ca,uBAAA,EAAuB,CAAA,CAAA,aAAA;;;;;;;;;;;;KAExB,iBAAA,GAAoB,CAAA,CAAE,KAAA,QAAa,uBAAA;AAAA,cAElC,wBAAA,EAAwB,CAAA,CAAA,aAAA;;;;;;;;;;;;KAEzB,kBAAA,GAAqB,CAAA,CAAE,KAAA,QAAa,wBAAA"}

package/dist/model/slices.js

@@ -0,0 +1,29 @@
+import { WidgetKeySchema } from "../common/widgetKey.js";
+import { DynamicSliceModelSchema, StaticSliceModelSchema } from "./slice.js";
+import { z } from "zod/mini";
+//#region src/model/slices.ts
+const LegacySlicesFieldType = "Choice";
+const SlicesFieldType = "Slices";
+const SlicesLabelSchema = z.object({
+	name: z.string(),
+	display: z.optional(z.string())
+});
+const SlicesLabelsSchema = z.union([z.record(z.string(), z.array(SlicesLabelSchema)), z.null()]);
+const getSlicesConfigSchema = (sliceSchema) => z.object({
+	label: z.nullish(z.string()),
+	labels: z.optional(SlicesLabelsSchema),
+	choices: z.optional(z.record(WidgetKeySchema, sliceSchema))
+});
+const StaticSlicesConfigSchema = getSlicesConfigSchema(StaticSliceModelSchema);
+const DynamicSlicesConfigSchema = getSlicesConfigSchema(DynamicSliceModelSchema);
+const getSlicesSchema = (configSchema) => z.object({
+	type: z.union([z.literal(SlicesFieldType), z.literal(LegacySlicesFieldType)]),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(configSchema)
+});
+const StaticSlicesModelSchema = getSlicesSchema(StaticSlicesConfigSchema);
+const DynamicSlicesModelSchema = getSlicesSchema(DynamicSlicesConfigSchema);
+//#endregion
+export { DynamicSlicesModelSchema, StaticSlicesModelSchema };
+
+//# sourceMappingURL=slices.js.map

package/dist/model/slices.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slices.js","names":[],"sources":["../../src/model/slices.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { WidgetKeySchema } from \"../common/widgetKey\"\nimport { StaticSliceModelSchema, DynamicSliceModelSchema } from \"./slice\"\n\nexport const LegacySlicesFieldType = \"Choice\"\nexport const SlicesFieldType = \"Slices\"\n\n// Label configuration for slices\nconst SlicesLabelSchema = z.object({\n\tname: z.string(),\n\tdisplay: z.optional(z.string()),\n})\n\nexport const SlicesLabelsSchema = z.union([\n\tz.record(z.string(), z.array(SlicesLabelSchema)),\n\tz.null(),\n])\n\n// Config\nconst getSlicesConfigSchema = <\n\tTSliceSchema extends typeof StaticSliceModelSchema | typeof DynamicSliceModelSchema,\n>(\n\tsliceSchema: TSliceSchema,\n) =>\n\tz.object({\n\t\tlabel: z.nullish(z.string()),\n\t\tlabels: z.optional(SlicesLabelsSchema),\n\t\tchoices: z.optional(z.record(WidgetKeySchema, sliceSchema)),\n\t})\n\nconst StaticSlicesConfigSchema = getSlicesConfigSchema(StaticSliceModelSchema)\n\nconst DynamicSlicesConfigSchema = getSlicesConfigSchema(DynamicSliceModelSchema)\n\n// Model\nconst getSlicesSchema = <\n\tTConfig extends typeof StaticSlicesConfigSchema | typeof DynamicSlicesConfigSchema,\n>(\n\tconfigSchema: TConfig,\n) =>\n\tz.object({\n\t\ttype: z.union([z.literal(SlicesFieldType), z.literal(LegacySlicesFieldType)]),\n\t\tfieldset: z.nullish(z.string()),\n\t\tconfig: z.optional(configSchema),\n\t})\n\nexport const StaticSlicesModelSchema = getSlicesSchema(StaticSlicesConfigSchema)\n\nexport type StaticSlicesModel = z.infer<typeof StaticSlicesModelSchema>\n\nexport const DynamicSlicesModelSchema = getSlicesSchema(DynamicSlicesConfigSchema)\n\nexport type DynamicSlicesModel = z.infer<typeof DynamicSlicesModelSchema>\n"],"mappings":";;;;AAKA,MAAa,wBAAwB;AACrC,MAAa,kBAAkB;AAG/B,MAAM,oBAAoB,EAAE,OAAO;CAClC,MAAM,EAAE,QAAQ;CAChB,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC;CAC/B,CAAC;AAEF,MAAa,qBAAqB,EAAE,MAAM,CACzC,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,MAAM,kBAAkB,CAAC,EAChD,EAAE,MAAM,CACR,CAAC;AAGF,MAAM,yBAGL,gBAEA,EAAE,OAAO;CACR,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC5B,QAAQ,EAAE,SAAS,mBAAmB;CACtC,SAAS,EAAE,SAAS,EAAE,OAAO,iBAAiB,YAAY,CAAC;CAC3D,CAAC;AAEH,MAAM,2BAA2B,sBAAsB,uBAAuB;AAE9E,MAAM,4BAA4B,sBAAsB,wBAAwB;AAGhF,MAAM,mBAGL,iBAEA,EAAE,OAAO;CACR,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,gBAAgB,EAAE,EAAE,QAAQ,sBAAsB,CAAC,CAAC;CAC7E,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC/B,QAAQ,EAAE,SAAS,aAAa;CAChC,CAAC;AAEH,MAAa,0BAA0B,gBAAgB,yBAAyB;AAIhF,MAAa,2BAA2B,gBAAgB,0BAA0B"}

package/dist/model/table.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod/mini";
+
+//#region src/model/table.d.ts
+declare const TableModelSchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Table">;
+  config: z.ZodMiniOptional<z.ZodMiniObject<{
+    label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type TableModel = z.infer<typeof TableModelSchema>;
+declare const TableCellModelNodeTypes: ("paragraph" | "hyperlink" | "strong" | "em")[];
+//#endregion
+export { TableCellModelNodeTypes, TableModel };
+//# sourceMappingURL=table.d.ts.map

package/dist/model/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","names":[],"sources":["../../src/model/table.ts"],"mappings":";;;cAQa,gBAAA,EAAgB,CAAA,CAAA,aAAA;;;;;;KAKjB,UAAA,GAAa,CAAA,CAAE,KAAA,QAAa,gBAAA;AAAA,cAG3B,uBAAA"}

package/dist/model/table.js

@@ -0,0 +1,22 @@
+import { RichTextNodeType } from "./richText.js";
+import { z } from "zod/mini";
+//#region src/model/table.ts
+const TableConfigSchema = z.object({ label: z.nullish(z.string()) });
+const TableModelSchema = z.object({
+	type: z.literal("Table"),
+	config: z.optional(TableConfigSchema)
+});
+const TableCellModelNodeTypes = [
+	RichTextNodeType.paragraph,
+	RichTextNodeType.strong,
+	RichTextNodeType.em,
+	RichTextNodeType.hyperlink
+];
+const TableCellModel = {
+	type: "StructuredText",
+	config: { multi: TableCellModelNodeTypes.join(",") }
+};
+//#endregion
+export { TableCellModel, TableCellModelNodeTypes, TableModelSchema };
+
+//# sourceMappingURL=table.js.map

package/dist/model/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","names":[],"sources":["../../src/model/table.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { RichTextNodeType, type RichTextModel } from \"./richText\"\n\nconst TableConfigSchema = z.object({\n\tlabel: z.nullish(z.string()),\n})\n\nexport const TableModelSchema = z.object({\n\ttype: z.literal(\"Table\"),\n\tconfig: z.optional(TableConfigSchema),\n})\n\nexport type TableModel = z.infer<typeof TableModelSchema>\n\n// TableCell configuration constant (used for cell rich text configuration)\nexport const TableCellModelNodeTypes = [\n\tRichTextNodeType.paragraph,\n\tRichTextNodeType.strong,\n\tRichTextNodeType.em,\n\tRichTextNodeType.hyperlink,\n]\n\nexport const TableCellModel: RichTextModel = {\n\ttype: \"StructuredText\" as const,\n\tconfig: {\n\t\tmulti: TableCellModelNodeTypes.join(\",\"),\n\t},\n}\n"],"mappings":";;;AAIA,MAAM,oBAAoB,EAAE,OAAO,EAClC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAC5B,CAAC;AAEF,MAAa,mBAAmB,EAAE,OAAO;CACxC,MAAM,EAAE,QAAQ,QAAQ;CACxB,QAAQ,EAAE,SAAS,kBAAkB;CACrC,CAAC;AAKF,MAAa,0BAA0B;CACtC,iBAAiB;CACjB,iBAAiB;CACjB,iBAAiB;CACjB,iBAAiB;CACjB;AAED,MAAa,iBAAgC;CAC5C,MAAM;CACN,QAAQ,EACP,OAAO,wBAAwB,KAAK,IAAI,EACxC;CACD"}

package/dist/model/text.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod/mini";
+
+//#region src/model/text.d.ts
+declare const TextModelSchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Text">;
+  fieldset: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  config: z.ZodMiniOptional<z.ZodMiniObject<{
+    label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    useAsTitle: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    placeholder: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type TextModel = z.infer<typeof TextModelSchema>;
+//#endregion
+export { TextModel };
+//# sourceMappingURL=text.d.ts.map

package/dist/model/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","names":[],"sources":["../../src/model/text.ts"],"mappings":";;;cAQa,eAAA,EAAe,CAAA,CAAA,aAAA;;;;;;;;;KAMhB,SAAA,GAAY,CAAA,CAAE,KAAA,QAAa,eAAA"}

package/dist/model/text.js

@@ -0,0 +1,16 @@
+import { z } from "zod/mini";
+//#region src/model/text.ts
+const TextConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	useAsTitle: z.optional(z.boolean()),
+	placeholder: z.optional(z.string())
+});
+const TextModelSchema = z.object({
+	type: z.literal("Text"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(TextConfigSchema)
+});
+//#endregion
+export { TextModelSchema };
+
+//# sourceMappingURL=text.js.map

package/dist/model/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","names":[],"sources":["../../src/model/text.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nconst TextConfigSchema = z.object({\n\tlabel: z.nullish(z.string()),\n\tuseAsTitle: z.optional(z.boolean()),\n\tplaceholder: z.optional(z.string()),\n})\n\nexport const TextModelSchema = z.object({\n\ttype: z.literal(\"Text\"),\n\tfieldset: z.nullish(z.string()),\n\tconfig: z.optional(TextConfigSchema),\n})\n\nexport type TextModel = z.infer<typeof TextModelSchema>\n"],"mappings":";;AAEA,MAAM,mBAAmB,EAAE,OAAO;CACjC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC5B,YAAY,EAAE,SAAS,EAAE,SAAS,CAAC;CACnC,aAAa,EAAE,SAAS,EAAE,QAAQ,CAAC;CACnC,CAAC;AAEF,MAAa,kBAAkB,EAAE,OAAO;CACvC,MAAM,EAAE,QAAQ,OAAO;CACvB,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC/B,QAAQ,EAAE,SAAS,iBAAiB;CACpC,CAAC"}

package/dist/model/timestamp.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod/mini";
+
+//#region src/model/timestamp.d.ts
+declare const TimestampModelSchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"Timestamp">;
+  fieldset: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  config: z.ZodMiniOptional<z.ZodMiniObject<{
+    label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    placeholder: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    default: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type TimestampModel = z.infer<typeof TimestampModelSchema>;
+//#endregion
+export { TimestampModel };
+//# sourceMappingURL=timestamp.d.ts.map

package/dist/model/timestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp.d.ts","names":[],"sources":["../../src/model/timestamp.ts"],"mappings":";;;cAQa,oBAAA,EAAoB,CAAA,CAAA,aAAA;;;;;;;;;KAMrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA"}

package/dist/model/timestamp.js

@@ -0,0 +1,16 @@
+import { z } from "zod/mini";
+//#region src/model/timestamp.ts
+const TimestampConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	placeholder: z.optional(z.string()),
+	default: z.optional(z.string())
+});
+const TimestampModelSchema = z.object({
+	type: z.literal("Timestamp"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(TimestampConfigSchema)
+});
+//#endregion
+export { TimestampModelSchema };
+
+//# sourceMappingURL=timestamp.js.map

package/dist/model/timestamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp.js","names":[],"sources":["../../src/model/timestamp.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nconst TimestampConfigSchema = z.object({\n\tlabel: z.nullish(z.string()),\n\tplaceholder: z.optional(z.string()),\n\tdefault: z.optional(z.string()),\n})\n\nexport const TimestampModelSchema = z.object({\n\ttype: z.literal(\"Timestamp\"),\n\tfieldset: z.nullish(z.string()),\n\tconfig: z.optional(TimestampConfigSchema),\n})\n\nexport type TimestampModel = z.infer<typeof TimestampModelSchema>\n"],"mappings":";;AAEA,MAAM,wBAAwB,EAAE,OAAO;CACtC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC5B,aAAa,EAAE,SAAS,EAAE,QAAQ,CAAC;CACnC,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC;CAC/B,CAAC;AAEF,MAAa,uBAAuB,EAAE,OAAO;CAC5C,MAAM,EAAE,QAAQ,YAAY;CAC5B,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC/B,QAAQ,EAAE,SAAS,sBAAsB;CACzC,CAAC"}

package/dist/model/uid.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod/mini";
+
+//#region src/model/uid.d.ts
+declare const UIDModelSchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"UID">;
+  fieldset: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  config: z.ZodMiniOptional<z.ZodMiniObject<{
+    label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    useAsTitle: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    placeholder: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type UIDModel = z.infer<typeof UIDModelSchema>;
+//#endregion
+export { UIDModel };
+//# sourceMappingURL=uid.d.ts.map

package/dist/model/uid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uid.d.ts","names":[],"sources":["../../src/model/uid.ts"],"mappings":";;;cAQa,cAAA,EAAc,CAAA,CAAA,aAAA;;;;;;;;;KAMf,QAAA,GAAW,CAAA,CAAE,KAAA,QAAa,cAAA"}

package/dist/model/uid.js

@@ -0,0 +1,16 @@
+import { z } from "zod/mini";
+//#region src/model/uid.ts
+const UIDConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	useAsTitle: z.optional(z.boolean()),
+	placeholder: z.optional(z.string())
+});
+const UIDModelSchema = z.object({
+	type: z.literal("UID"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(UIDConfigSchema)
+});
+//#endregion
+export { UIDModelSchema };
+
+//# sourceMappingURL=uid.js.map

package/dist/model/uid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uid.js","names":[],"sources":["../../src/model/uid.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nconst UIDConfigSchema = z.object({\n\tlabel: z.nullish(z.string()),\n\tuseAsTitle: z.optional(z.boolean()),\n\tplaceholder: z.optional(z.string()),\n})\n\nexport const UIDModelSchema = z.object({\n\ttype: z.literal(\"UID\"),\n\tfieldset: z.nullish(z.string()),\n\tconfig: z.optional(UIDConfigSchema),\n})\n\nexport type UIDModel = z.infer<typeof UIDModelSchema>\n"],"mappings":";;AAEA,MAAM,kBAAkB,EAAE,OAAO;CAChC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC5B,YAAY,EAAE,SAAS,EAAE,SAAS,CAAC;CACnC,aAAa,EAAE,SAAS,EAAE,QAAQ,CAAC;CACnC,CAAC;AAEF,MAAa,iBAAiB,EAAE,OAAO;CACtC,MAAM,EAAE,QAAQ,MAAM;CACtB,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC/B,QAAQ,EAAE,SAAS,gBAAgB;CACnC,CAAC"}

package/dist/model/widget.d.ts

@@ -0,0 +1,60 @@
+import { NestableModel } from "./nestable.js";
+import { GroupModel } from "./group.js";
+import { DynamicSlicesModel, StaticSlicesModel } from "./slices.js";
+import { UIDModel } from "./uid.js";
+import { z } from "zod/mini";
+
+//#region src/model/widget.d.ts
+type StaticWidgetModel = UIDModel | NestableModel | GroupModel | StaticSlicesModel;
+type DynamicWidgetModel = UIDModel | NestableModel | GroupModel | DynamicSlicesModel;
+declare const FieldModelTypeSchema: z.ZodMiniEnum<{
+  Color: "Color";
+  Date: "Date";
+  Number: "Number";
+  Range: "Range";
+  Select: "Select";
+  Link: "Link";
+  Text: "Text";
+  Timestamp: "Timestamp";
+  Boolean: "Boolean";
+  Embed: "Embed";
+  GeoPoint: "GeoPoint";
+  StructuredText: "StructuredText";
+  Separator: "Separator";
+  Table: "Table";
+  "Repeatable.Link": "Repeatable.Link";
+  Image: "Image";
+  IntegrationFields: "IntegrationFields";
+  UID: "UID";
+  Group: "Group";
+  Slices: "Slices";
+  Choice: "Choice";
+}>;
+type FieldModelType = z.infer<typeof FieldModelTypeSchema>;
+declare const FieldOrSliceTypeSchema: z.ZodMiniUnion<readonly [z.ZodMiniEnum<{
+  Color: "Color";
+  Date: "Date";
+  Number: "Number";
+  Range: "Range";
+  Select: "Select";
+  Link: "Link";
+  Text: "Text";
+  Timestamp: "Timestamp";
+  Boolean: "Boolean";
+  Embed: "Embed";
+  GeoPoint: "GeoPoint";
+  StructuredText: "StructuredText";
+  Separator: "Separator";
+  Table: "Table";
+  "Repeatable.Link": "Repeatable.Link";
+  Image: "Image";
+  IntegrationFields: "IntegrationFields";
+  UID: "UID";
+  Group: "Group";
+  Slices: "Slices";
+  Choice: "Choice";
+}>, z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"Slice">, z.ZodMiniLiteral<"SharedSlice">]>]>;
+type FieldOrSliceType = z.infer<typeof FieldOrSliceTypeSchema>;
+//#endregion
+export { DynamicWidgetModel, FieldModelType, FieldOrSliceType, StaticWidgetModel };
+//# sourceMappingURL=widget.d.ts.map

package/dist/model/widget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget.d.ts","names":[],"sources":["../../src/model/widget.ts"],"mappings":";;;;;;;KAoBY,iBAAA,GAAoB,QAAA,GAAW,aAAA,GAAgB,UAAA,GAAa,iBAAA;AAAA,KAU5D,kBAAA,GAAqB,QAAA,GAAW,aAAA,GAAgB,UAAA,GAAa,kBAAA;AAAA,cAG5D,oBAAA,EAAoB,CAAA,CAAA,WAAA;;;;;;;;;;;;;;;;;;;;;;;KAwBrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA;AAAA,cAG/B,sBAAA,EAAsB,CAAA,CAAA,YAAA,WAAA,CAAA,CAAA,WAAA;;;;;;;;;;;;;;;;;;;;;;;KAEvB,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,sBAAA"}

package/dist/model/widget.js

@@ -0,0 +1,47 @@
+import { NestableModelSchema } from "./nestable.js";
+import { GroupModelSchema } from "./group.js";
+import { SliceModelTypeSchema } from "./slice.js";
+import { DynamicSlicesModelSchema, StaticSlicesModelSchema } from "./slices.js";
+import { UIDModelSchema } from "./uid.js";
+import { z } from "zod/mini";
+//#region src/model/widget.ts
+const StaticWidgetModelSchema = z.union([
+	UIDModelSchema,
+	NestableModelSchema,
+	GroupModelSchema,
+	StaticSlicesModelSchema
+]);
+const DynamicWidgetModelSchema = z.union([
+	UIDModelSchema,
+	NestableModelSchema,
+	GroupModelSchema,
+	DynamicSlicesModelSchema
+]);
+const FieldModelTypeSchema = z.enum([
+	"Color",
+	"Boolean",
+	"Number",
+	"Embed",
+	"GeoPoint",
+	"Date",
+	"Range",
+	"StructuredText",
+	"Select",
+	"Separator",
+	"Table",
+	"Text",
+	"Timestamp",
+	"Link",
+	"Repeatable.Link",
+	"Image",
+	"IntegrationFields",
+	"UID",
+	"Group",
+	"Slices",
+	"Choice"
+]);
+const FieldOrSliceTypeSchema = z.union([FieldModelTypeSchema, SliceModelTypeSchema]);
+//#endregion
+export { DynamicWidgetModelSchema, FieldOrSliceTypeSchema, StaticWidgetModelSchema };
+
+//# sourceMappingURL=widget.js.map

package/dist/model/widget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget.js","names":[],"sources":["../../src/model/widget.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport type { GroupModel } from \"./group\"\nimport { GroupModelSchema } from \"./group\"\nimport type { NestableModel } from \"./nestable\"\nimport { NestableModelSchema } from \"./nestable\"\nimport { SliceModelTypeSchema } from \"./slice\"\nimport type { DynamicSlicesModel, StaticSlicesModel } from \"./slices\"\nimport { DynamicSlicesModelSchema, StaticSlicesModelSchema } from \"./slices\"\nimport type { UIDModel } from \"./uid\"\nimport { UIDModelSchema } from \"./uid\"\n\n// StaticWidget = UID | Nestable | Group | StaticSlices\nexport const StaticWidgetModelSchema: z.ZodMiniType<StaticWidgetModel> = z.union([\n\tUIDModelSchema,\n\tNestableModelSchema,\n\tGroupModelSchema,\n\tStaticSlicesModelSchema,\n])\n\nexport type StaticWidgetModel = UIDModel | NestableModel | GroupModel | StaticSlicesModel\n\n// DynamicWidget = UID | Nestable | Group | DynamicSlices\nexport const DynamicWidgetModelSchema: z.ZodMiniType<DynamicWidgetModel> = z.union([\n\tUIDModelSchema,\n\tNestableModelSchema,\n\tGroupModelSchema,\n\tDynamicSlicesModelSchema,\n])\n\nexport type DynamicWidgetModel = UIDModel | NestableModel | GroupModel | DynamicSlicesModel\n\n// FieldModelType - all possible field type strings\nexport const FieldModelTypeSchema = z.enum([\n\t\"Color\",\n\t\"Boolean\",\n\t\"Number\",\n\t\"Embed\",\n\t\"GeoPoint\",\n\t\"Date\",\n\t\"Range\",\n\t\"StructuredText\",\n\t\"Select\",\n\t\"Separator\",\n\t\"Table\",\n\t\"Text\",\n\t\"Timestamp\",\n\t\"Link\",\n\t\"Repeatable.Link\",\n\t\"Image\",\n\t\"IntegrationFields\",\n\t\"UID\",\n\t\"Group\",\n\t\"Slices\",\n\t\"Choice\",\n])\n\nexport type FieldModelType = z.infer<typeof FieldModelTypeSchema>\n\n// Field and slice types\nexport const FieldOrSliceTypeSchema = z.union([FieldModelTypeSchema, SliceModelTypeSchema])\n\nexport type FieldOrSliceType = z.infer<typeof FieldOrSliceTypeSchema>\n"],"mappings":";;;;;;;AAaA,MAAa,0BAA4D,EAAE,MAAM;CAChF;CACA;CACA;CACA;CACA,CAAC;AAKF,MAAa,2BAA8D,EAAE,MAAM;CAClF;CACA;CACA;CACA;CACA,CAAC;AAKF,MAAa,uBAAuB,EAAE,KAAK;CAC1C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA,CAAC;AAKF,MAAa,yBAAyB,EAAE,MAAM,CAAC,sBAAsB,qBAAqB,CAAC"}