@prismicio/types-internal 4.0.0-pr.6.bf36d5e → 4.0.0-pr.6.cba77ba

package/src/content/legacy/link.ts

@@ -109,16 +109,20 @@ export const AnyLinkLegacySchema = z.strictObject({
 
 // All
 
-export const FilledLinkValueLegacySchema = z.union([
+export const FilledLinkValueLegacySchema: z.ZodMiniType<FilledLinkValueLegacy> = z.union([
 	FilledImageLinkValueLegacySchema,
 	FilledFileLinkValueLegacySchema,
 	FilledDocumentLinkValueLegacySchema,
 	FilledExternalLinkValueLegacySchema,
 ])
 
-export type FilledLinkValueLegacy = z.infer<typeof FilledLinkValueLegacySchema>
+type FilledImageLinkValueLegacy = z.infer<typeof FilledImageLinkValueLegacySchema>
+type FilledFileLinkValueLegacy = z.infer<typeof FilledFileLinkValueLegacySchema>
+type FilledDocumentLinkValueLegacy = z.infer<typeof FilledDocumentLinkValueLegacySchema>
+type FilledExternalLinkValueLegacy = z.infer<typeof FilledExternalLinkValueLegacySchema>
+export type FilledLinkValueLegacy = FilledImageLinkValueLegacy | FilledFileLinkValueLegacy | FilledDocumentLinkValueLegacy | FilledExternalLinkValueLegacy
 
-const EmptyLinkValueLegacySchema = z.union([
+const EmptyLinkValueLegacySchema: z.ZodMiniType<EmptyLinkValueLegacy> = z.union([
 	EmptyImageLinkValueLegacySchema,
 	EmptyFileLinkValueLegacySchema,
 	EmptyMediaLinkValueLegacySchema,
@@ -127,11 +131,20 @@ const EmptyLinkValueLegacySchema = z.union([
 	AnyLinkLegacySchema,
 ])
 
-export type EmptyLinkValueLegacy = z.infer<typeof EmptyLinkValueLegacySchema>
+type EmptyImageLinkValueLegacy = z.infer<typeof EmptyImageLinkValueLegacySchema>
+type EmptyFileLinkValueLegacy = z.infer<typeof EmptyFileLinkValueLegacySchema>
+type EmptyMediaLinkValueLegacy = z.infer<typeof EmptyMediaLinkValueLegacySchema>
+type EmptyDocumentLinkValueLegacy = z.infer<typeof EmptyDocumentLinkValueLegacySchema>
+type EmptyExternalLinkValueLegacy = z.infer<typeof EmptyExternalLinkValueLegacySchema>
+type AnyLinkLegacy = z.infer<typeof AnyLinkLegacySchema>
+export type EmptyLinkValueLegacy = EmptyImageLinkValueLegacy | EmptyFileLinkValueLegacy | EmptyMediaLinkValueLegacy | EmptyDocumentLinkValueLegacy | EmptyExternalLinkValueLegacy | AnyLinkLegacy
 
-const LinkValueLegacySchema = z.union([FilledLinkValueLegacySchema, EmptyLinkValueLegacySchema])
+const LinkValueLegacySchema: z.ZodMiniType<LinkValueLegacy> =
+	z.union([FilledLinkValueLegacySchema, EmptyLinkValueLegacySchema])
 
-export type LinkValueLegacy = z.infer<typeof LinkValueLegacySchema>
+export type LinkValueLegacy =
+	| FilledLinkValueLegacy
+	| EmptyLinkValueLegacy
 
 // We cannot use z.extend here because we're working with unions.
 // z.intersection wouldn't work also for the same reason.
@@ -157,7 +170,7 @@ export const LinkLegacySchema = z.pipe(
 			key: z.optional(z.string()),
 			text: z.optional(z.string()),
 			variant: z.optional(z.string()),
-			value: LinkValueLegacySchema,
+			value: LinkValueLegacySchema as z.ZodMiniType<LinkValueLegacy, Record<string, unknown>>,
 		}),
 	),
 	z.transform(({ key, text, variant, value }) => ({

package/src/content/legacy/nestable.ts

@@ -1,19 +1,30 @@
 import { z } from "zod/mini"
 
+import type { BooleanLegacy} from "./boolean";
 import { BooleanLegacySchema } from "./boolean"
+import type { EmbedLegacy} from "./embed";
 import { EmbedLegacyLooseSchema } from "./embed"
+import type { EmptyLegacy} from "./empty";
 import { EmptyLegacySchema } from "./empty"
 import { StringLegacySchema } from "./field"
+import type { GeoPointLegacy} from "./geopoint";
 import { GeoPointLegacySchema } from "./geopoint"
+import type { ImageLegacy} from "./image";
 import { ImageLegacySchema } from "./image"
+import type { IntegrationFieldLegacy} from "./integrationField";
 import { IntegrationFieldLegacySchema } from "./integrationField"
+import type { LinkLegacy} from "./link";
 import { LinkLegacySchema } from "./link"
+import type { RepeatableLegacy} from "./repeatable";
 import { RepeatableLegacySchema } from "./repeatable"
+import type { RichTextLegacy} from "./richText";
 import { RichTextLegacySchema } from "./richText"
+import type { SeparatorLegacy} from "./separator";
 import { SeparatorLegacySchema } from "./separator"
+import type { TableLegacy} from "./table";
 import { TableLegacySchema } from "./table"
 
-export const NestableLegacySchema = z.union([
+export const NestableLegacySchema: z.ZodMiniType<NestableLegacy> = z.union([
 	EmptyLegacySchema,
 	BooleanLegacySchema,
 	EmbedLegacyLooseSchema,
@@ -28,4 +39,4 @@ export const NestableLegacySchema = z.union([
 	TableLegacySchema,
 ])
 
-export type NestableLegacy = z.infer<typeof NestableLegacySchema>
+export type NestableLegacy = EmptyLegacy | BooleanLegacy | EmbedLegacy | GeoPointLegacy | ImageLegacy | IntegrationFieldLegacy | LinkLegacy | RepeatableLegacy | RichTextLegacy | SeparatorLegacy | TableLegacy

package/src/content/legacy/richText.ts

@@ -4,10 +4,11 @@ import { z } from "zod/mini"
 // avoid runtime circular dependencies!
 import type { EmbedContentSchema } from "../embed"
 import type { ImageViewContentSchema } from "../image"
-import type { FilledLinkValueContentSchema } from "../link"
+import type { FilledLinkValueContent, FilledLinkValueContentSchema } from "../link"
 import { EmbedLegacyLooseSchema } from "./embed"
 import { ImageViewLegacySchema } from "./image"
 import { FilledLinkValueLegacySchema } from "./link"
+import type { FilledLinkValueLegacy } from "./link"
 
 export const RichTextNodeType = {
 	paragraph: "paragraph",
@@ -28,6 +29,13 @@ export const RichTextNodeType = {
 } as const
 
 // Spans
+type HyperlinkSpan<TData extends FilledLinkValueLegacy | FilledLinkValueContent> = {
+	type: typeof RichTextNodeType.hyperlink
+	start: number
+	end: number
+	data: TData
+}
+
 const getHyperlinkSpanSchema = <
 	TData extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,
 >(
@@ -40,7 +48,14 @@ const getHyperlinkSpanSchema = <
 		data,
 	})
 
-const LabelSpanSchema = z.object({
+type LabelSpan = {
+	type: "label"
+	start: number
+	end: number
+	data: string
+}
+
+const LabelSpanSchema: z.ZodMiniType<LabelSpan> = z.object({
 	type: z.literal("label"),
 	start: z.number(),
 	end: z.number(),
@@ -50,7 +65,13 @@ const LabelSpanSchema = z.object({
 	),
 })
 
-const BasicSpanSchema = z.object({
+type BasicSpan = {
+	type: typeof RichTextNodeType.strong | typeof RichTextNodeType.em | "list-item"
+	start: number
+	end: number
+}
+
+const BasicSpanSchema: z.ZodMiniType<BasicSpan> = z.object({
 	type: z.union([
 		z.literal(RichTextNodeType.strong),
 		z.literal(RichTextNodeType.em),
@@ -60,7 +81,11 @@ const BasicSpanSchema = z.object({
 	end: z.number(),
 })
 
-const getSpanSchema = <
+export type Span<TLink extends FilledLinkValueLegacy | FilledLinkValueContent> =
+	HyperlinkSpan<TLink> | LabelSpan | BasicSpan
+
+// oxlint-disable-next-line explicit-module-boundary-types
+export const getSpanSchema = <
 	TLinkSchema extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,
 >(
 	linkSchema: TLinkSchema,
@@ -113,6 +138,8 @@ export const getTextBlockSchema = <
 
 const TextBlockLegacySchema = getTextBlockSchema(FilledLinkValueLegacySchema)
 
+type TextBlockLegacy = z.infer<typeof TextBlockLegacySchema>
+
 // Image block
 
 // oxlint-disable-next-line explicit-module-boundary-types
@@ -135,6 +162,8 @@ const ImageBlockLegacySchema = getImageBlockSchema(
 	FilledLinkValueLegacySchema,
 )
 
+type ImageBlockLegacy = z.infer<typeof ImageBlockLegacySchema>
+
 // Embed block
 // oxlint-disable-next-line explicit-module-boundary-types
 export const getEmbedBlockSchema = <
@@ -151,15 +180,17 @@ export const getEmbedBlockSchema = <
 
 const EmbedBlockLegacySchema = getEmbedBlockSchema(EmbedLegacyLooseSchema)
 
+type EmbedBlockLegacy = z.infer<typeof EmbedBlockLegacySchema>
+
 // Blocks
-export const BlockLegacySchema = z.union([
+export const RichTextLegacyBlockSchema: z.ZodMiniType<RichTextLegacyBlock> = z.union([
 	TextBlockLegacySchema,
 	ImageBlockLegacySchema,
 	EmbedBlockLegacySchema,
 ])
 
-export type BlockLegacy = z.infer<typeof BlockLegacySchema>
+export type RichTextLegacyBlock = TextBlockLegacy | ImageBlockLegacy | EmbedBlockLegacy
 
-export const RichTextLegacySchema = z.array(BlockLegacySchema)
+export const RichTextLegacySchema = z.array(RichTextLegacyBlockSchema)
 
 export type RichTextLegacy = z.infer<typeof RichTextLegacySchema>

package/src/content/legacy/slice.ts

@@ -28,10 +28,10 @@ export const SharedSliceLegacySchema = z.object({
 export type SharedSliceLegacy = z.infer<typeof SharedSliceLegacySchema>
 
 // All
-export const SliceLegacySchema = z.union([
+export const SliceLegacySchema: z.ZodMiniType<SliceLegacy> = z.union([
 	LegacySliceLegacySchema,
 	CompositeSliceLegacySchema,
 	SharedSliceLegacySchema,
 ])
 
-export type SliceLegacy = z.infer<typeof SliceLegacySchema>
+export type SliceLegacy = LegacySliceLegacy | CompositeSliceLegacy | SharedSliceLegacy

package/src/content/legacy/widget.ts

@@ -1,15 +1,23 @@
 import { z } from "zod/mini"
 
+import type { GroupLegacy} from "./group";
 import { GroupLegacySchema } from "./group"
+import type { NestableLegacy} from "./nestable";
 import { NestableLegacySchema } from "./nestable"
+import type { SlicesLegacy} from "./slices";
 import { SlicesLegacySchema } from "./slices"
+import type { UIDLegacy} from "./uid";
 import { UIDLegacySchema } from "./uid"
 
-export const WidgetLegacySchema = z.union([
+export const WidgetLegacySchema: z.ZodMiniType<WidgetLegacy> = z.union([
 	UIDLegacySchema,
 	GroupLegacySchema,
 	SlicesLegacySchema,
 	NestableLegacySchema,
 ])
 
-export type WidgetLegacy = z.infer<typeof WidgetLegacySchema>
+export type WidgetLegacy =
+	| UIDLegacy
+	| GroupLegacy
+	| SlicesLegacy
+	| NestableLegacy

package/src/content/link.ts

@@ -63,7 +63,7 @@ const AnyLinkValueContentSchema = z.extend(AnyLinkLegacySchema, {
 // All
 
 // Used by content/richText
-export const FilledLinkValueContentSchema = z.union([
+export const FilledLinkValueContentSchema: z.ZodMiniType<FilledLinkValueContent> = z.union([
 	FilledImageLinkValueContentSchema,
 	FilledFileLinkValueContentSchema,
 	FilledDocumentLinkValueContentSchema,
@@ -71,9 +71,13 @@ export const FilledLinkValueContentSchema = z.union([
 ])
 
 // Used by content/legacy/link
-export type FilledLinkValueContent = z.infer<typeof FilledLinkValueContentSchema>
+type FilledImageLinkValueContent = z.infer<typeof FilledImageLinkValueContentSchema>
+type FilledFileLinkValueContent = z.infer<typeof FilledFileLinkValueContentSchema>
+type FilledDocumentLinkValueContent = z.infer<typeof FilledDocumentLinkValueContentSchema>
+type FilledExternalLinkValueContent = z.infer<typeof FilledExternalLinkValueContentSchema>
+export type FilledLinkValueContent = FilledImageLinkValueContent | FilledFileLinkValueContent | FilledDocumentLinkValueContent | FilledExternalLinkValueContent
 
-const EmptyLinkValueContentSchema = z.union([
+const EmptyLinkValueContentSchema: z.ZodMiniType<EmptyLinkValueContent> = z.union([
 	EmptyImageLinkValueContentSchema,
 	EmptyFileLinkValueContentSchema,
 	EmptyMediaLinkValueContentSchema,
@@ -83,12 +87,18 @@ const EmptyLinkValueContentSchema = z.union([
 ])
 
 // Used by content/codec/link
-export type EmptyLinkValueContent = z.infer<typeof EmptyLinkValueContentSchema>
+type EmptyImageLinkValueContent = z.infer<typeof EmptyImageLinkValueContentSchema>
+type EmptyFileLinkValueContent = z.infer<typeof EmptyFileLinkValueContentSchema>
+type EmptyMediaLinkValueContent = z.infer<typeof EmptyMediaLinkValueContentSchema>
+type EmptyDocumentLinkValueContent = z.infer<typeof EmptyDocumentLinkValueContentSchema>
+type EmptyExternalLinkValueContent = z.infer<typeof EmptyExternalLinkValueContentSchema>
+type AnyLinkValueContent = z.infer<typeof AnyLinkValueContentSchema>
+export type EmptyLinkValueContent = EmptyImageLinkValueContent | EmptyFileLinkValueContent | EmptyMediaLinkValueContent | EmptyDocumentLinkValueContent | EmptyExternalLinkValueContent | AnyLinkValueContent
 
-const LinkValueContentSchema = z.union([FilledLinkValueContentSchema, EmptyLinkValueContentSchema])
+const LinkValueContentSchema: z.ZodMiniType<LinkValueContent> = z.union([FilledLinkValueContentSchema, EmptyLinkValueContentSchema])
 
 // Used by content/codec/link
-export type LinkValueContent = z.infer<typeof LinkValueContentSchema>
+export type LinkValueContent = FilledLinkValueContent | EmptyLinkValueContent
 
 // Content
 export const LinkContentType = "LinkContent" as const
@@ -117,7 +127,7 @@ export const LinkContentSchema = z.object({
 			z.object({
 				text: z.optional(z.string()),
 				variant: z.optional(z.string()),
-				value: z.union([FilledLinkValueContentSchema, EmptyLinkValueContentSchema]),
+				value: LinkValueContentSchema as z.ZodMiniType<LinkValueContent, Record<string, unknown>>,
 			}),
 		),
 		z.transform(({ text, variant, value }) => ({

package/src/content/nestable.ts

@@ -1,9 +1,20 @@
 import { z } from "zod/mini"
 
 import type { NestableModel } from "../model/nestable"
+import type { BooleanContent} from "./boolean";
 import { BooleanContentDefaultValue, BooleanContentSchema, BooleanContentType } from "./boolean"
+import type { EmbedContent} from "./embed";
 import { EmbedContentSchema, EmbedContentType } from "./embed"
+import type { EmptyContent} from "./empty";
 import { EmptyContentSchema, EmptyContentType } from "./empty"
+import type {
+	ColorContent,
+	DateContent,
+	NumberContent,
+	RangeContent,
+	SelectContent,
+	TextContent,
+	TimestampContent} from "./field";
 import {
 	ColorContentSchema,
 	DateContentSchema,
@@ -15,16 +26,24 @@ import {
 	TextContentSchema,
 	TimestampContentSchema,
 } from "./field"
+import type { GeoPointContent} from "./geopoint";
 import { GeoPointContentSchema, GeoPointContentType } from "./geopoint"
+import type { ImageContent} from "./image";
 import { ImageContentSchema, ImageContentType } from "./image"
+import type { IntegrationFieldContent} from "./integrationField";
 import { IntegrationFieldContentSchema, IntegrationFieldContentType } from "./integrationField"
+import type { LinkContent} from "./link";
 import { LinkContentSchema, LinkContentType } from "./link"
+import type { RepeatableContent} from "./repeatable";
 import { RepeatableContentSchema, RepeatableContentType } from "./repeatable"
+import type { RichTextContent} from "./richText";
 import { RichTextContentSchema, RichTextContentType } from "./richText"
+import type { SeparatorContent} from "./separator";
 import { SeparatorContentSchema, SeparatorContentType } from "./separator"
+import type { TableContent} from "./table";
 import { TableContentSchema, TableContentType } from "./table"
 
-export const NestableContentSchema = z.union([
+export const NestableContentSchema: z.ZodMiniType<NestableContent> = z.union([
 	EmptyContentSchema,
 	BooleanContentSchema,
 	ColorContentSchema,
@@ -45,7 +64,25 @@ export const NestableContentSchema = z.union([
 	TimestampContentSchema,
 ])
 
-export type NestableContent = z.infer<typeof NestableContentSchema>
+export type NestableContent =
+	EmptyContent |
+	BooleanContent |
+	ColorContent |
+	DateContent |
+	EmbedContent |
+	GeoPointContent |
+	ImageContent |
+	IntegrationFieldContent |
+	LinkContent |
+	NumberContent |
+	RangeContent |
+	RepeatableContent |
+	RichTextContent |
+	SelectContent |
+	SeparatorContent |
+	TableContent |
+	TextContent |
+	TimestampContent
 
 const NestableContentTypes = [
 	EmptyContentType,

package/src/content/richText.ts

@@ -2,31 +2,55 @@ import { z } from "zod/mini"
 
 import { EmbedContentSchema } from "./embed"
 import { ImageViewContentSchema } from "./image"
-import { getEmbedBlockSchema, getImageBlockSchema, getTextBlockSchema } from "./legacy/richText"
+import {
+	getEmbedBlockSchema,
+	getImageBlockSchema,
+	getSpanSchema,
+	getTextBlockSchema,
+} from "./legacy/richText"
+import type { Span } from "./legacy/richText"
+import type { FilledLinkValueContent } from "./link"
 import { FilledLinkValueContentSchema } from "./link"
 
+// Spans
+export type RichTextContentSpan = Span<FilledLinkValueContent>
+
+export const RichTextContentSpanSchema: z.ZodMiniType<RichTextContentSpan> =
+	getSpanSchema(FilledLinkValueContentSchema)
+
+// Blocks
 const TextBlockValueSchema = getTextBlockSchema(FilledLinkValueContentSchema)
+type TextBlockValue = z.infer<typeof TextBlockValueSchema>
+
 const ImageBlockValueSchema = getImageBlockSchema(
 	ImageViewContentSchema,
 	FilledLinkValueContentSchema,
 )
+type ImageBlockValue = z.infer<typeof ImageBlockValueSchema>
+
 const EmbedBlockValueSchema = getEmbedBlockSchema(EmbedContentSchema)
+type EmbedBlockValue = z.infer<typeof EmbedBlockValueSchema>
 
-// Blocks
-const BlockValueSchema = z.union([
+export const RichTextContentBlockSchema: z.ZodMiniType<RichTextContentBlock> = z.union([
 	TextBlockValueSchema,
 	ImageBlockValueSchema,
 	EmbedBlockValueSchema,
 ])
 
-// Used by content/richText
-export type BlockValue = z.infer<typeof BlockValueSchema>
+// Used by content/codec/richText
+export type RichTextContentBlock =
+	| TextBlockValue
+	| ImageBlockValue
+	| EmbedBlockValue
 
 export const RichTextContentType = "StructuredTextContent" as const
 
-export const RichTextContentSchema = z.object({
+export type RichTextContent = {
+	__TYPE__: typeof RichTextContentType
+	value: RichTextContentBlock[]
+}
+
+export const RichTextContentSchema: z.ZodMiniType<RichTextContent> = z.object({
 	__TYPE__: z.literal(RichTextContentType),
-	value: z.array(BlockValueSchema),
+	value: z.array(RichTextContentBlockSchema),
 })
-
-export type RichTextContent = z.infer<typeof RichTextContentSchema>

package/src/content/slice.ts

@@ -32,10 +32,10 @@ export const SharedSliceContentSchema = z.object({
 export type SharedSliceContent = z.infer<typeof SharedSliceContentSchema>
 
 // All
-export const SliceContentSchema = z.union([
+export const SliceContentSchema: z.ZodMiniType<SliceContent> = z.union([
 	LegacySliceContentSchema,
 	CompositeSliceContentSchema,
 	SharedSliceContentSchema,
 ])
 
-export type SliceContent = z.infer<typeof SliceContentSchema>
+export type SliceContent = LegacySliceContent | CompositeSliceContent | SharedSliceContent

package/src/content/widget.ts

@@ -1,17 +1,21 @@
 import { z } from "zod/mini"
 
+import type { GroupContent} from "./group";
 import { GroupContentSchema } from "./group"
+import type { NestableContent} from "./nestable";
 import { NestableContentSchema } from "./nestable"
+import type { SlicesContent} from "./slices";
 import { SlicesContentSchema } from "./slices"
+import type { UIDContent} from "./uid";
 import { UIDContentSchema } from "./uid"
 
-export const WidgetContentSchema = z.union([
+export const WidgetContentSchema: z.ZodMiniType<WidgetContent> = z.union([
 	GroupContentSchema,
 	NestableContentSchema,
 	UIDContentSchema,
 	SlicesContentSchema,
 ])
 
-export type WidgetContent = z.infer<typeof WidgetContentSchema>
+export type WidgetContent = GroupContent | NestableContent | UIDContent | SlicesContent
 
 export type ContentType = WidgetContent["__TYPE__"]

package/src/helpers/documentContent.ts

@@ -13,27 +13,24 @@ import { traverseDocumentContent } from "./traverseContent"
 
 export function collectWidgets<TWidgetContent extends WidgetContent>(
 	document: DocumentContent,
-	test: (args: {
-		path: contentPath.Path
-		key: string
-		apiID: string
-		content: WidgetContent
-	}) => args is {
-		path: contentPath.Path
-		key: string
-		apiID: string
-		content: TWidgetContent
-	},
+	test: (
+		content: WidgetContent,
+		args: {
+			path: contentPath.Path
+			key: string
+			apiID: string
+		},
+	) => content is TWidgetContent,
 ): Record<string, TWidgetContent> {
 	const collected: Record<string, TWidgetContent> = {}
 
 	traverseDocumentContent(document, {
-		transformWidget: (args) => {
-			if (test(args)) {
-				collected[contentPath.serialize(args.path)] = args.content
+		transformWidget: ({ content, ...args }) => {
+			if (test(content, args)) {
+				collected[contentPath.serialize(args.path)] = content
 			}
 
-			return args.content
+			return content
 		},
 	})
 

package/src/helpers/traverseContent.ts

@@ -24,7 +24,8 @@ import type { NestableModel } from "../model/nestable"
 import type {
 	CompositeSliceModel,
 	LegacySliceModel,
-	SharedSliceVariationModel,
+	SharedSliceVariationContentModel,
+	SliceContentModel,
 } from "../model/slice"
 import type { StaticSlicesModel } from "../model/slices"
 import { TableCellModel } from "../model/table"
@@ -81,10 +82,8 @@ export function traverseSlicesContent(
 	content: SlicesContent,
 	config: TraverseSlicesContentConfig,
 ): SlicesContent | undefined {
-	const {
-		transformWidget = (args) => args.content,
-		transformSlice = (args) => args.content
-	} = config
+	const { transformWidget = (args) => args.content, transformSlice = (args) => args.content } =
+		config
 
 	const traversed: SlicesContent["value"] = []
 	for (const sliceItemContent of content.value) {
@@ -92,7 +91,7 @@ export function traverseSlicesContent(
 
 		let traversedSliceItemContent: SliceItemContent | undefined
 		if (sliceItemContent.widget.__TYPE__ === SharedSliceContentType) {
-			let model: SharedSliceVariationModel | undefined
+			let model: SharedSliceVariationContentModel | undefined
 			if (sliceModel?.type === "SharedSlice") {
 				const variationID = sliceItemContent.widget.variation
 				const variationModel = sliceModel.variations.find(
@@ -154,7 +153,7 @@ export function traverseSlicesContent(
 }
 
 type TraverseSharedSliceContentConfig = {
-	model?: SharedSliceVariationModel
+	model?: SharedSliceVariationContentModel
 	transformWidget?: TraverseWidgetContentFunction
 	transformSlice?: TraverseSliceContentFunction
 }
@@ -166,10 +165,8 @@ export function traverseSharedSliceContent(
 	content: SharedSliceItemContent,
 	config: TraverseSharedSliceContentConfig,
 ): SharedSliceItemContent | undefined {
-	const {
-		transformWidget = (args) => args.content,
-		transformSlice = (args) => args.content
-	} = config
+	const { transformWidget = (args) => args.content, transformSlice = (args) => args.content } =
+		config
 
 	const traversedPrimary: SharedSliceContent["primary"] = {}
 	for (const [key, fieldContent] of Object.entries(content.widget.primary)) {
@@ -222,10 +219,8 @@ export function traverseCompositeSliceContent(
 	content: CompositeSliceItemContent,
 	config: TraverseCompositeSliceContentConfig,
 ): CompositeSliceItemContent | undefined {
-	const {
-		transformWidget = (args) => args.content,
-		transformSlice = (args) => args.content
-	} = config
+	const { transformWidget = (args) => args.content, transformSlice = (args) => args.content } =
+		config
 
 	const traversedPrimary: CompositeSliceContent["nonRepeat"] = {}
 	for (const [key, fieldContent] of Object.entries(content.widget.nonRepeat)) {
@@ -278,7 +273,7 @@ export function traverseLegacySliceContent(
 	const {
 		model,
 		transformWidget = (args) => args.content,
-		transformSlice = (args) => args.content
+		transformSlice = (args) => args.content,
 	} = config
 
 	const traversedContent = traverseWidgetContent(path, key, apiID, content.widget, {
@@ -471,7 +466,7 @@ export type TraverseSliceContentFunction = <TContent extends SliceItemContent>(a
 	key: string
 	apiID: string
 	content: TContent
-	model?: SliceModel
+	model?: SliceContentModel
 }) => TContent | undefined
 
 export type TraverseWidgetContentFunction<
@@ -485,8 +480,6 @@ export type TraverseWidgetContentFunction<
 }) => (TContentTransformMode extends "preserve" ? TContent : WidgetContent) | undefined
 
 // Internals
-type SliceModel = SharedSliceVariationModel | CompositeSliceModel | LegacySliceModel
-
 type TraverseWidgetContentConfig = {
 	model?: StaticWidgetModel
 	transformWidget?: TraverseWidgetContentFunction