@prismicio/types-internal 3.17.0 → 4.0.0-canary.4689e2d

package/src/content/legacy/nestable.ts

@@ -0,0 +1,55 @@
+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 type { StringLegacy } from "./field"
+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.ZodMiniType<NestableLegacy> = z.union([
+	EmptyLegacySchema,
+	BooleanLegacySchema,
+	EmbedLegacyLooseSchema,
+	StringLegacySchema,
+	GeoPointLegacySchema,
+	ImageLegacySchema,
+	IntegrationFieldLegacySchema,
+	LinkLegacySchema,
+	RepeatableLegacySchema,
+	RichTextLegacySchema,
+	SeparatorLegacySchema,
+	TableLegacySchema,
+])
+
+export type NestableLegacy =
+	| EmptyLegacy
+	| BooleanLegacy
+	| EmbedLegacy
+	| StringLegacy
+	| GeoPointLegacy
+	| ImageLegacy
+	| IntegrationFieldLegacy
+	| LinkLegacy
+	| RepeatableLegacy
+	| RichTextLegacy
+	| SeparatorLegacy
+	| TableLegacy

package/src/content/legacy/repeatable.ts

@@ -0,0 +1,7 @@
+import { z } from "zod/mini"
+
+// Keep the legacy schema non-lossy; item-level link decoding lives in
+// `codec/repeatable.ts`, where the field model is available.
+export const RepeatableLegacySchema = z.array(z.unknown())
+
+export type RepeatableLegacy = z.infer<typeof RepeatableLegacySchema>

package/src/content/legacy/richText.ts

