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

package/src/index.ts

@@ -0,0 +1,123 @@
+// Common
+export type { Asset } from "./common/asset"
+export type { Embed } from "./common/embed"
+export type { HexaColorCode } from "./common/hexaColorCode"
+export type { NonEmptyString } from "./common/nonEmptyString"
+export type { WidgetKey } from "./common/widgetKey"
+
+// Content
+export type { BooleanContent } from "./content/boolean"
+export type { DocumentContent } from "./content/document"
+export type { EmbedContent } from "./content/embed"
+export type { EmptyContent } from "./content/empty"
+export type {
+	ColorContent,
+	DateContent,
+	NumberContent,
+	RangeContent,
+	SelectContent,
+	TextContent,
+	TimestampContent,
+	FieldContent,
+} from "./content/field"
+export type { GeoPointContent } from "./content/geopoint"
+export type { GroupContent, GroupItemContent } from "./content/group"
+export type { ImageContent } from "./content/image"
+export type { IntegrationFieldContent } from "./content/integrationField"
+export type { LinkContent } from "./content/link"
+export type { NestableContent } from "./content/nestable"
+export type { RepeatableContent } from "./content/repeatable"
+export type { RichTextContent, RichTextContentBlock, RichTextContentSpan } from "./content/richText"
+export type { SeparatorContent } from "./content/separator"
+export type {
+	LegacySliceContent,
+	CompositeSliceContent,
+	SharedSliceContent,
+	SliceContent,
+} from "./content/slice"
+export type {
+	LegacySliceItemContent,
+	CompositeSliceItemContent,
+	SharedSliceItemContent,
+	SliceItemContent,
+	SlicesContent,
+} from "./content/slices"
+export type { TableContent } from "./content/table"
+export type { UIDContent } from "./content/uid"
+export type { WidgetContent } from "./content/widget"
+
+// Model
+export type { BooleanModel } from "./model/boolean"
+export type { ColorModel } from "./model/color"
+export type { StaticCustomTypeModel, CustomTypeModel } from "./model/customType"
+export type { DateModel } from "./model/date"
+export type { EmbedModel } from "./model/embed"
+export type { GeoPointModel } from "./model/geopoint"
+export type { GroupModel, NestedGroupModel } from "./model/group"
+export type { ImageModel } from "./model/image"
+export type { IntegrationFieldModel } from "./model/integrationField"
+export type { LinkModel } from "./model/link"
+export type { NestableModel } from "./model/nestable"
+export type { NumberModel } from "./model/number"
+export type { RangeModel } from "./model/range"
+export type { RichTextModel } from "./model/richText"
+export type { StaticSectionModel, DynamicSectionModel } from "./model/section"
+export type { SelectModel } from "./model/select"
+export type { SeparatorModel } from "./model/separator"
+export type {
+	LegacySliceModel,
+	CompositeSliceModel,
+	SharedSliceModel,
+	SharedSliceRefModel,
+	SharedSliceVariationContentModel as SharedSliceVariationModel,
+	StaticSliceModel,
+	DynamicSliceModel,
+	SliceContentModel,
+	SliceModelType,
+} from "./model/slice"
+export type { DynamicSlicesModel, StaticSlicesModel } from "./model/slices"
+export type { TableModel } from "./model/table"
+export { TableCellModelNodeTypes } from "./model/table"
+export type { TextModel } from "./model/text"
+export type { TimestampModel } from "./model/timestamp"
+export type { UIDModel } from "./model/uid"
+export type { StaticWidgetModel, DynamicWidgetModel, FieldModelType } from "./model/widget"
+
+// Legacy
+export { LegacyContentCtx, getFieldCtx, defaultCtx } from "./content/codec/legacyContentCtx"
+
+// Helpers
+export * as contentPath from "./helpers/contentPath"
+export * as customTypeModel from "./helpers/customTypeModel"
+export * as documentContent from "./helpers/documentContent"
+export * as sliceContent from "./helpers/sliceContent"
+export {
+	traverseDocumentContent,
+	traverseSlicesContent,
+	traverseSharedSliceContent,
+	traverseCompositeSliceContent,
+	traverseLegacySliceContent,
+	traverseGroupContent,
+	traverseGroupItemsContent,
+	traverseRepeatableContent,
+	traverseTableContent,
+} from "./helpers/traverseContent"
+export type {
+	TraverseSliceContentFunction,
+	TraverseWidgetContentFunction,
+} from "./helpers/traverseContent"
+export {
+	traverseDocumentContentWithModel,
+	traverseSlicesContentWithModel,
+	traverseSharedSliceContentWithModel,
+	traverseCompositeSliceContentWithModel,
+	traverseLegacySliceContentWithModel,
+	traverseGroupContentWithModel,
+	traverseGroupItemsContentWithModel,
+	traverseRepeatableContentWithModel,
+	traverseTableContentWithModel,
+} from "./helpers/traverseContentWithModel"
+export type {
+	TraverseSliceContentWithModelFunction,
+	TraverseWidgetContentWithModelFunction,
+} from "./helpers/traverseContentWithModel"

