@prismicio/types-internal 4.0.0-pr.6.0ddf815 → 4.0.0-pr.6.38cb7de

package/src/model/link.ts

@@ -3,7 +3,7 @@ import { z } from "zod/mini"
 // Accepts string | string[], normalizes string to [string]
 const MasksArrayStringSchema = z.pipe(
 	z.union([z.array(z.string()), z.string()]),
-	z.transform((val): readonly string[] => (typeof val === "string" ? [val] : val)),
+	z.transform((val): string[] => (typeof val === "string" ? [val] : val)),
 )
 
 // --- CustomTypes hierarchy (field selection in content relationship fields) ---
@@ -15,9 +15,7 @@ const noDuplicateStrings = z.refine(
 	"Fields have duplicates.",
 )
 
-const CustomTypeLevel2FieldGroupFieldsSchema = z.readonly(
-	z.array(z.string()).check(noDuplicateStrings),
-)
+const CustomTypeLevel2FieldGroupFieldsSchema = z.array(z.string()).check(noDuplicateStrings)
 
 const CustomTypeLevel2FieldSchema = z.union([
 	z.object({ id: z.string(), fields: CustomTypeLevel2FieldGroupFieldsSchema }),
@@ -30,18 +28,18 @@ const noDuplicateIds = (items: unknown) => {
 	return ids.size === arr.length
 }
 
-const CustomTypeLevel2FieldsSchema = z.readonly(
-	z.array(CustomTypeLevel2FieldSchema).check(z.refine(noDuplicateIds, "Fields have duplicates.")),
-)
+const CustomTypeLevel2FieldsSchema = z
+	.array(CustomTypeLevel2FieldSchema)
+	.check(z.refine(noDuplicateIds, "Fields have duplicates."))
 
 const CustomTypeLevel2Schema = z.union([
 	z.string(),
 	z.object({ id: z.string(), fields: CustomTypeLevel2FieldsSchema }),
 ])
 
-const CustomTypesLevel2Schema = z.readonly(
-	z.array(CustomTypeLevel2Schema).check(z.refine(noDuplicateIds, "Custom types have duplicates.")),
-)
+const CustomTypesLevel2Schema = z
+	.array(CustomTypeLevel2Schema)
+	.check(z.refine(noDuplicateIds, "Custom types have duplicates."))
 
 // Level 1
 
@@ -55,11 +53,9 @@ const CustomTypeLevel1FieldGroupFieldSchema = z.union([
 	z.string(),
 ])
 
-const CustomTypeLevel1FieldGroupFieldsSchema = z.readonly(
-	z
-		.array(CustomTypeLevel1FieldGroupFieldSchema)
-		.check(z.refine(noDuplicateIds, "Fields have duplicates.")),
-)
+const CustomTypeLevel1FieldGroupFieldsSchema = z
+	.array(CustomTypeLevel1FieldGroupFieldSchema)
+	.check(z.refine(noDuplicateIds, "Fields have duplicates."))
 
 const CustomTypeLevel1FieldSchema = z.union([
 	z.object({
@@ -70,45 +66,43 @@ const CustomTypeLevel1FieldSchema = z.union([
 	z.string(),
 ])
 
-const CustomTypeLevel1FieldsSchema = z.readonly(
-	z.array(CustomTypeLevel1FieldSchema).check(z.refine(noDuplicateIds, "Fields have duplicates.")),
-)
+const CustomTypeLevel1FieldsSchema = z
+	.array(CustomTypeLevel1FieldSchema)
+	.check(z.refine(noDuplicateIds, "Fields have duplicates."))
 
 const CustomTypeLevel1Schema = z.union([
 	z.string(),
 	z.object({ id: z.string(), fields: CustomTypeLevel1FieldsSchema }),
 ])
 
-const CustomTypesSchema = z.readonly(
-	z.array(CustomTypeLevel1Schema).check(({ value, issues }) => {
-		const cts = value as ({ id: string } | string)[]
-		const push = (message: string) => issues.push({ code: "custom", input: value, message })
-		const strings = new Set<string>()
-		const objects = new Set<string>()
-		for (const ct of cts) {
-			let failed = false
-			if (typeof ct === "string") {
-				failed = objects.has(ct)
-				strings.add(ct)
-			} else {
-				const { id } = ct
-				failed = strings.has(id) || objects.has(id)
-				objects.add(id)
-			}
-			if (failed) {
-				push("Custom types have duplicates.")
-				return
-			}
+const CustomTypesSchema = z.array(CustomTypeLevel1Schema).check(({ value, issues }) => {
+	const cts = value as ({ id: string } | string)[]
+	const push = (message: string) => issues.push({ code: "custom", input: value, message })
+	const strings = new Set<string>()
+	const objects = new Set<string>()
+	for (const ct of cts) {
+		let failed = false
+		if (typeof ct === "string") {
+			failed = objects.has(ct)
+			strings.add(ct)
+		} else {
+			const { id } = ct
+			failed = strings.has(id) || objects.has(id)
+			objects.add(id)
 		}
-		if (objects.size > 1) {
-			push("Cannot have multiple custom types with fields selection.")
+		if (failed) {
+			push("Custom types have duplicates.")
 			return
 		}
-		if (strings.size > 0 && objects.size > 0) {
-			push("Cannot mix custom types as strings and objects with fields.")
-		}
-	}),
-)
+	}
+	if (objects.size > 1) {
+		push("Cannot have multiple custom types with fields selection.")
+		return
+	}
+	if (strings.size > 0 && objects.size > 0) {
+		push("Cannot mix custom types as strings and objects with fields.")
+	}
+})
 
 // --- Select with fallback to null ---
 

package/src/model/nestable.ts

@@ -1,20 +1,36 @@
 import { z } from "zod/mini"
 
+import type { BooleanModel } from "./boolean"
 import { BooleanModelSchema } from "./boolean"
+import type { ColorModel } from "./color"
 import { ColorModelSchema } from "./color"
+import type { DateModel } from "./date"
 import { DateModelSchema } from "./date"
+import type { EmbedModel } from "./embed"
 import { EmbedModelSchema } from "./embed"
+import type { GeoPointModel } from "./geopoint"
 import { GeoPointModelSchema } from "./geopoint"
+import type { ImageModel } from "./image"
 import { ImageModelSchema } from "./image"
+import type { IntegrationFieldModel } from "./integrationField"
 import { IntegrationFieldModelSchema } from "./integrationField"
+import type { LinkModel } from "./link"
 import { LinkModelSchema } from "./link"
+import type { NumberModel } from "./number"
 import { NumberModelSchema } from "./number"
+import type { RangeModel } from "./range"
 import { RangeModelSchema } from "./range"
+import type { RichTextModel } from "./richText"
 import { RichTextModelSchema } from "./richText"
+import type { SelectModel } from "./select"
 import { SelectModelSchema } from "./select"
+import type { SeparatorModel } from "./separator"
 import { SeparatorModelSchema } from "./separator"
+import type { TableModel } from "./table"
 import { TableModelSchema } from "./table"
+import type { TextModel } from "./text"
 import { TextModelSchema } from "./text"
+import type { TimestampModel } from "./timestamp"
 import { TimestampModelSchema } from "./timestamp"
 
 export const NestableModelSchema = z.union([
@@ -36,4 +52,20 @@ export const NestableModelSchema = z.union([
 	TimestampModelSchema,
 ])
 
-export type NestableModel = z.infer<typeof NestableModelSchema>
+export type NestableModel =
+	| BooleanModel
+	| ColorModel
+	| DateModel
+	| EmbedModel
+	| GeoPointModel
+	| ImageModel
+	| IntegrationFieldModel
+	| LinkModel
+	| NumberModel
+	| RangeModel
+	| RichTextModel
+	| SelectModel
+	| SeparatorModel
+	| TableModel
+	| TextModel
+	| TimestampModel

package/src/model/richText.ts

@@ -52,7 +52,7 @@ const RichTextOptionsSchema = z.pipe(
  */
 const LegacyLabelsFormat = z.record(z.string(), z.array(z.object({ name: z.string() })))
 
-const RichTextLabelsSchema = z.pipe(
+const RichTextLabelsSchema: z.ZodMiniType<string[]> = z.pipe(
 	z.union([
 		z.pipe(
 			z.null(),
@@ -83,7 +83,7 @@ const RichTextLabelsSchema = z.pipe(
 			}),
 		),
 	]),
-	z.transform((result: string[]) => result as readonly string[]),
+	z.transform((result: string[]) => result as string[]),
 )
 
 const RichTextConfigSchema = z.object({

package/src/model/select.ts

@@ -2,7 +2,7 @@ import { z } from "zod/mini"
 
 // Options can be string, number, or boolean - all coerced to string
 // Matches io-ts behavior: t.union([t.string, StringFromNumber, StringFromBoolean])
-const SelectOptionSchema = z.union([
+const SelectOptionSchema: z.ZodMiniType<string> = z.union([
 	z.string(),
 	z.pipe(
 		z.number(),
@@ -18,7 +18,7 @@ const SelectConfigSchema = z.object({
 	label: z.nullish(z.string()),
 	placeholder: z.optional(z.string()),
 	default_value: z.optional(z.string()),
-	options: z.optional(z.readonly(z.array(SelectOptionSchema))),
+	options: z.optional(z.array(SelectOptionSchema)),
 })
 
 export const SelectModelSchema = z.object({

package/src/model/slice.ts

@@ -1,13 +1,18 @@
 import { z } from "zod/mini"
 
 import { WidgetKeySchema } from "../common/widgetKey"
+import type { NestedGroupModel } from "./group"
 import { GroupModelSchema, NestedGroupModelSchema } from "./group"
+import type { NestableModel } from "./nestable"
 import { NestableModelSchema } from "./nestable"
 
 // Simple (before 2020)
-export const LegacySliceModelSchema = z.union([NestableModelSchema, NestedGroupModelSchema])
+export const LegacySliceModelSchema: z.ZodMiniType<LegacySliceModel> = z.union([
+	NestableModelSchema,
+	NestedGroupModelSchema,
+])
 
-export type LegacySliceModel = z.infer<typeof LegacySliceModelSchema>
+export type LegacySliceModel = NestableModel | NestedGroupModel
 
 // Composite (2020 to 2021)
 export const CompositeSliceType = "Slice" as const
@@ -43,7 +48,14 @@ export const SharedSliceVariationSchema = z.object({
 	docURL: z.string(),
 	version: z.string(),
 	display: z.optional(z.string()),
-	primary: z.optional(z.record(z.string(), z.union([NestableModelSchema, GroupModelSchema]))),
+	primary: z.optional(
+		z.record(
+			z.string(),
+			z.union([NestableModelSchema, GroupModelSchema]) as z.ZodMiniType<
+				NestableModel | NestedGroupModel
+			>,
+		),
+	),
 	items: z.optional(z.record(z.string(), NestableModelSchema)),
 })
 
@@ -68,34 +80,49 @@ export type SharedSliceRefModel = z.infer<typeof SharedSliceRefModelSchema>
 
 // Used to represent a shared slice content which can only be
 // of a given shared slice variation type.
-export const SharedSliceVariationModelSchema = z.object({
+export const SharedSliceVariationContentModelSchema = z.object({
 	type: z.literal(SharedSliceType),
 	sliceName: z.string(),
 	variationID: z.string(),
 	fields: z.pick(SharedSliceVariationSchema, { primary: true, items: true }),
 })
 
-export type SharedSliceVariationModel = z.infer<typeof SharedSliceVariationModelSchema>
+export type SharedSliceVariationContentModel = z.infer<
+	typeof SharedSliceVariationContentModelSchema
+>
 
 // All
 
 // Used when slices reference SharedSlice by ref (not full definition)
-export const DynamicSliceModelSchema = z.union([
+export const DynamicSliceModelSchema: z.ZodMiniType<DynamicSliceModel> = z.union([
 	CompositeSliceModelSchema,
 	LegacySliceModelSchema,
 	SharedSliceRefModelSchema,
 ])
 
-export type DynamicSliceModel = z.infer<typeof DynamicSliceModelSchema>
+export type DynamicSliceModel = CompositeSliceModel | LegacySliceModel | SharedSliceRefModel
 
 // Used when slices include full SharedSlice definition
-export const StaticSliceModelSchema = z.union([
+export const StaticSliceModelSchema: z.ZodMiniType<StaticSliceModel> = z.union([
 	CompositeSliceModelSchema,
 	LegacySliceModelSchema,
 	SharedSliceModelSchema,
 ])
 
-export type StaticSliceModel = z.infer<typeof StaticSliceModelSchema>
+export type StaticSliceModel = CompositeSliceModel | LegacySliceModel | SharedSliceModel
+
+// Used to represent a slice content model as shared slice variations
+// can only be of a given shared slice variation type.
+export const SliceContentModelSchema: z.ZodMiniType<SliceContentModel> = z.union([
+	CompositeSliceModelSchema,
+	LegacySliceModelSchema,
+	SharedSliceVariationContentModelSchema,
+])
+
+export type SliceContentModel =
+	| CompositeSliceModel
+	| LegacySliceModel
+	| SharedSliceVariationContentModel
 
 // Model types
 export const SliceModelTypeSchema = z.union([

package/src/model/table.ts

@@ -1,4 +1,5 @@
 import { z } from "zod/mini"
+import { RichTextNodeType, type RichTextModel } from "./richText"
 
 const TableConfigSchema = z.object({
 	label: z.nullish(z.string()),
@@ -12,9 +13,16 @@ export const TableModelSchema = z.object({
 export type TableModel = z.infer<typeof TableModelSchema>
 
 // TableCell configuration constant (used for cell rich text configuration)
-export const TableCellModel = {
+export const TableCellModelNodeTypes = [
+	RichTextNodeType.paragraph,
+	RichTextNodeType.strong,
+	RichTextNodeType.em,
+	RichTextNodeType.hyperlink
+]
+
+export const TableCellModel: RichTextModel = {
 	type: "StructuredText" as const,
 	config: {
-		multi: ["paragraph", "strong", "em", "hyperlink"].join(","),
+		multi: TableCellModelNodeTypes.join(","),
 	},
 }

package/src/model/widget.ts

@@ -1,30 +1,34 @@
 import { z } from "zod/mini"
 
+import type { GroupModel } from "./group"
 import { GroupModelSchema } from "./group"
+import type { NestableModel } from "./nestable"
 import { NestableModelSchema } from "./nestable"
 import { SliceModelTypeSchema } from "./slice"
+import type { DynamicSlicesModel, StaticSlicesModel } from "./slices"
 import { DynamicSlicesModelSchema, StaticSlicesModelSchema } from "./slices"
+import type { UIDModel } from "./uid"
 import { UIDModelSchema } from "./uid"
 
 // StaticWidget = UID | Nestable | Group | StaticSlices
-export const StaticWidgetModelSchema = z.union([
+export const StaticWidgetModelSchema: z.ZodMiniType<StaticWidgetModel> = z.union([
 	UIDModelSchema,
 	NestableModelSchema,
 	GroupModelSchema,
 	StaticSlicesModelSchema,
 ])
 
-export type StaticWidgetModel = z.infer<typeof StaticWidgetModelSchema>
+export type StaticWidgetModel = UIDModel | NestableModel | GroupModel | StaticSlicesModel
 
 // DynamicWidget = UID | Nestable | Group | DynamicSlices
-export const DynamicWidgetModelSchema = z.union([
+export const DynamicWidgetModelSchema: z.ZodMiniType<DynamicWidgetModel> = z.union([
 	UIDModelSchema,
 	NestableModelSchema,
 	GroupModelSchema,
 	DynamicSlicesModelSchema,
 ])
 
-export type DynamicWidgetModel = z.infer<typeof DynamicWidgetModelSchema>
+export type DynamicWidgetModel = UIDModel | NestableModel | GroupModel | DynamicSlicesModel
 
 // FieldModelType - all possible field type strings
 export const FieldModelTypeSchema = z.enum([