@@ -0,0 +1,200 @@
+import { z } from "zod/mini"
+
+// It's important to only import the types here to
+// avoid runtime circular dependencies!
+import type { EmbedContentSchema } from "../embed"
+import type { ImageContentViewSchema } from "../image"
+import type { FilledLinkContentValue, FilledLinkContentValueSchema } from "../link"
+import { EmbedLegacyLooseSchema } from "./embed"
+import { ImageLegacyViewSchema } from "./image"
+import { FilledLinkLegacyValueSchema } from "./link"
+import type { FilledLinkLegacyValue } from "./link"
+
+export const RichTextNodeType = {
+	heading1: "heading1",
+	heading2: "heading2",
+	heading3: "heading3",
+	heading4: "heading4",
+	heading5: "heading5",
+	heading6: "heading6",
+	paragraph: "paragraph",
+	preformatted: "preformatted",
+	oListItem: "o-list-item",
+	listItem: "list-item",
+	image: "image",
+	embed: "embed",
+	hyperlink: "hyperlink",
+	strong: "strong",
+	em: "em",
+} as const
+
+export type RichTextNodeTypes = (typeof RichTextNodeType)[keyof typeof RichTextNodeType]
+
+// Spans
+type HyperlinkSpan<TData extends FilledLinkLegacyValue | FilledLinkContentValue> = {
+	type: typeof RichTextNodeType.hyperlink
+	start: number
+	end: number
+	data: TData
+}
+
+const getHyperlinkSpanSchema = <
+	TData extends typeof FilledLinkLegacyValueSchema | typeof FilledLinkContentValueSchema,
+>(
+	data: TData,
+) =>
+	z.object({
+		type: z.literal(RichTextNodeType.hyperlink),
+		start: z.number(),
+		end: z.number(),
+		data,
+	})
+
+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(),
+	data: z.pipe(
+		z.unknown(),
+		z.transform((value) => (typeof value === "string" && value.length > 0 ? value : "")),
+	),
+})
+
+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),
+		z.literal("list-item"), // legacy case
+	]),
+	start: z.number(),
+	end: z.number(),
+})
+
+export type Span<TLink extends FilledLinkLegacyValue | FilledLinkContentValue> =
+	| HyperlinkSpan<TLink>
+	| LabelSpan
+	| BasicSpan
+
+// oxlint-disable-next-line explicit-module-boundary-types
+export const getSpanSchema = <
+	TLinkSchema extends typeof FilledLinkLegacyValueSchema | typeof FilledLinkContentValueSchema,
+>(
+	linkSchema: TLinkSchema,
+) => z.union([getHyperlinkSpanSchema(linkSchema), LabelSpanSchema, BasicSpanSchema])
+
+// Text blocks
+const TextBlockTypeSchema = z.union([
+	z.literal(RichTextNodeType.paragraph),
+	z.literal(RichTextNodeType.heading1),
+	z.literal(RichTextNodeType.heading2),
+	z.literal(RichTextNodeType.heading3),
+	z.literal(RichTextNodeType.heading4),
+	z.literal(RichTextNodeType.heading5),
+	z.literal(RichTextNodeType.heading6),
+	z.literal(RichTextNodeType.preformatted),
+	z.literal(RichTextNodeType.oListItem),
+	z.literal(RichTextNodeType.listItem),
+])
+
+// oxlint-disable-next-line explicit-module-boundary-types
+export const getTextBlockSchema = <
+	TLinkSchema extends typeof FilledLinkLegacyValueSchema | typeof FilledLinkContentValueSchema,
+>(
+	linkSchema: TLinkSchema,
+) =>
+	z.object({
+		type: TextBlockTypeSchema,
+		content: z.object({
+			text: z.string(),
+			spans: z.optional(
+				z.pipe(
+					z.array(z.unknown()),
+					z.transform((spans) => {
+						const spanSchema = getSpanSchema(linkSchema)
+
+						// Filter out invalid spans and order them by start position
+						return spans
+							.flatMap((maybeSpan) => {
+								const parsed = spanSchema.safeParse(maybeSpan)
+								return parsed.success ? [parsed.data] : []
+							})
+							.sort((a, b) => a.start - b.start)
+					}),
+				),
+			),
+		}),
+		label: z.optional(z.string()),
+		direction: z.optional(z.string()),
+	})
+
+const TextBlockLegacySchema = getTextBlockSchema(FilledLinkLegacyValueSchema)
+
+type TextBlockLegacy = z.infer<typeof TextBlockLegacySchema>
+
+// Image block
+
+// oxlint-disable-next-line explicit-module-boundary-types
+export const getImageBlockSchema = <
+	TData extends typeof ImageLegacyViewSchema | typeof ImageContentViewSchema,
+	TLinkTo extends typeof FilledLinkLegacyValueSchema | typeof FilledLinkContentValueSchema,
+>(
+	data: TData,
+	linkTo: TLinkTo,
+) =>
+	z.object({
+		type: z.literal(RichTextNodeType.image),
+		data: z.extend(data, { linkTo: z.nullish(linkTo) }),
+		label: z.nullish(z.string()),
+		direction: z.nullish(z.string()),
+	})
+
+const ImageBlockLegacySchema = getImageBlockSchema(
+	ImageLegacyViewSchema,
+	FilledLinkLegacyValueSchema,
+)
+
+type ImageBlockLegacy = z.infer<typeof ImageBlockLegacySchema>
+
+// Embed block
+// oxlint-disable-next-line explicit-module-boundary-types
+export const getEmbedBlockSchema = <
+	TData extends typeof EmbedLegacyLooseSchema | typeof EmbedContentSchema,
+>(
+	data: TData,
+) =>
+	z.object({
+		type: z.literal(RichTextNodeType.embed),
+		data,
+		label: z.nullish(z.string()),
+		direction: z.nullish(z.string()),
+	})
+
+const EmbedBlockLegacySchema = getEmbedBlockSchema(EmbedLegacyLooseSchema)
+
+type EmbedBlockLegacy = z.infer<typeof EmbedBlockLegacySchema>
+
+// Blocks
+export const RichTextLegacyBlockSchema: z.ZodMiniType<RichTextLegacyBlock> = z.union([
+	TextBlockLegacySchema,
+	ImageBlockLegacySchema,
+	EmbedBlockLegacySchema,
+])
+
+export type RichTextLegacyBlock = TextBlockLegacy | ImageBlockLegacy | EmbedBlockLegacy
+
+export const RichTextLegacySchema = z.array(RichTextLegacyBlockSchema)
+
+export type RichTextLegacy = z.infer<typeof RichTextLegacySchema>