package/src/io-ts.ts

@@ -0,0 +1,351 @@
+import * as t from "io-ts"
+import type { ZodMiniType } from "zod/mini"
+
+// Common
+import { AssetSchema as rawAssetSchema } from "./common/asset"
+import { EmbedSchema as rawEmbedSchema } from "./common/embed"
+import { HexaColorCodeSchema as rawHexaColorCodeSchema } from "./common/hexaColorCode"
+import { NonEmptyStringSchema as rawNonEmptyStringSchema } from "./common/nonEmptyString"
+import { WidgetKeySchema as rawWidgetKeySchema } from "./common/widgetKey"
+// Content
+import { BooleanContentSchema as rawBooleanContentSchema } from "./content/boolean"
+import { BooleanLegacyCodec } from "./content/codec/boolean"
+import { DocumentLegacyCodec } from "./content/codec/document"
+import { EmbedLegacyCodec } from "./content/codec/embed"
+import { EmptyLegacyCodec } from "./content/codec/empty"
+import {
+	ColorLegacyCodec,
+	DateLegacyCodec,
+	NumberLegacyCodec,
+	RangeLegacyCodec,
+	SelectLegacyCodec,
+	TextLegacyCodec,
+	TimestampLegacyCodec,
+} from "./content/codec/field"
+import { GeoPointLegacyCodec } from "./content/codec/geopoint"
+import { GroupItemLegacyCodec, GroupLegacyCodec } from "./content/codec/group"
+import { ImageLegacyCodec } from "./content/codec/image"
+import { IntegrationFieldLegacyCodec } from "./content/codec/integrationField"
+import type { LegacyCodec } from "./content/codec/legacyContentCtx"
+import { LinkLegacyCodec } from "./content/codec/link"
+import { NestableLegacyCodec } from "./content/codec/nestable"
+import { RepeatableLegacyCodec } from "./content/codec/repeatable"
+import { RichTextLegacyCodec } from "./content/codec/richText"
+import { SeparatorLegacyCodec } from "./content/codec/separator"
+import {
+	CompositeSliceLegacyCodec,
+	SharedSliceLegacyCodec,
+	LegacySliceLegacyCodec,
+	SliceLegacyCodec,
+} from "./content/codec/slice"
+import { SliceItemLegacyCodec, SlicesLegacyCodec } from "./content/codec/slices"
+import { TableLegacyCodec } from "./content/codec/table"
+import { UIDLegacyCodec } from "./content/codec/uid"
+import { WidgetLegacyCodec } from "./content/codec/widget"
+import { DocumentContentSchema as rawDocumentContentSchema } from "./content/document"
+import { EmbedContentSchema as rawEmbedContentSchema } from "./content/embed"
+import { EmptyContentSchema as rawEmptyContentSchema } from "./content/empty"
+import {
+	ColorContentSchema as rawColorContentSchema,
+	DateContentSchema as rawDateContentSchema,
+	NumberContentSchema as rawNumberContentSchema,
+	RangeContentSchema as rawRangeContentSchema,
+	SelectContentSchema as rawSelectContentSchema,
+	TextContentSchema as rawTextContentSchema,
+	TimestampContentSchema as rawTimestampContentSchema,
+	FieldContentSchema as rawFieldContentSchema,
+} from "./content/field"
+import { GeoPointContentSchema as rawGeoPointContentSchema } from "./content/geopoint"
+import {
+	GroupContentSchema as rawGroupContentSchema,
+	GroupItemContentSchema as rawGroupItemContentSchema,
+} from "./content/group"
+import { ImageContentSchema as rawImageContentSchema } from "./content/image"
+import { IntegrationFieldContentSchema as rawIntegrationFieldContentSchema } from "./content/integrationField"
+import { LinkContentSchema as rawLinkContentSchema } from "./content/link"
+import { NestableContentSchema as rawNestableContentSchema } from "./content/nestable"
+import { RepeatableContentSchema as rawRepeatableContentSchema } from "./content/repeatable"
+import {
+	RichTextContentSchema as rawRichTextContentSchema,
+	RichTextContentBlockSchema as rawRichTextContentBlockSchema,
+	RichTextContentSpanSchema as rawRichTextContentSpanSchema,
+} from "./content/richText"
+import { SeparatorContentSchema as rawSeparatorContentSchema } from "./content/separator"
+import {
+	LegacySliceContentSchema as rawLegacySliceContentSchema,
+	CompositeSliceContentSchema as rawCompositeSliceContentSchema,
+	SharedSliceContentSchema as rawSharedSliceContentSchema,
+	SliceContentSchema as rawSliceContentSchema,
+} from "./content/slice"
+import {
+	LegacySliceItemContentSchema as rawLegacySliceItemContentSchema,
+	CompositeSliceItemContentSchema as rawCompositeSliceItemContentSchema,
+	SharedSliceItemContentSchema as rawSharedSliceItemContentSchema,
+	SliceItemContentSchema as rawSliceItemContentSchema,
+	SlicesContentSchema as rawSlicesContentSchema,
+} from "./content/slices"
+import { TableContentSchema as rawTableContentSchema } from "./content/table"
+import { UIDContentSchema as rawUIDContentSchema } from "./content/uid"
+import { WidgetContentSchema as rawWidgetContentSchema } from "./content/widget"
+// Model
+import { BooleanModelSchema as rawBooleanModelSchema } from "./model/boolean"
+import { ColorModelSchema as rawColorModelSchema } from "./model/color"
+import {
+	StaticCustomTypeModelSchema as rawStaticCustomTypeModelSchema,
+	CustomTypeModelSchema as rawCustomTypeModelSchema,
+} from "./model/customType"
+import { DateModelSchema as rawDateModelSchema } from "./model/date"
+import { EmbedModelSchema as rawEmbedModelSchema } from "./model/embed"
+import { GeoPointModelSchema as rawGeoPointModelSchema } from "./model/geopoint"
+import {
+	GroupModelSchema as rawGroupModelSchema,
+	NestedGroupModelSchema as rawNestedGroupModelSchema,
+} from "./model/group"
+import { ImageModelSchema as rawImageModelSchema } from "./model/image"
+import { IntegrationFieldModelSchema as rawIntegrationFieldModelSchema } from "./model/integrationField"
+import { LinkModelSchema as rawLinkModelSchema } from "./model/link"
+import { NestableModelSchema as rawNestableModelSchema } from "./model/nestable"
+import { NumberModelSchema as rawNumberModelSchema } from "./model/number"
+import { RangeModelSchema as rawRangeModelSchema } from "./model/range"
+import { RichTextModelSchema as rawRichTextModelSchema } from "./model/richText"
+import {
+	StaticSectionModelSchema as rawStaticSectionModelSchema,
+	DynamicSectionModelSchema as rawDynamicSectionModelSchema,
+} from "./model/section"
+import { SelectModelSchema as rawSelectModelSchema } from "./model/select"
+import { SeparatorModelSchema as rawSeparatorModelSchema } from "./model/separator"
+import {
+	LegacySliceModelSchema as rawLegacySliceModelSchema,
+	CompositeSliceModelSchema as rawCompositeSliceModelSchema,
+	SharedSliceModelSchema as rawSharedSliceModelSchema,
+	SharedSliceRefModelSchema as rawSharedSliceRefModelSchema,
+	StaticSliceModelSchema as rawStaticSliceModelSchema,
+	DynamicSliceModelSchema as rawDynamicSliceModelSchema,
+	SliceContentModelSchema as rawSliceContentModelSchema,
+} from "./model/slice"
+import {
+	DynamicSlicesModelSchema as rawDynamicSlicesModelSchema,
+	StaticSlicesModelSchema as rawStaticSlicesModelSchema,
+} from "./model/slices"
+import { TableModelSchema as rawTableModelSchema } from "./model/table"
+import { TextModelSchema as rawTextModelSchema } from "./model/text"
+import { TimestampModelSchema as rawTimestampModelSchema } from "./model/timestamp"
+import { UIDModelSchema as rawUIDModelSchema } from "./model/uid"
+import {
+	StaticWidgetModelSchema as rawStaticWidgetModelSchema,
+	DynamicWidgetModelSchema as rawDynamicWidgetModelSchema,
+} from "./model/widget"
+
+// Common
+export const AssetSchema = toIOTS(rawAssetSchema)
+export const EmbedSchema = toIOTS(rawEmbedSchema)
+export const HexaColorCodeSchema = toIOTS(rawHexaColorCodeSchema)
+export const NonEmptyStringSchema = toIOTS(rawNonEmptyStringSchema)
+export const WidgetKeySchema = toIOTS(rawWidgetKeySchema)
+
+// Content
+export const BooleanContentSchema = toIOTS(rawBooleanContentSchema)
+export const ColorContentSchema = toIOTS(rawColorContentSchema)
+export const DateContentSchema = toIOTS(rawDateContentSchema)
+export const EmptyContentSchema = toIOTS(rawEmptyContentSchema)
+export const GeoPointContentSchema = toIOTS(rawGeoPointContentSchema)
+export const LinkContentSchema = toIOTS(rawLinkContentSchema)
+export const NumberContentSchema = toIOTS(rawNumberContentSchema)
+export const RangeContentSchema = toIOTS(rawRangeContentSchema)
+export const SelectContentSchema = toIOTS(rawSelectContentSchema)
+export const SeparatorContentSchema = toIOTS(rawSeparatorContentSchema)
+export const SharedSliceContentSchema = toIOTS(rawSharedSliceContentSchema)
+export const TextContentSchema = toIOTS(rawTextContentSchema)
+export const TimestampContentSchema = toIOTS(rawTimestampContentSchema)
+export const FieldContentSchema = toIOTS(rawFieldContentSchema)
+export const UIDContentSchema = toIOTS(rawUIDContentSchema)
+export const IntegrationFieldContentSchema = toIOTS(rawIntegrationFieldContentSchema)
+export const EmbedContentSchema = toIOTS(rawEmbedContentSchema)
+export const ImageContentSchema = toIOTS(rawImageContentSchema)
+export const RichTextContentSchema = toIOTS(rawRichTextContentSchema)
+export const RichTextContentBlockSchema = toIOTS(rawRichTextContentBlockSchema)
+export const RichTextContentSpanSchema = toIOTS(rawRichTextContentSpanSchema)
+export const TableContentSchema = toIOTS(rawTableContentSchema)
+export const RepeatableContentSchema = toIOTS(rawRepeatableContentSchema)
+export const NestableContentSchema = toIOTS(rawNestableContentSchema)
+export const GroupContentSchema = toIOTS(rawGroupContentSchema)
+export const GroupItemContentSchema = toIOTS(rawGroupItemContentSchema)
+export const CompositeSliceContentSchema = toIOTS(rawCompositeSliceContentSchema)
+export const LegacySliceContentSchema = toIOTS(rawLegacySliceContentSchema)
+export const SliceContentSchema = toIOTS(rawSliceContentSchema)
+export const LegacySliceItemContentSchema = toIOTS(rawLegacySliceItemContentSchema)
+export const CompositeSliceItemContentSchema = toIOTS(rawCompositeSliceItemContentSchema)
+export const SharedSliceItemContentSchema = toIOTS(rawSharedSliceItemContentSchema)
+export const SliceItemContentSchema = toIOTS(rawSliceItemContentSchema)
+export const SlicesContentSchema = toIOTS(rawSlicesContentSchema)
+export const WidgetContentSchema = toIOTS(rawWidgetContentSchema)
+export const DocumentContentSchema = toIOTS(rawDocumentContentSchema)
+
+// Content legacy
+export const BooleanLegacy = toIOTSCodec(BooleanLegacyCodec)
+export const EmptyLegacy = toIOTSCodec(EmptyLegacyCodec)
+export const TextLegacy = toIOTSCodec(TextLegacyCodec)
+export const ColorLegacy = toIOTSCodec(ColorLegacyCodec)
+export const DateLegacy = toIOTSCodec(DateLegacyCodec)
+export const TimestampLegacy = toIOTSCodec(TimestampLegacyCodec)
+export const NumberLegacy = toIOTSCodec(NumberLegacyCodec)
+export const RangeLegacy = toIOTSCodec(RangeLegacyCodec)
+export const SelectLegacy = toIOTSCodec(SelectLegacyCodec)
+export const GeoPointLegacy = toIOTSCodec(GeoPointLegacyCodec)
+export const EmbedLegacy = toIOTSCodec(EmbedLegacyCodec)
+export const ImageLegacy = toIOTSCodec(ImageLegacyCodec)
+export const LinkLegacy = toIOTSCodec(LinkLegacyCodec)
+export const RepeatableLegacy = toIOTSCodec(RepeatableLegacyCodec)
+export const RichTextLegacy = toIOTSCodec(RichTextLegacyCodec)
+export const SeparatorLegacy = toIOTSCodec(SeparatorLegacyCodec)
+export const IntegrationFieldLegacy = toIOTSCodec(IntegrationFieldLegacyCodec)
+export const TableLegacy = toIOTSCodec(TableLegacyCodec)
+export const NestableLegacy = toIOTSCodec(NestableLegacyCodec)
+export const UIDLegacy = toIOTSCodec(UIDLegacyCodec)
+export const GroupItemLegacy = toIOTSCodec(GroupItemLegacyCodec)
+export const GroupLegacy = toIOTSCodec(GroupLegacyCodec)
+export const LegacySliceLegacy = toIOTSCodec(LegacySliceLegacyCodec)
+export const CompositeSliceLegacy = toIOTSCodec(CompositeSliceLegacyCodec)
+export const SharedSliceLegacy = toIOTSCodec(SharedSliceLegacyCodec)
+export const SliceLegacy = toIOTSCodec(SliceLegacyCodec)
+export const SliceItemLegacy = toIOTSCodec(SliceItemLegacyCodec)
+export const SlicesLegacy = toIOTSCodec(SlicesLegacyCodec)
+export const WidgetLegacy = toIOTSCodec(WidgetLegacyCodec)
+export const DocumentLegacy = toIOTSCodec(DocumentLegacyCodec)
+
+// Model
+export const BooleanModelSchema = toIOTS(rawBooleanModelSchema)
+export const ColorModelSchema = toIOTS(rawColorModelSchema)
+export const DateModelSchema = toIOTS(rawDateModelSchema)
+export const EmbedModelSchema = toIOTS(rawEmbedModelSchema)
+export const GeoPointModelSchema = toIOTS(rawGeoPointModelSchema)
+export const ImageModelSchema = toIOTS(rawImageModelSchema)
+export const IntegrationFieldModelSchema = toIOTS(rawIntegrationFieldModelSchema)
+export const LinkModelSchema = toIOTS(rawLinkModelSchema)
+export const NestableModelSchema = toIOTS(rawNestableModelSchema)
+export const NumberModelSchema = toIOTS(rawNumberModelSchema)
+export const RangeModelSchema = toIOTS(rawRangeModelSchema)
+export const RichTextModelSchema = toIOTS(rawRichTextModelSchema)
+export const SelectModelSchema = toIOTS(rawSelectModelSchema)
+export const SeparatorModelSchema = toIOTS(rawSeparatorModelSchema)
+export const SharedSliceModelSchema = toIOTS(rawSharedSliceModelSchema)
+export const TableModelSchema = toIOTS(rawTableModelSchema)
+export const TextModelSchema = toIOTS(rawTextModelSchema)
+export const TimestampModelSchema = toIOTS(rawTimestampModelSchema)
+export const UIDModelSchema = toIOTS(rawUIDModelSchema)
+export const GroupModelSchema = toIOTS(rawGroupModelSchema)
+export const NestedGroupModelSchema = toIOTS(rawNestedGroupModelSchema)
+export const SharedSliceRefModelSchema = toIOTS(rawSharedSliceRefModelSchema)
+export const CompositeSliceModelSchema = toIOTS(rawCompositeSliceModelSchema)
+export const LegacySliceModelSchema = toIOTS(rawLegacySliceModelSchema)
+export const DynamicSliceModelSchema = toIOTS(rawDynamicSliceModelSchema)
+export const StaticSliceModelSchema = toIOTS(rawStaticSliceModelSchema)
+export const SliceContentModelSchema = toIOTS(rawSliceContentModelSchema)
+export const DynamicSlicesModelSchema = toIOTS(rawDynamicSlicesModelSchema)
+export const StaticSlicesModelSchema = toIOTS(rawStaticSlicesModelSchema)
+export const StaticWidgetModelSchema = toIOTS(rawStaticWidgetModelSchema)
+export const DynamicWidgetModelSchema = toIOTS(rawDynamicWidgetModelSchema)
+export const StaticSectionModelSchema = toIOTS(rawStaticSectionModelSchema)
+export const DynamicSectionModelSchema = toIOTS(rawDynamicSectionModelSchema)
+export const StaticCustomTypeModelSchema = toIOTS(rawStaticCustomTypeModelSchema)
+export const CustomTypeModelSchema = toIOTS(rawCustomTypeModelSchema)
+
+function toIOTS<T>(type: ZodMiniType<T>): t.Type<T> {
+	return new t.Type<T>(
+		"Type",
+		(input): input is T => type.safeParse(input).success,
+		(input, context) => {
+			const result = type.safeParse(input)
+			return result.success
+				? t.success(result.data)
+				: t.failure(
+						input,
+						context,
+						result.error.issues.map((issue) => formatIssue(issue, input)).join("\n"),
+					)
+		},
+		t.identity,
+	)
+}
+
+function toIOTSCodec<TArgs extends unknown[], A, LegacyRaw, AllowUndefined extends boolean>(
+	codecFactory: (...args: TArgs) => LegacyCodec<A, LegacyRaw, AllowUndefined>,
+): (
+	...args: TArgs
+) => t.Type<A, ReturnType<LegacyCodec<A, LegacyRaw, AllowUndefined>["fromContent"]>, unknown> {
+	return (...args: TArgs) => {
+		const codec = codecFactory(...args)
+		return new t.Type<
+			A,
+			ReturnType<LegacyCodec<A, LegacyRaw, AllowUndefined>["fromContent"]>,
+			unknown
+		>(
+			codec.name,
+			codec.is,
+			(input, context) => {
+				const result = codec.toContent(input)
+				return result.success
+					? t.success(result.data)
+					: t.failure(
+							input,
+							context,
+							result.error.issues.map((issue) => formatIssue(issue, input)).join("\n"),
+						)
+			},
+			codec.fromContent,
+		)
+	}
+}
+
+interface ZodIssue {
+	code: string
+	message: string
+	path?: PropertyKey[]
+	expected?: string
+	values?: unknown[]
+	keys?: string[]
+}
+
+function resolveValue(input: unknown, path: PropertyKey[]): unknown {
+	let current = input
+	for (const key of path) {
+		if (current == null || typeof current !== "object") return undefined
+		current = (current as Record<PropertyKey, unknown>)[key]
+	}
+	return current
+}
+
+function formatValue(value: unknown): string {
+	if (value === null) return "null"
+	if (value === undefined) return "undefined"
+	if (typeof value === "string") return JSON.stringify(value)
+	return String(value)
+}
+
+function formatIssue(issue: ZodIssue, input: unknown): string {
+	if (issue.code === "custom" && issue.message !== "Invalid input") {
+		return issue.message
+	}
+
+	const value = resolveValue(input, issue.path ?? [])
+	const pathStr = issue.path?.length ? issue.path.join(".") : undefined
+
+	if (issue.code === "invalid_value" && issue.values) {
+		const expected = issue.values.map(formatValue).join(", ")
+		return pathStr
+			? `Invalid value ${formatValue(value)} at .${pathStr}: expected ${expected}`
+			: `Invalid value ${formatValue(value)}: expected ${expected}`
+	}
+
+	if (issue.code === "invalid_type" && issue.expected) {
+		return pathStr
+			? `Invalid value ${formatValue(value)} at .${pathStr}: expected ${issue.expected}`
+			: `Invalid value ${formatValue(value)}: expected ${issue.expected}`
+	}
+
+	if (issue.code === "unrecognized_keys" && issue.keys) {
+		return `Unrecognized key(s): ${issue.keys.join(", ")}`
+	}
+
+	return issue.message
+}

