@prismicio/types-internal 4.0.0 → 4.1.0-canary.18ae460

package/src/helpers/customTypeModel.ts

@@ -67,3 +67,47 @@ export function collectSharedSlices(
 
 	return sharedSlices
 }
+
+export function filterMissingSharedSlices<
+	TCustomType extends StaticCustomTypeModel | CustomTypeModel,
+>(
+	customType: TCustomType,
+	sharedSlices: Map<string, SharedSliceModel> | Record<string, SharedSliceModel>,
+): TCustomType {
+	const json: TCustomType["json"] = {}
+
+	const sharedSlicesMap =
+		sharedSlices instanceof Map ? sharedSlices : new Map(Object.entries(sharedSlices))
+
+	for (const [tabKey, tab] of Object.entries(customType.json)) {
+		const tabJSON: typeof tab = {}
+		for (const [key, widget] of Object.entries(tab)) {
+			switch (widget.type) {
+				case "Slices":
+				case "Choice":
+					const choices: Required<typeof widget>["config"]["choices"] = {}
+					for (const [id, model] of Object.entries(widget.config?.choices || {})) {
+						if (model.type === "SharedSlice") {
+							if (sharedSlicesMap.get(id)) {
+								choices[id] = model
+							}
+						} else {
+							choices[id] = model
+						}
+					}
+
+					tabJSON[key] = {
+						...widget,
+						config: { ...widget.config, choices },
+					}
+					break
+				default:
+					tabJSON[key] = widget
+			}
+		}
+
+		json[tabKey] = tabJSON
+	}
+
+	return { ...customType, json }
+}

package/src/helpers/imageContent.ts

@@ -0,0 +1,84 @@
+import type { ImageContent, ImageContentView } from "../content/image"
+
+export interface CroppedImage {
+	zoom: number
+	/** X coordinate of the crop rect on the original image */
+	x: number
+	/** Y coordinate of the crop rect on the original image */
+	y: number
+
+	/** The width of the crop rect over the original image */
+	cropWidth: number
+	/** The height of the crop rect over the original image */
+	cropHeight: number
+
+	/** Final (user defined via W input) width of the image */
+	width: number
+	/** Final (user defined via H input) height of the image */
+	height: number
+}
+
+export function buildCropURL(args: {
+	origin: ImageContent["origin"]
+	croppedImage: CroppedImage
+}): string {
+	const { origin, croppedImage } = args
+	const { x, y, width, height, cropHeight, cropWidth } = croppedImage
+
+	const url = new URL(origin.url)
+
+	const hasResize = origin.height !== height || origin.width !== width
+
+	const hasCrop = x !== 0 || y !== 0 || cropHeight !== origin.height || cropWidth !== origin.width
+
+	if (hasCrop) {
+		const crop = [x, y, cropWidth, cropHeight].map(Math.round).join(",")
+
+		url.searchParams.set("rect", crop)
+		url.searchParams.set("w", width.toString())
+		url.searchParams.set("h", height.toString())
+	}
+
+	if (hasResize) {
+		url.searchParams.set("w", width.toString())
+		url.searchParams.set("h", height.toString())
+	}
+
+	return url.toString()
+}
+
+export function getCroppedImage({ contentView }: { contentView: ImageContentView }): CroppedImage {
+	const {
+		edit: {
+			crop: { x, y },
+			zoom,
+		},
+		width,
+		height,
+		origin: { width: originWidth, height: originHeight },
+	} = contentView
+
+	let cropWidth
+	let cropHeight
+	const originAspect = originWidth / originHeight
+	const cropAspect = width / height
+	if (cropAspect >= originAspect) {
+		// crop and origin image would be the same width if zoom was equal to 1
+		cropWidth = originWidth / zoom
+		cropHeight = cropWidth / cropAspect
+	} else {
+		// crop and origin image would be the same height if zoom was equal to 1
+		cropHeight = originHeight / zoom
+		cropWidth = cropHeight * cropAspect
+	}
+
+	return {
+		x,
+		y,
+		width,
+		height,
+		zoom,
+		cropWidth,
+		cropHeight,
+	}
+}

package/src/helpers/traverseContent.ts

