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

package/src/model/select.ts

@@ -0,0 +1,30 @@
+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.ZodMiniType<string> = z.union([
+	z.string(),
+	z.pipe(
+		z.number(),
+		z.transform((n) => n.toString()),
+	),
+	z.pipe(
+		z.boolean(),
+		z.transform((b) => b.toString()),
+	),
+])
+
+const SelectConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	placeholder: z.optional(z.string()),
+	default_value: z.optional(z.string()),
+	options: z.optional(z.array(SelectOptionSchema)),
+})
+
+export const SelectModelSchema = z.object({
+	type: z.literal("Select"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(SelectConfigSchema),
+})
+
+export type SelectModel = z.infer<typeof SelectModelSchema>

package/src/model/separator.ts

@@ -0,0 +1,12 @@
+import { z } from "zod/mini"
+
+const SeparatorConfigSchema = z.object({
+	label: z.nullish(z.string()),
+})
+
+export const SeparatorModelSchema = z.object({
+	type: z.literal("Separator"),
+	config: z.optional(SeparatorConfigSchema),
+})
+
+export type SeparatorModel = z.infer<typeof SeparatorModelSchema>

package/src/model/slice.ts

@@ -0,0 +1,133 @@
+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.ZodMiniType<LegacySliceModel> = z.union([
+	NestableModelSchema,
+	NestedGroupModelSchema,
+])
+
+export type LegacySliceModel = NestableModel | NestedGroupModel
+
+// Composite (2020 to 2021)
+export const CompositeSliceType = "Slice" as const
+
+const CompositeSliceConfigSchema = z.object({
+	label: z.nullish(z.string()),
+})
+
+export 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),
+})
+
+export type CompositeSliceModel = z.infer<typeof CompositeSliceModelSchema>
+
+// Shared (2021 to present)
+export const SharedSliceType = "SharedSlice" as const
+
+const IMAGE_PLACEHOLDER_URL =
+	"https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format"
+
+export const SharedSliceVariationSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string(),
+	imageUrl: z._default(z.string(), IMAGE_PLACEHOLDER_URL),
+	docURL: z.string(),
+	version: z.string(),
+	display: z.optional(z.string()),
+	primary: z.optional(
+		z.record(
+			z.string(),
+			z.union([NestableModelSchema, GroupModelSchema]) as z.ZodMiniType<
+				NestableModel | NestedGroupModel
+			>,
+		),
+	),
+	items: z.optional(z.record(z.string(), NestableModelSchema)),
+})
+
+export type SharedSliceVariation = z.infer<typeof SharedSliceVariationSchema>
+
+export 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())),
+})
+
+export type SharedSliceModel = z.infer<typeof SharedSliceModelSchema>
+
+export const SharedSliceRefModelSchema = z.object({
+	type: z.literal(SharedSliceType),
+})
+
+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 SharedSliceVariationContentModelSchema = z.object({
+	type: z.literal(SharedSliceType),
+	sliceName: z.string(),
+	variationID: z.string(),
+	fields: z.pick(SharedSliceVariationSchema, { primary: true, items: true }),
+})
+
+export type SharedSliceVariationContentModel = z.infer<
+	typeof SharedSliceVariationContentModelSchema
+>
+
+// All
+
+// Used when slices reference SharedSlice by ref (not full definition)
+export const DynamicSliceModelSchema: z.ZodMiniType<DynamicSliceModel> = z.union([
+	CompositeSliceModelSchema,
+	LegacySliceModelSchema,
+	SharedSliceRefModelSchema,
+])
+
+export type DynamicSliceModel = CompositeSliceModel | LegacySliceModel | SharedSliceRefModel
+
+// Used when slices include full SharedSlice definition
+export const StaticSliceModelSchema: z.ZodMiniType<StaticSliceModel> = z.union([
+	CompositeSliceModelSchema,
+	LegacySliceModelSchema,
+	SharedSliceModelSchema,
+])
+
+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([
+	z.literal(CompositeSliceType),
+	z.literal(SharedSliceType),
+])
+
+export type SliceModelType = z.infer<typeof SliceModelTypeSchema>

package/src/model/slices.ts