package/src/content/legacy/separator.ts

@@ -0,0 +1,6 @@
+import { z } from "zod/mini"
+
+// v3 SeparatorLegacy decode accepts any input and normalizes to SeparatorContent.
+export const SeparatorLegacySchema = z.unknown()
+
+export type SeparatorLegacy = z.infer<typeof SeparatorLegacySchema>

package/src/content/legacy/slice.ts

@@ -0,0 +1,38 @@
+import { z } from "zod/mini"
+
+import { GroupItemLegacySchema, NestableAndGroupLegacySchema } from "./group"
+
+// Legacy (before 2020)
+export const LegacySliceLegacySchema = NestableAndGroupLegacySchema
+
+export type LegacySliceLegacy = z.infer<typeof LegacySliceLegacySchema>
+
+// Composite (2020 to 2021)
+// Keep non-repeat values raw here: array-shaped legacy payloads are ambiguous until
+// `codec/slice.ts` resolves the field model and picks the right decoder.
+export const CompositeSliceLegacySchema = z.object({
+	"non-repeat": z.optional(z.record(z.string(), z.unknown())),
+	repeat: z.optional(z.array(GroupItemLegacySchema)),
+})
+
+export type CompositeSliceLegacy = z.infer<typeof CompositeSliceLegacySchema>
+
+// Shared (2021 to present)
+// Keep primary values raw here: array-shaped legacy payloads are ambiguous until
+// `codec/slice.ts` resolves the field model and picks the right decoder.
+export const SharedSliceLegacySchema = z.object({
+	variation: z.string(),
+	primary: z.transform((value) => z.record(z.string(), z.unknown()).safeParse(value).data || {}),
+	items: z.transform((value) => z.array(GroupItemLegacySchema).safeParse(value).data || []),
+})
+
+export type SharedSliceLegacy = z.infer<typeof SharedSliceLegacySchema>
+
+// All
+export const SliceLegacySchema: z.ZodMiniType<SliceLegacy> = z.union([
+	LegacySliceLegacySchema,
+	CompositeSliceLegacySchema,
+	SharedSliceLegacySchema,
+])
+
+export type SliceLegacy = LegacySliceLegacy | CompositeSliceLegacy | SharedSliceLegacy

package/src/content/legacy/slices.ts

@@ -0,0 +1,17 @@
+import { z } from "zod/mini"
+
+import { SliceLegacySchema } from "./slice"
+
+// Item
+export const SliceItemLegacySchema = z.object({
+	key: z.string(),
+	label: z.nullish(z.string()),
+	value: SliceLegacySchema,
+})
+
+export type SliceItemLegacy = z.infer<typeof SliceItemLegacySchema>
+
+// Slices
+export const SlicesLegacySchema = z.array(SliceItemLegacySchema)
+
+export type SlicesLegacy = z.infer<typeof SlicesLegacySchema>

package/src/content/legacy/table.ts