@@ -332,7 +332,10 @@ export function traverseLegacySliceContent(
 		}
 	} else {
 		if (model?.type === "SharedSlice") {
-			legacySliceModel = model.fields.primary?.[content.name]
+			const primaryModel = model.fields.primary?.[content.name]
+			if (primaryModel?.type !== "Group") {
+				legacySliceModel = primaryModel
+			}
 		} else if (model?.type !== "Group") {
 			legacySliceModel = model
 		}

package/src/helpers/withDefaultContent.ts

@@ -0,0 +1,180 @@
+import { BooleanContentType } from "../content/boolean"
+import type { DocumentContent } from "../content/document"
+import { FieldContentType, SelectFieldType } from "../content/field"
+import type { GroupContent, GroupItemContent } from "../content/group"
+import { GroupContentType } from "../content/group"
+import type { SliceContent } from "../content/slice"
+import { CompositeSliceContentType, SharedSliceContentType } from "../content/slice"
+import type { SlicesContent } from "../content/slices"
+import { SlicesContentType } from "../content/slices"
+import type { WidgetContent } from "../content/widget"
+import type { StaticCustomTypeModel } from "../model/customType"
+import type { GroupModel } from "../model/group"
+import type { NestableModel } from "../model/nestable"
+import type { StaticSliceModel } from "../model/slice"
+import type { StaticWidgetModel } from "../model/widget"
+import * as customTypeModel from "./customTypeModel"
+
+export function document(content: DocumentContent, model: StaticCustomTypeModel): DocumentContent {
+	return record(content, customTypeModel.flatten(model))
+}
+
+export function slice(content: SliceContent, model: StaticSliceModel | undefined): SliceContent {
+	if (!model) {
+		return content
+	}
+
+	if (model.type === "SharedSlice") {
+		if (content.__TYPE__ !== SharedSliceContentType) {
+			return content
+		}
+
+		const variation = model.variations.find((variation) => variation.id === content.variation)
+		if (!variation) {
+			return content
+		}
+
+		return {
+			...content,
+			primary: record(content.primary, variation?.primary),
+			items: items(content.items, variation?.items),
+		}
+	}
+
+	if (model.type === "Slice") {
+		if (content.__TYPE__ !== CompositeSliceContentType) {
+			return content
+		}
+
+		return {
+			...content,
+			nonRepeat: record(content.nonRepeat, model["non-repeat"]),
+			repeat: items(content.repeat, model.repeat),
+		}
+	}
+
+	if (
+		content.__TYPE__ === SharedSliceContentType ||
+		content.__TYPE__ === CompositeSliceContentType
+	) {
+		return content
+	}
+
+	return widget(content, model)
+}
+
+export function widget<TContent extends WidgetContent | undefined>(
+	content: TContent,
+	model: StaticWidgetModel | undefined,
+): TContent {
+	if (!model) {
+		return content
+	}
+
+	if (
+		(model.type === "Slices" || model.type === "Choice") &&
+		content?.__TYPE__ === SlicesContentType
+	) {
+		if (!model.config?.choices) return content
+
+		const value: SlicesContent["value"] = []
+		for (const sliceItem of content.value) {
+			value.push({
+				...sliceItem,
+				widget: slice(sliceItem.widget, model.config.choices[sliceItem.name]),
+			})
+		}
+
+		return { ...content, value }
+	}
+
+	if (model.type === "Group") {
+		if (content?.__TYPE__ !== GroupContentType) {
+			return <TContent>{
+				__TYPE__: GroupContentType,
+				value: items([], model.config?.fields),
+			}
+		}
+
+		return { ...content, value: items(content.value, model.config?.fields) }
+	}
+
+	if (model.type === "Boolean" && !content) {
+		if (model.config?.default_value === undefined) {
+			return <TContent>undefined
+		}
+
+		return <TContent>{
+			__TYPE__: BooleanContentType,
+			value: model.config.default_value,
+		}
+	}
+
+	if (model.type === "Select" && !content) {
+		if (!model.config?.default_value) {
+			return <TContent>undefined
+		}
+
+		return <TContent>{
+			__TYPE__: FieldContentType,
+			type: SelectFieldType,
+			value: model.config.default_value,
+		}
+	}
+
+	return content
+}
+
+export function items(
+	items: GroupContent["value"],
+	fields: Record<string, GroupModel | NestableModel> | undefined,
+): GroupContent["value"] {
+	if (!fields) {
+		return items
+	}
+
+	const itemsWithDefaults: GroupContent["value"] = []
+	for (const item of items) {
+		const itemValue: GroupItemContent["value"] = []
+
+		const missingFields = { ...fields }
+		for (const [key, value] of item.value) {
+			delete missingFields[key]
+			itemValue.push([key, widget(value, fields[key])])
+		}
+		for (const [key, field] of Object.entries(missingFields)) {
+			const content = widget(undefined, field)
+			if (content) {
+				itemValue.push([key, content])
+			}
+		}
+
+		itemsWithDefaults.push({ ...item, value: itemValue })
+	}
+
+	return itemsWithDefaults
+}
+
+function record<TContent extends WidgetContent>(
+	record: Record<string, TContent>,
+	fields: Record<string, StaticWidgetModel> | undefined,
+): Record<string, TContent> {
+	if (!fields) {
+		return record
+	}
+
+	const missingFields = { ...fields }
+	const recordWithDefaults: Record<string, TContent> = {}
+	for (const [key, value] of Object.entries(record)) {
+		delete missingFields[key]
+		recordWithDefaults[key] = widget(value, fields[key])
+	}
+	for (const [key, field] of Object.entries(missingFields)) {
+		const content = widget(undefined, field)
+		if (content) {
+			recordWithDefaults[key] = content
+		}
+	}
+
+	return recordWithDefaults
+}

package/src/index.ts

@@ -22,12 +22,21 @@ export type {
 } from "./content/field"
 export type { GeoPointContent } from "./content/geopoint"
 export type { GroupContent, GroupItemContent } from "./content/group"
-export type { ImageContent } from "./content/image"
+export type { ImageContent, ImageContentView } from "./content/image"
 export type { IntegrationFieldContent } from "./content/integrationField"
-export type { LinkContent } from "./content/link"
+export type { EmptyLinkContent, FilledLinkContent, 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 {
+	RichTextContent,
+	RichTextContentBlock,
+	RichTextContentTextBlock,
+	RichTextContentImageBlock,
+	RichTextContentEmbedBlock,
+	RichTextContentSpan,
+	RichTextNodeTypes,
+} from "./content/richText"
+export { RichTextNodeType } from "./content/richText"
 export type { SeparatorContent } from "./content/separator"
 export type {
 	LegacySliceContent,
@@ -60,7 +69,8 @@ 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 { RichTextModel, RichTextModelNodeTypes } from "./model/richText"
+export { RichTextModelNodeType } from "./model/richText"
 export type { StaticSectionModel, DynamicSectionModel } from "./model/section"
 export type { SelectModel } from "./model/select"
 export type { SeparatorModel } from "./model/separator"
@@ -69,7 +79,8 @@ export type {
 	CompositeSliceModel,
 	SharedSliceModel,
 	SharedSliceRefModel,
-	SharedSliceVariationContentModel as SharedSliceVariationModel,
+	SharedSliceModelVariation,
+	SharedSliceVariationContentModel,
 	StaticSliceModel,
 	DynamicSliceModel,
 	SliceContentModel,
@@ -91,6 +102,8 @@ 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 * as withDefaultContent from "./helpers/withDefaultContent"
+export * as imageContent from "./helpers/imageContent"
 export {
 	traverseDocumentContent,
 	traverseSlicesContent,

package/src/io-ts.ts

@@ -60,9 +60,16 @@ import {
 	GroupContentSchema as rawGroupContentSchema,
 	GroupItemContentSchema as rawGroupItemContentSchema,
 } from "./content/group"
-import { ImageContentSchema as rawImageContentSchema } from "./content/image"
+import {
+	ImageContentSchema as rawImageContentSchema,
+	ImageContentViewSchema as rawImageContentViewSchema,
+} from "./content/image"
 import { IntegrationFieldContentSchema as rawIntegrationFieldContentSchema } from "./content/integrationField"
-import { LinkContentSchema as rawLinkContentSchema } from "./content/link"
+import {
+	EmptyLinkContentSchema as rawEmptyLinkContentSchema,
+	FilledLinkContentSchema as rawFilledLinkContentSchema,
+	LinkContentSchema as rawLinkContentSchema,
+} from "./content/link"
 import { NestableContentSchema as rawNestableContentSchema } from "./content/nestable"
 import { RepeatableContentSchema as rawRepeatableContentSchema } from "./content/repeatable"
 import {
@@ -118,6 +125,7 @@ import {
 	LegacySliceModelSchema as rawLegacySliceModelSchema,
 	CompositeSliceModelSchema as rawCompositeSliceModelSchema,
 	SharedSliceModelSchema as rawSharedSliceModelSchema,
+	SharedSliceModelVariationSchema as rawSharedSliceModelVariationSchema,
 	SharedSliceRefModelSchema as rawSharedSliceRefModelSchema,
 	StaticSliceModelSchema as rawStaticSliceModelSchema,
 	DynamicSliceModelSchema as rawDynamicSliceModelSchema,
@@ -149,6 +157,8 @@ export const ColorContentSchema = toIOTS(rawColorContentSchema)
 export const DateContentSchema = toIOTS(rawDateContentSchema)
 export const EmptyContentSchema = toIOTS(rawEmptyContentSchema)
 export const GeoPointContentSchema = toIOTS(rawGeoPointContentSchema)
+export const FilledLinkContentSchema = toIOTS(rawFilledLinkContentSchema)
+export const EmptyLinkContentSchema = toIOTS(rawEmptyLinkContentSchema)
 export const LinkContentSchema = toIOTS(rawLinkContentSchema)
 export const NumberContentSchema = toIOTS(rawNumberContentSchema)
 export const RangeContentSchema = toIOTS(rawRangeContentSchema)
@@ -161,6 +171,7 @@ export const FieldContentSchema = toIOTS(rawFieldContentSchema)
 export const UIDContentSchema = toIOTS(rawUIDContentSchema)
 export const IntegrationFieldContentSchema = toIOTS(rawIntegrationFieldContentSchema)
 export const EmbedContentSchema = toIOTS(rawEmbedContentSchema)
+export const ImageContentViewSchema = toIOTS(rawImageContentViewSchema)
 export const ImageContentSchema = toIOTS(rawImageContentSchema)
 export const RichTextContentSchema = toIOTS(rawRichTextContentSchema)
 export const RichTextContentBlockSchema = toIOTS(rawRichTextContentBlockSchema)
@@ -235,6 +246,7 @@ export const TimestampModelSchema = toIOTS(rawTimestampModelSchema)
 export const UIDModelSchema = toIOTS(rawUIDModelSchema)
 export const GroupModelSchema = toIOTS(rawGroupModelSchema)
 export const NestedGroupModelSchema = toIOTS(rawNestedGroupModelSchema)
+export const SharedSliceModelVariationSchema = toIOTS(rawSharedSliceModelVariationSchema)
 export const SharedSliceRefModelSchema = toIOTS(rawSharedSliceRefModelSchema)
 export const CompositeSliceModelSchema = toIOTS(rawCompositeSliceModelSchema)
 export const LegacySliceModelSchema = toIOTS(rawLegacySliceModelSchema)

package/src/model/diff/sharedSlice.ts

@@ -1,4 +1,4 @@
-import type { SharedSliceModel, SharedSliceVariation } from "../slice"
+import type { SharedSliceModel, SharedSliceModelVariation } from "../slice"
 import { type DiffChange, DiffOperation } from "./changes"
 import { isNotEmpty, toRecord, zipObjects } from "./utils"
 import { type VariationDiff, VariationComparator } from "./variation"
@@ -41,7 +41,7 @@ export const SliceComparator = {
 
 		const diffMeta = compareSliceMeta(sliceA, sliceB)
 
-		const zippedSlices = zipObjects<SharedSliceVariation>(
+		const zippedSlices = zipObjects<SharedSliceModelVariation>(
 			sliceA && toRecord(sliceA.variations, (v) => v.id),
 			sliceB && toRecord(sliceB.variations, (v) => v.id),
 		)

package/src/model/diff/variation.ts

@@ -1,7 +1,7 @@
 import type { GroupModel } from "../group"
 import { GroupFieldType } from "../group"
 import type { NestableModel } from "../nestable"
-import type { SharedSliceVariation } from "../slice"
+import type { SharedSliceModelVariation } from "../slice"
 import { type DiffChange, DiffOperation } from "./changes"
 import { isNotEmpty, zipObjects } from "./utils"
 import type {
@@ -10,9 +10,9 @@ import type {
 	SlicePrimaryWidgetDiff,
 } from "./widgets"
 
-export type VariationMetadata = Omit<SharedSliceVariation, "primary" | "items">
+export type VariationMetadata = Omit<SharedSliceModelVariation, "primary" | "items">
 export type VariationDiff = DiffChange<
-	SharedSliceVariation,
+	SharedSliceModelVariation,
 	Partial<VariationMetadata> & {
 		primary?: Record<string, SlicePrimaryWidgetDiff>
 		items?: Record<string, NestableWidgetDiff>
@@ -20,8 +20,8 @@ export type VariationDiff = DiffChange<
 >
 
 function compareVariationMeta(
-	variationA?: SharedSliceVariation,
-	variationB?: SharedSliceVariation,
+	variationA?: SharedSliceModelVariation,
+	variationB?: SharedSliceModelVariation,
 ): Partial<VariationMetadata> {
 	const zippedVariations = zipObjects(variationA, variationB)
 
@@ -119,8 +119,8 @@ function compareWidgets<TWidget extends NestableModel | GroupModel>(
 
 export const VariationComparator = {
 	compare(
-		variationA?: SharedSliceVariation,
-		variationB?: SharedSliceVariation,
+		variationA?: SharedSliceModelVariation,
+		variationB?: SharedSliceModelVariation,
 	): VariationDiff | undefined {
 		if (variationA && !variationB)
 			return {

package/src/model/richText.ts

@@ -6,7 +6,7 @@ export const RichTextFieldType = "StructuredText"
 
 export const DEFAULT_OPTION = "paragraph"
 
-export const RichTextNodeType = {
+export const RichTextModelNodeType = {
 	heading1: "heading1",
 	heading2: "heading2",
 	heading3: "heading3",
@@ -25,7 +25,10 @@ export const RichTextNodeType = {
 	rtl: "rtl",
 } as const
 
-const VALID_NODE_TYPES = Object.values(RichTextNodeType)
+export type RichTextModelNodeTypes =
+	(typeof RichTextModelNodeType)[keyof typeof RichTextModelNodeType]
+
+const VALID_NODE_TYPES = Object.values(RichTextModelNodeType)
 
 /**
  * RichTextOptions parses comma-separated node types, filters invalid ones,

package/src/model/slice.ts

@@ -1,7 +1,7 @@
 import { z } from "zod/mini"
 
 import { WidgetKeySchema } from "../common/widgetKey"
-import type { NestedGroupModel } from "./group"
+import type { GroupModel, NestedGroupModel } from "./group"
 import { GroupModelSchema, NestedGroupModelSchema } from "./group"
 import type { NestableModel } from "./nestable"
 import { NestableModelSchema } from "./nestable"
@@ -40,7 +40,7 @@ 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({
+export const SharedSliceModelVariationSchema = z.object({
 	id: z.string(),
 	name: z.string(),
 	description: z.string(),
@@ -51,21 +51,19 @@ export const SharedSliceVariationSchema = z.object({
 	primary: z.optional(
 		z.record(
 			z.string(),
-			z.union([NestableModelSchema, GroupModelSchema]) as z.ZodMiniType<
-				NestableModel | NestedGroupModel
-			>,
+			z.union([NestableModelSchema, GroupModelSchema]) as z.ZodMiniType<NestableModel | GroupModel>,
 		),
 	),
 	items: z.optional(z.record(z.string(), NestableModelSchema)),
 })
 
-export type SharedSliceVariation = z.infer<typeof SharedSliceVariationSchema>
+export type SharedSliceModelVariation = z.infer<typeof SharedSliceModelVariationSchema>
 
 export const SharedSliceModelSchema = z.object({
 	id: z.string(),
 	type: z.literal(SharedSliceType),
 	name: z.string(),
-	variations: z.array(SharedSliceVariationSchema),
+	variations: z.array(SharedSliceModelVariationSchema),
 	description: z.optional(z.string()),
 	legacyPaths: z.optional(z.record(z.string(), z.string())),
 })
@@ -84,7 +82,7 @@ export const SharedSliceVariationContentModelSchema = z.object({
 	type: z.literal(SharedSliceType),
 	sliceName: z.string(),
 	variationID: z.string(),
-	fields: z.pick(SharedSliceVariationSchema, { primary: true, items: true }),
+	fields: z.pick(SharedSliceModelVariationSchema, { primary: true, items: true }),
 })
 
 export type SharedSliceVariationContentModel = z.infer<

package/src/model/table.ts

@@ -1,6 +1,6 @@
 import { z } from "zod/mini"
 
-import { RichTextNodeType, type RichTextModel } from "./richText"
+import { RichTextModelNodeType, type RichTextModel } from "./richText"
 
 const TableConfigSchema = z.object({
 	label: z.nullish(z.string()),
@@ -15,10 +15,10 @@ 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,
+	RichTextModelNodeType.paragraph,
+	RichTextModelNodeType.strong,
+	RichTextModelNodeType.em,
+	RichTextModelNodeType.hyperlink,
 ]
 
 export const TableCellModel: RichTextModel = {

package/src/model/widget.ts

@@ -46,7 +46,6 @@ export const FieldModelTypeSchema = z.enum([
 	"Text",
 	"Timestamp",
 	"Link",
-	"Repeatable.Link",
 	"Image",
 	"IntegrationFields",
 	"UID",
@@ -58,6 +57,11 @@ export const FieldModelTypeSchema = z.enum([
 export type FieldModelType = z.infer<typeof FieldModelTypeSchema>
 
 // Field and slice types
-export const FieldOrSliceTypeSchema = z.union([FieldModelTypeSchema, SliceModelTypeSchema])
+export const FieldOrSliceTypeSchema = z.union([
+	FieldModelTypeSchema,
+	SliceModelTypeSchema,
+	// Repeatable links are "meta" types like slices and shared slices
+	z.literal("Repeatable.Link"),
+])
 
 export type FieldOrSliceType = z.infer<typeof FieldOrSliceTypeSchema>

package/src/zod4.ts

@@ -24,9 +24,16 @@ import {
 	GroupContentSchema as rawGroupContentSchema,
 	GroupItemContentSchema as rawGroupItemContentSchema,
 } from "./content/group"
-import { ImageContentSchema as rawImageContentSchema } from "./content/image"
+import {
+	ImageContentSchema as rawImageContentSchema,
+	ImageContentViewSchema as rawImageContentViewSchema,
+} from "./content/image"
 import { IntegrationFieldContentSchema as rawIntegrationFieldContentSchema } from "./content/integrationField"
-import { LinkContentSchema as rawLinkContentSchema } from "./content/link"
+import {
+	EmptyLinkContentSchema as rawEmptyLinkContentSchema,
+	FilledLinkContentSchema as rawFilledLinkContentSchema,
+	LinkContentSchema as rawLinkContentSchema,
+} from "./content/link"
 import { NestableContentSchema as rawNestableContentSchema } from "./content/nestable"
 import { RepeatableContentSchema as rawRepeatableContentSchema } from "./content/repeatable"
 import {
@@ -82,6 +89,7 @@ import {
 	LegacySliceModelSchema as rawLegacySliceModelSchema,
 	CompositeSliceModelSchema as rawCompositeSliceModelSchema,
 	SharedSliceModelSchema as rawSharedSliceModelSchema,
+	SharedSliceModelVariationSchema as rawSharedSliceModelVariationSchema,
 	SharedSliceRefModelSchema as rawSharedSliceRefModelSchema,
 	StaticSliceModelSchema as rawStaticSliceModelSchema,
 	DynamicSliceModelSchema as rawDynamicSliceModelSchema,
@@ -113,6 +121,8 @@ export const ColorContentSchema = toZod4(rawColorContentSchema)
 export const DateContentSchema = toZod4(rawDateContentSchema)
 export const EmptyContentSchema = toZod4(rawEmptyContentSchema)
 export const GeoPointContentSchema = toZod4(rawGeoPointContentSchema)
+export const FilledLinkContentSchema = toZod4(rawFilledLinkContentSchema)
+export const EmptyLinkContentSchema = toZod4(rawEmptyLinkContentSchema)
 export const LinkContentSchema = toZod4(rawLinkContentSchema)
 export const NumberContentSchema = toZod4(rawNumberContentSchema)
 export const RangeContentSchema = toZod4(rawRangeContentSchema)
@@ -125,6 +135,7 @@ export const FieldContentSchema = toZod4(rawFieldContentSchema)
 export const UIDContentSchema = toZod4(rawUIDContentSchema)
 export const IntegrationFieldContentSchema = toZod4(rawIntegrationFieldContentSchema)
 export const EmbedContentSchema = toZod4(rawEmbedContentSchema)
+export const ImageContentViewSchema = toZod4(rawImageContentViewSchema)
 export const ImageContentSchema = toZod4(rawImageContentSchema)
 export const RichTextContentSchema = toZod4(rawRichTextContentSchema)
 export const RichTextContentBlockSchema = toZod4(rawRichTextContentBlockSchema)
@@ -167,6 +178,7 @@ export const TimestampModelSchema = toZod4(rawTimestampModelSchema)
 export const UIDModelSchema = toZod4(rawUIDModelSchema)
 export const GroupModelSchema = toZod4(rawGroupModelSchema)
 export const NestedGroupModelSchema = toZod4(rawNestedGroupModelSchema)
+export const SharedSliceModelVariationSchema = toZod4(rawSharedSliceModelVariationSchema)
 export const SharedSliceRefModelSchema = toZod4(rawSharedSliceRefModelSchema)
 export const CompositeSliceModelSchema = toZod4(rawCompositeSliceModelSchema)
 export const LegacySliceModelSchema = toZod4(rawLegacySliceModelSchema)