@@ -0,0 +1,54 @@
+import { z } from "zod/mini"
+
+import { WidgetKeySchema } from "../common/widgetKey"
+import { StaticSliceModelSchema, DynamicSliceModelSchema } from "./slice"
+
+export const LegacySlicesFieldType = "Choice"
+export const SlicesFieldType = "Slices"
+
+// Label configuration for slices
+const SlicesLabelSchema = z.object({
+	name: z.string(),
+	display: z.optional(z.string()),
+})
+
+export const SlicesLabelsSchema = z.union([
+	z.record(z.string(), z.array(SlicesLabelSchema)),
+	z.null(),
+])
+
+// Config
+const getSlicesConfigSchema = <
+	TSliceSchema extends typeof StaticSliceModelSchema | typeof DynamicSliceModelSchema,
+>(
+	sliceSchema: TSliceSchema,
+) =>
+	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)
+
+// Model
+const getSlicesSchema = <
+	TConfig extends typeof StaticSlicesConfigSchema | typeof DynamicSlicesConfigSchema,
+>(
+	configSchema: TConfig,
+) =>
+	z.object({
+		type: z.union([z.literal(SlicesFieldType), z.literal(LegacySlicesFieldType)]),
+		fieldset: z.nullish(z.string()),
+		config: z.optional(configSchema),
+	})
+
+export const StaticSlicesModelSchema = getSlicesSchema(StaticSlicesConfigSchema)
+
+export type StaticSlicesModel = z.infer<typeof StaticSlicesModelSchema>
+
+export const DynamicSlicesModelSchema = getSlicesSchema(DynamicSlicesConfigSchema)
+
+export type DynamicSlicesModel = z.infer<typeof DynamicSlicesModelSchema>

package/src/model/table.ts

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

package/src/model/text.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/mini"
+
+const TextConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	useAsTitle: z.optional(z.boolean()),
+	placeholder: z.optional(z.string()),
+})
+
+export const TextModelSchema = z.object({
+	type: z.literal("Text"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(TextConfigSchema),
+})
+
+export type TextModel = z.infer<typeof TextModelSchema>

package/src/model/timestamp.ts

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

package/src/model/uid.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/mini"
+
+const UIDConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	useAsTitle: z.optional(z.boolean()),
+	placeholder: z.optional(z.string()),
+})
+
+export const UIDModelSchema = z.object({
+	type: z.literal("UID"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(UIDConfigSchema),
+})
+
+export type UIDModel = z.infer<typeof UIDModelSchema>

package/src/model/widget.ts

@@ -0,0 +1,63 @@
+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.ZodMiniType<StaticWidgetModel> = z.union([
+	UIDModelSchema,
+	NestableModelSchema,
+	GroupModelSchema,
+	StaticSlicesModelSchema,
+])
+
+export type StaticWidgetModel = UIDModel | NestableModel | GroupModel | StaticSlicesModel
+
+// DynamicWidget = UID | Nestable | Group | DynamicSlices
+export const DynamicWidgetModelSchema: z.ZodMiniType<DynamicWidgetModel> = z.union([
+	UIDModelSchema,
+	NestableModelSchema,
+	GroupModelSchema,
+	DynamicSlicesModelSchema,
+])
+
+export type DynamicWidgetModel = UIDModel | NestableModel | GroupModel | DynamicSlicesModel
+
+// FieldModelType - all possible field type strings
+export 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",
+])
+
+export type FieldModelType = z.infer<typeof FieldModelTypeSchema>
+
+// Field and slice types
+export const FieldOrSliceTypeSchema = z.union([FieldModelTypeSchema, SliceModelTypeSchema])
+
+export type FieldOrSliceType = z.infer<typeof FieldOrSliceTypeSchema>

package/src/zod4.ts