package/src/model/boolean.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/mini"
+
+const BooleanConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	default_value: z.optional(z.boolean()),
+	placeholder_true: z.optional(z.string()),
+	placeholder_false: z.optional(z.string()),
+})
+
+export const BooleanModelSchema = z.object({
+	type: z.literal("Boolean"),
+	config: z.optional(BooleanConfigSchema),
+})
+
+export type BooleanModel = z.infer<typeof BooleanModelSchema>

package/src/model/color.ts

@@ -0,0 +1,14 @@
+import { z } from "zod/mini"
+
+const ColorConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	placeholder: z.optional(z.string()),
+})
+
+export const ColorModelSchema = z.object({
+	type: z.literal("Color"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(ColorConfigSchema),
+})
+
+export type ColorModel = z.infer<typeof ColorModelSchema>

package/src/model/customType.ts

@@ -0,0 +1,26 @@
+import { z } from "zod/mini"
+
+import { DynamicSectionModelSchema, StaticSectionModelSchema } from "./section"
+
+// CustomTypeFormat - "page" | "custom"
+export const CustomTypeFormatSchema = z.enum(["page", "custom"])
+export type CustomTypeFormat = z.infer<typeof CustomTypeFormatSchema>
+
+// Factory to create CustomType schema with configurable section type
+const createCustomTypeSchema = <T extends z.ZodMiniType>(sectionSchema: T) =>
+	z.object({
+		id: z.string(),
+		label: z.nullish(z.string()),
+		repeatable: z._default(z.boolean(), true),
+		json: z.record(z.string(), sectionSchema),
+		status: z._default(z.boolean(), true),
+		format: z._default(CustomTypeFormatSchema, "custom"),
+	})
+
+// StaticCustomType - uses StaticSection (with full SharedSlice definitions)
+export const StaticCustomTypeModelSchema = createCustomTypeSchema(StaticSectionModelSchema)
+export type StaticCustomTypeModel = z.infer<typeof StaticCustomTypeModelSchema>
+
+// CustomType (dynamic) - uses DynamicSection (with SharedSliceRef references)
+export const CustomTypeModelSchema = createCustomTypeSchema(DynamicSectionModelSchema)
+export type CustomTypeModel = z.infer<typeof CustomTypeModelSchema>

package/src/model/date.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/mini"
+
+const DateConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	placeholder: z.optional(z.string()),
+	default: z.optional(z.string()),
+})
+
+export const DateModelSchema = z.object({
+	type: z.literal("Date"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(DateConfigSchema),
+})
+
+export type DateModel = z.infer<typeof DateModelSchema>

package/src/model/diff/index.ts

@@ -0,0 +1,4 @@
+export * from "./changes"
+export * from "./sharedSlice"
+export * from "./variation"
+export * from "./widgets"

package/src/{customtypes/diff/SharedSlice.ts → model/diff/sharedSlice.ts}

@@ -1,11 +1,11 @@
-import { Arrays, Objects } from "../../utils"
-import type { SharedSlice, Variation } from "../widgets/slices"
-import { type DiffChange, DiffOperation } from "./Changes"
-import { VariationComparator, VariationDiff } from "./Variation"
+import type { SharedSliceModel, SharedSliceVariation } from "../slice"
+import { type DiffChange, DiffOperation } from "./changes"
+import { isNotEmpty, toRecord, zipObjects } from "./utils"
+import { type VariationDiff, VariationComparator } from "./variation"
 
-export type SliceMetadata = Omit<SharedSlice, "variations">
+export type SliceMetadata = Omit<SharedSliceModel, "variations">
 export type SliceDiff = DiffChange<
-	SharedSlice,
+	SharedSliceModel,
 	Partial<
 		SliceMetadata & {
 			variations?: Partial<Record<string, VariationDiff>>
@@ -14,13 +14,13 @@ export type SliceDiff = DiffChange<
 >
 
 function compareSliceMeta(
-	sliceA?: SharedSlice,
-	sliceB?: SharedSlice,
+	sliceA?: SharedSliceModel,
+	sliceB?: SharedSliceModel,
 ): Partial<SliceMetadata> {
-	const zippedSlices = Objects.zipObjects(sliceA, sliceB)
+	const zippedSlices = zipObjects(sliceA, sliceB)
 
 	return Object.entries(zippedSlices).reduce((acc, [key, value]) => {
-		if (key === `variations`) return acc
+		if (key === "variations") return acc
 
 		if (value?.left === value?.right) return acc
 		return { ...acc, [key]: value?.right }
@@ -28,7 +28,7 @@ function compareSliceMeta(
 }
 
 export const SliceComparator = {
-	compare(sliceA?: SharedSlice, sliceB?: SharedSlice): SliceDiff | undefined {
+	compare(sliceA?: SharedSliceModel, sliceB?: SharedSliceModel): SliceDiff | undefined {
 		if (!sliceA && sliceB)
 			return {
 				op: DiffOperation.Added,
@@ -41,9 +41,9 @@ export const SliceComparator = {
 
 		const diffMeta = compareSliceMeta(sliceA, sliceB)
 
-		const zippedSlices = Objects.zipObjects<Variation>(
-			sliceA && Arrays.toRecord(sliceA.variations, (v) => v.id),
-			sliceB && Arrays.toRecord(sliceB.variations, (v) => v.id),
+		const zippedSlices = zipObjects<SharedSliceVariation>(
+			sliceA && toRecord(sliceA.variations, (v) => v.id),
+			sliceB && toRecord(sliceB.variations, (v) => v.id),
 		)
 
 		const diffVariations = Object.entries(zippedSlices).reduce<
@@ -61,12 +61,10 @@ export const SliceComparator = {
 
 		const diffSlice = {
 			...diffMeta,
-			...(Objects.isNotEmpty(diffVariations)
-				? { variations: diffVariations }
-				: {}),
+			...(isNotEmpty(diffVariations) ? { variations: diffVariations } : {}),
 		}
 
-		if (Objects.isNotEmpty(diffSlice)) {
+		if (isNotEmpty(diffSlice)) {
 			return {
 				op: DiffOperation.Updated,
 				value: diffSlice,

package/src/model/diff/utils.ts

@@ -0,0 +1,45 @@
+/**
+ * Zips two objects together by their keys, creating an object with
+ * both left and right values for each key.
+ */
+export function zipObjects<A, B = A>(
+	objLeft?: Partial<Record<string, A>> | undefined,
+	objRight?: Partial<Record<string, B>> | undefined,
+): Partial<Record<string, { left?: A | undefined; right?: B | undefined }>> {
+	const allKeys = [...new Set(Object.keys(objLeft || {}).concat(Object.keys(objRight || {})))]
+
+	return allKeys.reduce<Record<string, { left?: A | undefined; right?: B | undefined }>>(
+		(acc, key) => {
+			const left = objLeft?.[key]
+			const right = objRight?.[key]
+			return {
+				...acc,
+				[key]: { left, right },
+			}
+		},
+		{},
+	)
+}
+
+/**
+ * Returns true if the object has at least one key.
+ */
+export function isNotEmpty<A extends object>(obj: A): boolean {
+	return Boolean(Object.keys(obj).length)
+}
+
+/**
+ * Converts an array to a record using the provided key function.
+ */
+export function toRecord<A extends object>(
+	arr: ReadonlyArray<A>,
+	key: (obj: A) => string,
+): Record<string, A> {
+	return arr.reduce<Record<string, A>>((acc, entry) => {
+		const k = key(entry)
+		return {
+			...acc,
+			[k]: entry,
+		}
+	}, {})
+}