@@ -0,0 +1,39 @@
+import { z } from "zod/mini"
+
+// It's important to only import the types here to
+// avoid runtime circular dependencies!
+import type { RichTextContentSchema } from "../richText"
+import { RichTextLegacySchema } from "./richText"
+
+// Cell
+const getTableCellSchema = <
+	TContent extends typeof RichTextLegacySchema | typeof RichTextContentSchema,
+>(
+	content: TContent,
+) =>
+	z.object({
+		key: z.transform((value) => z.uuidv4().safeParse(value).data || crypto.randomUUID()),
+		type: z.union([z.literal("tableHeader"), z.literal("tableCell")]),
+		content,
+		columnWidth: z.optional(z.number()),
+	})
+
+// Row
+// oxlint-disable-next-line explicit-module-boundary-types
+export const getTableRowSchema = <
+	TRichText extends typeof RichTextLegacySchema | typeof RichTextContentSchema,
+>(
+	richTextSchema: TRichText,
+) =>
+	z.strictObject({
+		key: z.transform((value) => z.uuidv4().safeParse(value).data || crypto.randomUUID()),
+		type: z.literal("tableRow"),
+		content: z.array(getTableCellSchema(richTextSchema)),
+	})
+
+// Table
+export const TableLegacySchema = z.strictObject({
+	content: z.array(getTableRowSchema(RichTextLegacySchema)),
+})
+
+export type TableLegacy = z.infer<typeof TableLegacySchema>

package/src/content/legacy/uid.ts

@@ -0,0 +1,6 @@
+import { z } from "zod/mini"
+
+// TODO: Can't we add business logic UID shape validation here? (not uniqueness but format)
+export const UIDLegacySchema = z.string()
+
+export type UIDLegacy = z.infer<typeof UIDLegacySchema>

package/src/content/legacy/widget.ts

@@ -0,0 +1,19 @@
+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.ZodMiniType<WidgetLegacy> = z.union([
+	UIDLegacySchema,
+	GroupLegacySchema,
+	SlicesLegacySchema,
+	NestableLegacySchema,
+])
+
+export type WidgetLegacy = UIDLegacy | GroupLegacy | SlicesLegacy | NestableLegacy

package/src/content/link.ts