@@ -0,0 +1,187 @@
+// 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 { 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 {
+	CompositeSliceContentSchema as rawCompositeSliceContentSchema,
+	LegacySliceContentSchema as rawLegacySliceContentSchema,
+	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 = toZod4(rawAssetSchema)
+export const EmbedSchema = toZod4(rawEmbedSchema)
+export const HexaColorCodeSchema = toZod4(rawHexaColorCodeSchema)
+export const NonEmptyStringSchema = toZod4(rawNonEmptyStringSchema)
+export const WidgetKeySchema = toZod4(rawWidgetKeySchema)
+
+// Content
+export const BooleanContentSchema = toZod4(rawBooleanContentSchema)
+export const ColorContentSchema = toZod4(rawColorContentSchema)
+export const DateContentSchema = toZod4(rawDateContentSchema)
+export const EmptyContentSchema = toZod4(rawEmptyContentSchema)
+export const GeoPointContentSchema = toZod4(rawGeoPointContentSchema)
+export const LinkContentSchema = toZod4(rawLinkContentSchema)
+export const NumberContentSchema = toZod4(rawNumberContentSchema)
+export const RangeContentSchema = toZod4(rawRangeContentSchema)
+export const SelectContentSchema = toZod4(rawSelectContentSchema)
+export const SeparatorContentSchema = toZod4(rawSeparatorContentSchema)
+export const SharedSliceContentSchema = toZod4(rawSharedSliceContentSchema)
+export const TextContentSchema = toZod4(rawTextContentSchema)
+export const TimestampContentSchema = toZod4(rawTimestampContentSchema)
+export const FieldContentSchema = toZod4(rawFieldContentSchema)
+export const UIDContentSchema = toZod4(rawUIDContentSchema)
+export const IntegrationFieldContentSchema = toZod4(rawIntegrationFieldContentSchema)
+export const EmbedContentSchema = toZod4(rawEmbedContentSchema)
+export const ImageContentSchema = toZod4(rawImageContentSchema)
+export const RichTextContentSchema = toZod4(rawRichTextContentSchema)
+export const RichTextContentBlockSchema = toZod4(rawRichTextContentBlockSchema)
+export const RichTextContentSpanSchema = toZod4(rawRichTextContentSpanSchema)
+export const TableContentSchema = toZod4(rawTableContentSchema)
+export const RepeatableContentSchema = toZod4(rawRepeatableContentSchema)
+export const NestableContentSchema = toZod4(rawNestableContentSchema)
+export const GroupContentSchema = toZod4(rawGroupContentSchema)
+export const GroupItemContentSchema = toZod4(rawGroupItemContentSchema)
+export const CompositeSliceContentSchema = toZod4(rawCompositeSliceContentSchema)
+export const LegacySliceContentSchema = toZod4(rawLegacySliceContentSchema)
+export const SliceContentSchema = toZod4(rawSliceContentSchema)
+export const LegacySliceItemContentSchema = toZod4(rawLegacySliceItemContentSchema)
+export const CompositeSliceItemContentSchema = toZod4(rawCompositeSliceItemContentSchema)
+export const SharedSliceItemContentSchema = toZod4(rawSharedSliceItemContentSchema)
+export const SliceItemContentSchema = toZod4(rawSliceItemContentSchema)
+export const SlicesContentSchema = toZod4(rawSlicesContentSchema)
+export const WidgetContentSchema = toZod4(rawWidgetContentSchema)
+export const DocumentContentSchema = toZod4(rawDocumentContentSchema)
+
+// Model
+export const BooleanModelSchema = toZod4(rawBooleanModelSchema)
+export const ColorModelSchema = toZod4(rawColorModelSchema)
+export const DateModelSchema = toZod4(rawDateModelSchema)
+export const EmbedModelSchema = toZod4(rawEmbedModelSchema)
+export const GeoPointModelSchema = toZod4(rawGeoPointModelSchema)
+export const ImageModelSchema = toZod4(rawImageModelSchema)
+export const IntegrationFieldModelSchema = toZod4(rawIntegrationFieldModelSchema)
+export const LinkModelSchema = toZod4(rawLinkModelSchema)
+export const NestableModelSchema = toZod4(rawNestableModelSchema)
+export const NumberModelSchema = toZod4(rawNumberModelSchema)
+export const RangeModelSchema = toZod4(rawRangeModelSchema)
+export const RichTextModelSchema = toZod4(rawRichTextModelSchema)
+export const SelectModelSchema = toZod4(rawSelectModelSchema)
+export const SeparatorModelSchema = toZod4(rawSeparatorModelSchema)
+export const SharedSliceModelSchema = toZod4(rawSharedSliceModelSchema)
+export const TableModelSchema = toZod4(rawTableModelSchema)
+export const TextModelSchema = toZod4(rawTextModelSchema)
+export const TimestampModelSchema = toZod4(rawTimestampModelSchema)
+export const UIDModelSchema = toZod4(rawUIDModelSchema)
+export const GroupModelSchema = toZod4(rawGroupModelSchema)
+export const NestedGroupModelSchema = toZod4(rawNestedGroupModelSchema)
+export const SharedSliceRefModelSchema = toZod4(rawSharedSliceRefModelSchema)
+export const CompositeSliceModelSchema = toZod4(rawCompositeSliceModelSchema)
+export const LegacySliceModelSchema = toZod4(rawLegacySliceModelSchema)
+export const DynamicSliceModelSchema = toZod4(rawDynamicSliceModelSchema)
+export const StaticSliceModelSchema = toZod4(rawStaticSliceModelSchema)
+export const SliceContentModelSchema = toZod4(rawSliceContentModelSchema)
+export const DynamicSlicesModelSchema = toZod4(rawDynamicSlicesModelSchema)
+export const StaticSlicesModelSchema = toZod4(rawStaticSlicesModelSchema)
+export const StaticWidgetModelSchema = toZod4(rawStaticWidgetModelSchema)
+export const DynamicWidgetModelSchema = toZod4(rawDynamicWidgetModelSchema)
+export const StaticSectionModelSchema = toZod4(rawStaticSectionModelSchema)
+export const DynamicSectionModelSchema = toZod4(rawDynamicSectionModelSchema)
+export const StaticCustomTypeModelSchema = toZod4(rawStaticCustomTypeModelSchema)
+export const CustomTypeModelSchema = toZod4(rawCustomTypeModelSchema)
+
+function toZod4<T>(type: T): T {
+	return type
+}