@@ -0,0 +1,165 @@
+import { z } from "zod/mini"
+
+import {
+	EmptyDocumentLinkLegacyValueSchema,
+	EmptyImageLinkLegacyValueSchema,
+	FilledDocumentLinkLegacyValueSchema,
+	FilledFileLinkLegacyValueSchema,
+	FilledImageLinkLegacyValueSchema,
+	EmptyMediaLinkLegacyValueSchema,
+	FilledExternalLinkLegacyValueSchema,
+	EmptyExternalLinkLegacyValueSchema,
+	AnyLinkLegacySchema,
+	LinkType,
+	EmptyFileLinkLegacyValueSchema,
+} from "./legacy/link"
+
+// Image
+const FilledImageLinkContentValueSchema = z.extend(FilledImageLinkLegacyValueSchema, {
+	__TYPE__: z.literal(LinkType.Image),
+})
+
+const EmptyImageLinkContentValueSchema = z.extend(EmptyImageLinkLegacyValueSchema, {
+	__TYPE__: z.literal(LinkType.Image),
+})
+
+// File
+const FilledFileLinkContentValueSchema = z.extend(FilledFileLinkLegacyValueSchema, {
+	__TYPE__: z.literal(LinkType.File),
+})
+
+const EmptyFileLinkContentValueSchema = z.extend(EmptyFileLinkLegacyValueSchema, {
+	__TYPE__: z.literal(LinkType.File),
+})
+
+// Media
+const EmptyMediaLinkContentValueSchema = z.extend(EmptyMediaLinkLegacyValueSchema, {
+	__TYPE__: z.literal(LinkType.Media),
+})
+
+// Document
+const FilledDocumentLinkContentValueSchema = z.extend(FilledDocumentLinkLegacyValueSchema, {
+	__TYPE__: z.literal(LinkType.Document),
+})
+
+const EmptyDocumentLinkContentValueSchema = z.extend(EmptyDocumentLinkLegacyValueSchema, {
+	__TYPE__: z.literal(LinkType.Document),
+})
+
+// External
+const FilledExternalLinkContentValueSchema = z.extend(FilledExternalLinkLegacyValueSchema, {
+	__TYPE__: z.literal(LinkType.External),
+})
+
+const EmptyExternalLinkContentValueSchema = z.extend(EmptyExternalLinkLegacyValueSchema, {
+	__TYPE__: z.literal(LinkType.External),
+})
+
+// Any
+const AnyLinkContentValueSchema = z.extend(AnyLinkLegacySchema, {
+	__TYPE__: z.literal(LinkType.Any),
+})
+
+// All
+
+// Used by content/richText
+export const FilledLinkContentValueSchema: z.ZodMiniType<FilledLinkContentValue> = z.union([
+	FilledImageLinkContentValueSchema,
+	FilledFileLinkContentValueSchema,
+	FilledDocumentLinkContentValueSchema,
+	FilledExternalLinkContentValueSchema,
+])
+
+// Used by content/legacy/link
+type FilledImageLinkContentValue = z.infer<typeof FilledImageLinkContentValueSchema>
+type FilledFileLinkContentValue = z.infer<typeof FilledFileLinkContentValueSchema>
+type FilledDocumentLinkContentValue = z.infer<typeof FilledDocumentLinkContentValueSchema>
+type FilledExternalLinkContentValue = z.infer<typeof FilledExternalLinkContentValueSchema>
+export type FilledLinkContentValue =
+	| FilledImageLinkContentValue
+	| FilledFileLinkContentValue
+	| FilledDocumentLinkContentValue
+	| FilledExternalLinkContentValue
+
+const EmptyLinkContentValueSchema: z.ZodMiniType<EmptyLinkContentValue> = z.union([
+	EmptyImageLinkContentValueSchema,
+	EmptyFileLinkContentValueSchema,
+	EmptyMediaLinkContentValueSchema,
+	EmptyDocumentLinkContentValueSchema,
+	EmptyExternalLinkContentValueSchema,
+	AnyLinkContentValueSchema,
+])
+
+// Used by content/codec/link
+type EmptyImageLinkContentValue = z.infer<typeof EmptyImageLinkContentValueSchema>
+type EmptyFileLinkContentValue = z.infer<typeof EmptyFileLinkContentValueSchema>
+type EmptyMediaLinkContentValue = z.infer<typeof EmptyMediaLinkContentValueSchema>
+type EmptyDocumentLinkContentValue = z.infer<typeof EmptyDocumentLinkContentValueSchema>
+type EmptyExternalLinkContentValue = z.infer<typeof EmptyExternalLinkContentValueSchema>
+type AnyLinkContentValue = z.infer<typeof AnyLinkContentValueSchema>
+export type EmptyLinkContentValue =
+	| EmptyImageLinkContentValue
+	| EmptyFileLinkContentValue
+	| EmptyMediaLinkContentValue
+	| EmptyDocumentLinkContentValue
+	| EmptyExternalLinkContentValue
+	| AnyLinkContentValue
+
+const LinkContentValueSchema: z.ZodMiniType<LinkContentValue> = z.union([
+	FilledLinkContentValueSchema,
+	EmptyLinkContentValueSchema,
+])
+
+// Used by content/codec/link
+export type LinkContentValue = FilledLinkContentValue | EmptyLinkContentValue
+
+// Content
+export const LinkContentType = "LinkContent" as const
+
+const getLinkContentSchema = <TValue extends LinkContentValue>(value: z.ZodMiniType<TValue>) =>
+	z.object({
+		__TYPE__: z.literal(LinkContentType),
+		key: z.transform((value) => z.uuidv4().safeParse(value).data || crypto.randomUUID()),
+		// We cannot use z.extend here because we're working with unions.
+		// z.intersection wouldn't work also for the same reason.
+		value: z.pipe(
+			z.pipe(
+				z.pipe(
+					z.record(z.string(), z.unknown()),
+					z.transform(
+						({
+							text,
+							variant,
+							...value
+						}): {
+							text?: unknown
+							variant?: unknown
+							value: Record<string, unknown>
+						} => ({ text, variant, value }),
+					),
+				),
+				z.object({
+					text: z.optional(z.string()),
+					variant: z.optional(z.string()),
+					value: value as z.ZodMiniType<TValue, Record<string, unknown>>,
+				}),
+			),
+			z.transform(({ text, variant, value }) => ({
+				...(text ? { text } : {}),
+				...(variant ? { variant } : {}),
+				...value,
+			})),
+		),
+	})
+
+export const FilledLinkContentSchema = getLinkContentSchema(FilledLinkContentValueSchema)
+
+export type FilledLinkContent = z.infer<typeof FilledLinkContentSchema>
+
+export const EmptyLinkContentSchema = getLinkContentSchema(EmptyLinkContentValueSchema)
+
+export type EmptyLinkContent = z.infer<typeof EmptyLinkContentSchema>
+
+export const LinkContentSchema = getLinkContentSchema(LinkContentValueSchema)
+
+export type LinkContent = z.infer<typeof LinkContentSchema>