package/lib/common/Asset.d.ts

@@ -1,16 +0,0 @@
-export declare type Asset = {
-    id: string;
-    last_modified: string;
-    kind: "image" | "all";
-    filename?: string;
-    extension?: string;
-    size?: number;
-    origin_url: string;
-    url: string;
-    width?: number;
-    height?: number;
-    notes?: string;
-    credits?: string;
-    alt?: string;
-};
-export declare const getAssetOrThrow: (assets: Record<Asset["id"], Asset | undefined>) => (assetId: Asset["id"]) => Asset;

package/lib/common/Asset.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAssetOrThrow = void 0;
-const getAssetOrThrow = (assets) => (assetId) => {
-    const asset = assets[assetId];
-    if (!asset) {
-        throw new Error(`Missing asset with id '${assetId}'!`);
-    }
-    return asset;
-};
-exports.getAssetOrThrow = getAssetOrThrow;

package/lib/common/Embed.d.ts

@@ -1,15 +0,0 @@
-export declare type Embed = {
-    type: string;
-    version?: string | null;
-    author_name?: string | null;
-    author_url?: string | null;
-    provider_name?: string | null;
-    provider_url?: string | null;
-    cache_age?: string | null;
-    thumbnail_url?: string | null;
-    thumbnail_width?: number | null;
-    thumbnail_height?: number | null;
-    html?: string | null;
-    title?: string | null;
-};
-export declare const getEmbedOrThrow: (embeds: Record<string, Embed | undefined>) => (embedUrl: string) => Embed;

package/lib/common/Embed.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEmbedOrThrow = void 0;
-const getEmbedOrThrow = (embeds) => (embedUrl) => {
-    const embed = embeds[embedUrl];
-    if (!embed)
-        throw new Error(`Missing embed with url '${embedUrl}'`);
-    return embed;
-};
-exports.getEmbedOrThrow = getEmbedOrThrow;

package/lib/common/HexaColorCode.d.ts

@@ -1,4 +0,0 @@
-export declare type HexaColorCode = `#${string}`;
-export declare const HexaColor: {
-    is: (strColor: string) => strColor is `#${string}`;
-};

package/lib/common/HexaColorCode.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HexaColor = void 0;
-const hexaColorCodeRegex = /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;
-exports.HexaColor = {
-    is: (strColor) => hexaColorCodeRegex.test(strColor),
-};

package/lib/common/UUID.d.ts

@@ -1,6 +0,0 @@
-import * as t from "io-ts";
-export interface UUIDBrand {
-    readonly UUID: unique symbol;
-}
-export declare const UUID: t.BrandC<t.StringC, UUIDBrand>;
-export declare type UUID = t.TypeOf<typeof UUID>;

package/lib/common/UUID.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UUID = void 0;
-const tslib_1 = require("tslib");
-const t = (0, tslib_1.__importStar)(require("io-ts"));
-const uuid_1 = require("uuid");
-const function_1 = require("../validators/function");
-exports.UUID = (0, function_1.withCustomError)(t.brand(t.string, (s) => (0, uuid_1.validate)(s), "UUID"), () => "The value must be a valid UUID");

package/lib/common/WidgetKey.d.ts

@@ -1,3 +0,0 @@
-import * as t from "io-ts";
-export declare const WidgetKey: t.Type<string, string, unknown>;
-export declare type WidgetKey = t.TypeOf<typeof WidgetKey>;

package/lib/common/WidgetKey.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WidgetKey = void 0;
-const tslib_1 = require("tslib");
-const t = (0, tslib_1.__importStar)(require("io-ts"));
-const function_1 = require("../validators/function");
-const widgetKeyRegex = new RegExp("^[^<>]+$");
-exports.WidgetKey = (0, function_1.refineType)(t.string, "WidgetKey", (s) => s.length === 0 || widgetKeyRegex.test(s));

package/lib/common/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./Asset";
-export * from "./Embed";
-export * from "./WidgetKey";