package/src/content/nestable.ts

@@ -0,0 +1,107 @@
+import { z } from "zod/mini"
+
+import type { BooleanContent } from "./boolean"
+import { 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,
+	FieldContentType,
+	NumberContentSchema,
+	RangeContentSchema,
+	SelectContentSchema,
+	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.ZodMiniType<NestableContent> = z.union([
+	EmptyContentSchema,
+	BooleanContentSchema,
+	ColorContentSchema,
+	DateContentSchema,
+	EmbedContentSchema,
+	GeoPointContentSchema,
+	ImageContentSchema,
+	IntegrationFieldContentSchema,
+	LinkContentSchema,
+	NumberContentSchema,
+	RangeContentSchema,
+	RepeatableContentSchema,
+	RichTextContentSchema,
+	SelectContentSchema,
+	SeparatorContentSchema,
+	TableContentSchema,
+	TextContentSchema,
+	TimestampContentSchema,
+])
+
+export type NestableContent =
+	| EmptyContent
+	| BooleanContent
+	| ColorContent
+	| DateContent
+	| EmbedContent
+	| GeoPointContent
+	| ImageContent
+	| IntegrationFieldContent
+	| LinkContent
+	| NumberContent
+	| RangeContent
+	| RepeatableContent
+	| RichTextContent
+	| SelectContent
+	| SeparatorContent
+	| TableContent
+	| TextContent
+	| TimestampContent
+
+const NestableContentTypes = [
+	EmptyContentType,
+	BooleanContentType,
+	EmbedContentType,
+	FieldContentType,
+	GeoPointContentType,
+	ImageContentType,
+	IntegrationFieldContentType,
+	LinkContentType,
+	RepeatableContentType,
+	RichTextContentType,
+	SeparatorContentType,
+	TableContentType,
+]
+type NestableContentType = (typeof NestableContentTypes)[number]
+
+/** @internal */
+export function isNestableContent(content: {
+	__TYPE__: string
+}): content is { __TYPE__: NestableContentType } {
+	return (NestableContentTypes as string[]).includes(content.__TYPE__)
+}

package/src/content/repeatable.ts

@@ -0,0 +1,21 @@
+import { z } from "zod/mini"
+
+import { LinkContentSchema, LinkContentType } from "./link"
+
+export const RepeatableContentType = "RepeatableContent" as const
+
+export const RepeatableContentSchema = z.object({
+	__TYPE__: z.literal(RepeatableContentType),
+	type: z.literal("Link"),
+	value: z.array(LinkContentSchema),
+})
+
+export type RepeatableContent = z.infer<typeof RepeatableContentSchema>
+
+const RepeatableContentTypes = [LinkContentType]
+type RepeatableContentType = (typeof RepeatableContentTypes)[number]
+export function isRepeatableContentValue(content: {
+	__TYPE__: string
+}): content is { __TYPE__: RepeatableContentType } {
+	return (RepeatableContentTypes as string[]).includes(content.__TYPE__)
+}