@datocms/cma-client 5.0.1 → 5.1.0

package/dist/types/fieldTypes/slug.d.ts

@@ -0,0 +1,26 @@
+import type { SlugEditorConfiguration } from './appearance/slug';
+import type { LengthValidator } from './validators/length';
+import type { RequiredValidator } from './validators/required';
+import type { SlugFormatValidator } from './validators/slug_format';
+import type { SlugTitleFieldValidator } from './validators/slug_title_field';
+export type SlugFieldValue = string | null;
+export declare function isSlugFieldValue(value: unknown): value is SlugFieldValue;
+export type SlugFieldValidators = {
+    /** Value must be specified or it won't be valid */
+    required?: RequiredValidator;
+    /** Accept strings only with a specified number of characters */
+    length?: LengthValidator;
+    /** Only accept slugs having a specific format */
+    slug_format?: SlugFormatValidator;
+    /** Specifies the ID of the Single_line string field that will be used to generate the slug */
+    slug_title_field?: SlugTitleFieldValidator;
+};
+export type SlugFieldAppearance = {
+    editor: 'slug';
+    parameters: SlugEditorConfiguration;
+} | {
+    /** Plugin ID */
+    editor: string;
+    /** Plugin configuration */
+    parameters: Record<string, unknown>;
+};

package/dist/types/fieldTypes/string.d.ts

@@ -0,0 +1,37 @@
+import type { SingleLineEditorConfiguration } from './appearance/single_line';
+import type { StringRadioGroupEditorConfiguration } from './appearance/string_radio_group';
+import type { StringSelectEditorConfiguration } from './appearance/string_select';
+import type { EnumValidator } from './validators/enum';
+import type { FormatValidator } from './validators/format';
+import type { LengthValidator } from './validators/length';
+import type { RequiredValidator } from './validators/required';
+import type { UniqueValidator } from './validators/unique';
+export type StringFieldValue = string | null;
+export declare function isStringFieldValue(value: unknown): value is StringFieldValue;
+export type StringFieldValidators = {
+    /** Value must be specified or it won't be valid */
+    required?: RequiredValidator;
+    /** The value must be unique across the whole collection of records */
+    unique?: UniqueValidator;
+    /** Accept strings only with a specified number of characters */
+    length?: LengthValidator;
+    /** Accepts only strings that match a specified format */
+    format?: FormatValidator;
+    /** Only accept a specific set of values */
+    enum?: EnumValidator;
+};
+export type StringFieldAppearance = {
+    editor: 'single_line';
+    parameters: SingleLineEditorConfiguration;
+} | {
+    editor: 'string_radio_group';
+    parameters: StringRadioGroupEditorConfiguration;
+} | {
+    editor: 'string_select';
+    parameters: StringSelectEditorConfiguration;
+} | {
+    /** Plugin ID */
+    editor: string;
+    /** Plugin configuration */
+    parameters: Record<string, unknown>;
+};

package/dist/types/fieldTypes/structured_text.d.ts

@@ -0,0 +1,181 @@
+import { type Block, type Document, type InlineBlock, type Root } from 'datocms-structured-text-utils';
+import type * as SchemaTypes from '../generated/SchemaTypes';
+import { type BlockItemInARequest } from './single_block';
+/**
+ * STRUCTURED TEXT TYPE SYSTEM FOR DATOCMS
+ *
+ * This module defines a comprehensive type system for handling DatoCMS structured text fields,
+ * which are rich text documents that can contain embedded blocks and inline elements.
+ *
+ * The challenge we're solving:
+ * - DatoCMS structured text can contain "blocks" (embedded content items) in bloth 'block'
+ *   and 'inlineBlock' nodes
+ * - By default, API responses contain blocks as string IDs (lightweight references)
+ * - With ?nested=true parameter though, API responses contain blocks as full item objects
+ *   (which in turn can contain other blocks)
+ * - For API requests, blocks can be represented as:
+ *   1. String IDs (referencing existing items)
+ *   2. Full item objects with IDs (for updates)
+ *   3. Item objects without IDs (for creation)
+ *
+ * This creates a need for different type variants for the same conceptual data structure.
+ */
+/**
+ * =============================================================================
+ * REQUEST VARIANTS - Types for sending data TO the DatoCMS API
+ * =============================================================================
+ *
+ * When making API requests, we need flexibility in how we represent embedded blocks:
+ * - Use string IDs to reference existing blocks that do not need to change
+ * - Include full block objects for updates
+ * - Omit IDs for new blocks being created
+ */
+/**
+ * Variant of 'block' structured text node for API requests
+ */
+export type BlockAsRequest = Omit<Block, 'item'> & {
+    item: BlockItemInARequest;
+};
+/**
+ * Variant of 'inlineBlock' structured text node for API requests
+ */
+export type InlineBlockAsRequest = Omit<InlineBlock, 'item'> & {
+    item: BlockItemInARequest;
+};
+/**
+ * Generic type to transform a node that might be containing a 'block' or 'inlineBlock' as a (deeply nested) children to its variant for API requests
+ */
+export type NodeAsRequest<T> = WithMappedChildren<T, DeepMapVariants<T extends {
+    children: infer C;
+} ? C : never, BlockAsRequest, InlineBlockAsRequest>>;
+/**
+ * Variant of Structured Text document for API requests
+ */
+export type DocumentAsRequest = {
+    schema: 'dast';
+    document: NodeAsRequest<Root>;
+};
+/**
+ * =============================================================================
+ * NESTED VARIANTS - Types for API responses with ?nested=true parameter
+ * =============================================================================
+ *
+ * When using the GET /items?nested=true, the API returns Structured Text documents
+ * with embedded blocks fully populated as complete SchemaTypes.Item objects instead
+ * of just string IDs.
+ */
+/**
+ * Variant of 'block' structured text node for ?nested=true API responses
+ */
+export type BlockWithResolvedBlocks = Omit<Block, 'item'> & {
+    item: SchemaTypes.Item;
+};
+/**
+ * Variant of 'inlineBlock' structured text node for ?nested=true API responses
+ */
+export type InlineBlockWithResolvedBlocks = Omit<InlineBlock, 'item'> & {
+    item: SchemaTypes.Item;
+};
+/**
+ * Generic type to transform a node that might be containing a 'block' or 'inlineBlock' as a (deeply nested) children to it's variant for ?nested=true API responses
+ */
+export type NodeWithResolvedBlocks<T> = WithMappedChildren<T, DeepMapVariants<T extends {
+    children: infer C;
+} ? C : never, BlockWithResolvedBlocks, InlineBlockWithResolvedBlocks>>;
+/**
+ * Variant of Structured Text document for ?nested=true API responses
+ */
+export type DocumentWithResolvedBlocks = {
+    schema: 'dast';
+    document: NodeWithResolvedBlocks<Root>;
+};
+/**
+ * =============================================================================
+ * MAIN APPLICATION TYPES
+ * =============================================================================
+ */
+/**
+ * The main type for structured text field values in our application.
+ * Can be null (empty field) or a document with blocks as string IDs
+ */
+export type StructuredTextFieldValue = Document | null;
+export type StructuredTextFieldValueAsRequest = DocumentAsRequest | null;
+export type StructuredTextFieldValueWithResolvedBlocks = DocumentWithResolvedBlocks | null;
+/**
+ * Type guard for basic structured text field values (blocks as string IDs only).
+ * Checks for the expected structure and ensures all block/inlineBlock nodes have string IDs.
+ */
+export declare function isStructuredTextFieldValue(value: unknown): value is StructuredTextFieldValue;
+/**
+ * Type guard for structured text field values in API request format.
+ * Allows blocks as string IDs, full objects with IDs, or objects without IDs.
+ */
+export declare function isStructuredTextFieldValueAsRequest(value: unknown): value is StructuredTextFieldValueAsRequest;
+/**
+ * Type guard for structured text field values with nested blocks (?nested=true format).
+ * Ensures all block/inlineBlock nodes have full SchemaTypes.Item objects.
+ */
+export declare function isStructuredTextFieldValueWithResolvedBlocks(value: unknown): value is StructuredTextFieldValueWithResolvedBlocks;
+/**
+ * =============================================================================
+ * SHARED TRANSFORMATION UTILITIES
+ * =============================================================================
+ *
+ * These utility types provide the machinery for automatically transforming
+ * structured text types between their different variants. The goal is to
+ * recursively walk through complex nested structures and apply the appropriate
+ * transformations to Block and InlineBlock nodes while preserving all other types.
+ */
+/**
+ * Utility type that preserves the structure of T but replaces its children with ChildrenType.
+ * If T doesn't have children, it returns T unchanged.
+ */
+type WithMappedChildren<T, ChildrenType> = T extends {
+    children: any;
+} ? Omit<T, 'children'> & {
+    children: ChildrenType;
+} : T;
+/**
+ * Generic transformation type that replace 'block' and 'inlineBlock' node types to their variants.
+ */
+type MapVariants<T, BlockVariant, InlineBlockVariant> = T extends Block ? BlockVariant : T extends InlineBlock ? InlineBlockVariant : T;
+/**
+ * Recursively transform a Structured Text node type using the provided variants for 'block' and 'inlineBlock' nodes.
+ *
+ * This handles three cases:
+ * _ Arrays: Transform each array element recursively
+ * _ Objects with children: Transform the object itself AND recursively transform its children
+ * _ Leaf nodes: Apply the variant mapping
+ */
+type DeepMapVariants<T, BlockVariant, InlineBlockVariant> = T extends (infer U)[] ? DeepMapVariants<U, BlockVariant, InlineBlockVariant>[] : T extends {
+    children: infer Children;
+} ? T extends {
+    children: any;
+} ? Omit<T, 'children'> & {
+    children: DeepMapVariants<Children, BlockVariant, InlineBlockVariant>;
+} : MapVariants<T, BlockVariant, InlineBlockVariant> : MapVariants<T, BlockVariant, InlineBlockVariant>;
+import type { StructuredTextEditorConfiguration } from './appearance/structured_text';
+import type { LengthValidator } from './validators/length';
+import type { StructuredTextBlocksValidator } from './validators/structured_text_blocks';
+import type { StructuredTextInlineBlocksValidator } from './validators/structured_text_inline_blocks';
+import type { StructuredTextLinksValidator } from './validators/structured_text_links';
+export type StructuredTextFieldValidators = {
+    /** Only accept references to block records of the specified block models */
+    structured_text_blocks: StructuredTextBlocksValidator;
+    /** Only accept itemLink to inlineItem nodes for records of the specified models */
+    structured_text_links: StructuredTextLinksValidator;
+    /** Accept strings only with a specified number of characters */
+    length?: LengthValidator;
+    /** Only accept references to block records of the specified block models for inline blocks */
+    structured_text_inline_blocks?: StructuredTextInlineBlocksValidator;
+};
+export type StructuredTextFieldAppearance = {
+    editor: 'structured_text';
+    parameters: StructuredTextEditorConfiguration;
+} | {
+    /** Plugin ID */
+    editor: string;
+    /** Plugin configuration */
+    parameters: Record<string, unknown>;
+};
+export {};

package/dist/types/fieldTypes/text.d.ts

@@ -0,0 +1,34 @@
+import type { MarkdownEditorConfiguration } from './appearance/markdown';
+import type { TextareaEditorConfiguration } from './appearance/textarea';
+import type { WysiwygEditorConfiguration } from './appearance/wysiwyg';
+import type { FormatValidator } from './validators/format';
+import type { LengthValidator } from './validators/length';
+import type { RequiredValidator } from './validators/required';
+import type { SanitizationValidator } from './validators/sanitization';
+export type TextFieldValue = string | null;
+export declare function isTextFieldValue(value: unknown): value is TextFieldValue;
+export type TextFieldValidators = {
+    /** Value must be specified or it won't be valid */
+    required?: RequiredValidator;
+    /** Accept strings only with a specified number of characters */
+    length?: LengthValidator;
+    /** Accepts only strings that match a specified format */
+    format?: FormatValidator;
+    /** Checks for the presence of malicious code in HTML fields */
+    sanitization?: SanitizationValidator;
+};
+export type TextFieldAppearance = {
+    editor: 'markdown';
+    parameters: MarkdownEditorConfiguration;
+} | {
+    editor: 'wysiwyg';
+    parameters: WysiwygEditorConfiguration;
+} | {
+    editor: 'textarea';
+    parameters: TextareaEditorConfiguration;
+} | {
+    /** Plugin ID */
+    editor: string;
+    /** Plugin configuration */
+    parameters: Record<string, unknown>;
+};

package/dist/types/fieldTypes/validators/date_range.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Accept dates only inside a specified date range.
+ */
+export type DateRangeValidator = {
+    /** Minimum date (ISO 8601 date format) */
+    min: string;
+    /** Maximum date (ISO 8601 date format) */
+    max?: string;
+} | {
+    /** Minimum date (ISO 8601 date format) */
+    min?: string;
+    /** Maximum date (ISO 8601 date format) */
+    max: string;
+};

package/dist/types/fieldTypes/validators/date_time_range.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Accept date times only inside a specified date range.
+ */
+export type DateTimeRangeValidator = {
+    /** Minimum datetime (ISO 8601 datetime format) */
+    min: string /** Maximum datetime (ISO 8601 datetime format) */;
+    max?: string;
+} | {
+    /** Minimum datetime (ISO 8601 datetime format) */
+    min?: string /** Maximum datetime (ISO 8601 datetime format) */;
+    max: string;
+};

package/dist/types/fieldTypes/validators/description_length.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Limits the length of the description for a SEO field.
+ * Search engines usually truncate description tags to 160 characters so it is a good practice to keep the description around this length.
+ */
+export type DescriptionLengthValidator = {
+    /** Minimum value */ min: number /** Maximum value */;
+    max?: number;
+} | {
+    /** Minimum value */ min?: number /** Maximum value */;
+    max: number;
+};

package/dist/types/fieldTypes/validators/enum.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Only accept a specific set of values.
+ */
+export type EnumValidator = {
+    /** Set of allowed values */
+    values: string[];
+};

package/dist/types/fieldTypes/validators/extension.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Only accept assets with specific file extensions.
+ */
+export type ExtensionValidator = {
+    /** Set of allowed file extensions */
+    extensions: string[];
+    predefined_list?: never;
+} | {
+    extensions?: never;
+    /** Allowed file type */
+    predefined_list: 'image' | 'transformable_image' | 'video' | 'document';
+};

package/dist/types/fieldTypes/validators/file_size.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Accept assets only within a specified file size range.
+ */
+export type FileSizeValidator = {
+    /** Numeric value for minimum filesize */
+    min_value: number /** Unit for minimum filesize */;
+    min_unit: 'B' | 'KB' | 'MB' /** Numeric value for maximum filesize */;
+    max_value?: number /** Unit for maximum filesize */;
+    max_unit?: 'B' | 'KB' | 'MB';
+} | {
+    /** Numeric value for minimum filesize */
+    min_value?: number /** Unit for minimum filesize */;
+    min_unit?: 'B' | 'KB' | 'MB' /** Numeric value for maximum filesize */;
+    max_value: number /** Unit for maximum filesize */;
+    max_unit: 'B' | 'KB' | 'MB';
+};

package/dist/types/fieldTypes/validators/format.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Accepts only strings that match a specified format.
+ * Only one of `custom_pattern` or `predefined_pattern` should be specified.
+ * If `custom_pattern` is used, an additional `description` parameter can be provided
+ * to serve as a hint for the user with a simple explanation of the expected pattern.
+ */
+export type FormatValidator = {
+    /** Custom regular expression for validation */
+    custom_pattern?: string;
+    /** Specifies a pre-defined format (email or URL) */
+    predefined_pattern?: 'email' | 'url';
+    /**
+     * Description that serves as a hint for the user when using custom_pattern.
+     * Offers a simple explanation of the expected pattern, such as "The field must end with an 's'",
+     * instead of the default message like "Field must match the pattern: /s$/".
+     */
+    description?: string;
+};

package/dist/types/fieldTypes/validators/image_aspect_ratio.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Accept assets only within a specified aspect ratio range.
+ */
+export type ImageAspectRatioValidator = {
+    /** Numerator part of the minimum aspect ratio */
+    min_ar_numerator: number /** Denominator part of the minimum aspect ratio */;
+    min_ar_denominator: number /** Numerator part for the required aspect ratio */;
+    eq_ar_numerator?: number /** Denominator part for the required aspect ratio */;
+    eq_ar_denominator?: number /** Numerator part of the maximum aspect ratio */;
+    max_ar_numerator?: number /** Denominator part of the maximum aspect ratio */;
+    max_ar_denominator?: number;
+} | {
+    /** Numerator part of the minimum aspect ratio */
+    min_ar_numerator?: number /** Denominator part of the minimum aspect ratio */;
+    min_ar_denominator?: number /** Numerator part for the required aspect ratio */;
+    eq_ar_numerator: number /** Denominator part for the required aspect ratio */;
+    eq_ar_denominator: number /** Numerator part of the maximum aspect ratio */;
+    max_ar_numerator?: number /** Denominator part of the maximum aspect ratio */;
+    max_ar_denominator?: number;
+} | {
+    /** Numerator part of the minimum aspect ratio */
+    min_ar_numerator?: number /** Denominator part of the minimum aspect ratio */;
+    min_ar_denominator?: number /** Numerator part for the required aspect ratio */;
+    eq_ar_numerator?: number /** Denominator part for the required aspect ratio */;
+    eq_ar_denominator?: number /** Numerator part of the maximum aspect ratio */;
+    max_ar_numerator: number /** Denominator part of the maximum aspect ratio */;
+    max_ar_denominator: number;
+};

package/dist/types/fieldTypes/validators/image_dimensions.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Accept assets only within a specified height and width range.
+ */
+export type ImageDimensionsValidator = {
+    /** Numeric value for minimum width */
+    width_min_value: number /** Numeric value for maximum width */;
+    width_max_value?: number /** Numeric value for minimum height */;
+    height_min_value?: number /** Numeric value for maximum height */;
+    height_max_value?: number;
+} | {
+    /** Numeric value for minimum width */
+    width_min_value?: number /** Numeric value for maximum width */;
+    width_max_value: number /** Numeric value for minimum height */;
+    height_min_value?: number /** Numeric value for maximum height */;
+    height_max_value?: number;
+} | {
+    /** Numeric value for minimum width */
+    width_min_value?: number /** Numeric value for maximum width */;
+    width_max_value?: number /** Numeric value for minimum height */;
+    height_min_value: number /** Numeric value for maximum height */;
+    height_max_value?: number;
+} | {
+    /** Numeric value for minimum width */
+    width_min_value?: number /** Numeric value for maximum width */;
+    width_max_value?: number /** Numeric value for minimum height */;
+    height_min_value?: number /** Numeric value for maximum height */;
+    height_max_value: number;
+};

package/dist/types/fieldTypes/validators/index.d.ts

@@ -0,0 +1,27 @@
+export * from './date_range';
+export * from './date_time_range';
+export * from './description_length';
+export * from './enum';
+export * from './extension';
+export * from './file_size';
+export * from './format';
+export * from './image_aspect_ratio';
+export * from './image_dimensions';
+export * from './item_item_type';
+export * from './items_item_type';
+export * from './length';
+export * from './number_range';
+export * from './required';
+export * from './required_alt_title';
+export * from './required_seo_fields';
+export * from './rich_text_blocks';
+export * from './sanitization';
+export * from './single_block_blocks';
+export * from './size';
+export * from './slug_format';
+export * from './slug_title_field';
+export * from './structured_text_blocks';
+export * from './structured_text_inline_blocks';
+export * from './structured_text_links';
+export * from './title_length';
+export * from './unique';

package/dist/types/fieldTypes/validators/item_item_type.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Only accept references to records of the specified models.
+ */
+export type ItemItemTypeValidator = {
+    /** Set of allowed model IDs */
+    item_types: string[];
+    /**
+     * Strategy to apply when a publishing is requested and this field references some unpublished records.
+     * - "fail": Fail the operation and notify the user
+     * - "publish_references": Publish also the referenced records
+     * @default "fail"
+     */
+    on_publish_with_unpublished_references_strategy?: 'fail' | 'publish_references';
+    /**
+     * Strategy to apply when unpublishing is requested for a record referenced by this field.
+     * - "fail": Fail the operation and notify the user
+     * - "unpublish": Unpublish also this record
+     * - "delete_references": Try to remove the reference to the unpublished record (if the field has a required validation it will fail)
+     * @default "fail"
+     */
+    on_reference_unpublish_strategy?: 'fail' | 'unpublish' | 'delete_references';
+    /**
+     * Strategy to apply when deletion is requested for a record referenced by this field.
+     * - "fail": Fail the operation and notify the user
+     * - "delete_references": Try to remove the reference to the deleted record (if the field has a required validation it will fail)
+     * @default "delete_references"
+     */
+    on_reference_delete_strategy?: 'fail' | 'delete_references';
+};

package/dist/types/fieldTypes/validators/items_item_type.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Only accept references to records of the specified models.
+ */
+export type ItemsItemTypeValidator = {
+    /** Set of allowed model IDs */
+    item_types: string[];
+    /**
+     * Strategy to apply when a publishing is requested and this field references some unpublished records.
+     * - "fail": Fail the operation and notify the user
+     * - "publish_references": Publish also the referenced records
+     * @default "fail"
+     */
+    on_publish_with_unpublished_references_strategy?: 'fail' | 'publish_references';
+    /**
+     * Strategy to apply when unpublishing is requested for a record referenced by this field.
+     * - "fail": Fail the operation and notify the user
+     * - "unpublish": Unpublish also this record
+     * - "delete_references": Try to remove the reference to the unpublished record (if the field has a required validation it will fail)
+     * @default "fail"
+     */
+    on_reference_unpublish_strategy?: 'fail' | 'unpublish' | 'delete_references';
+    /**
+     * Strategy to apply when deletion is requested for a record referenced by this field.
+     * - "fail": Fail the operation and notify the user
+     * - "delete_references": Try to remove the reference to the deleted record (if the field has a required validation it will fail)
+     * @default "delete_references"
+     */
+    on_reference_delete_strategy?: 'fail' | 'delete_references';
+};

package/dist/types/fieldTypes/validators/length.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Accept strings only with a specified number of characters.
+ */
+export type LengthValidator = {
+    /** Minimum length */
+    min: number /** Expected length */;
+    eq?: number /** Maximum length */;
+    max?: number;
+} | {
+    /** Minimum length */
+    min?: number /** Expected length */;
+    eq: number /** Maximum length */;
+    max?: number;
+} | {
+    /** Minimum length */
+    min?: number /** Expected length */;
+    eq?: number /** Maximum length */;
+    max: number;
+};

package/dist/types/fieldTypes/validators/number_range.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Accept numbers only inside a specified range.
+ */
+export type NumberRangeValidator = {
+    /** Minimum value */ min: number /** Maximum value */;
+    max?: number;
+} | {
+    /** Minimum value */ min?: number /** Maximum value */;
+    max: number;
+};

package/dist/types/fieldTypes/validators/required.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Value must be specified or it won't be valid.
+ */
+export type RequiredValidator = Record<string, never>;

package/dist/types/fieldTypes/validators/required_alt_title.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Assets contained in the field are required to specify custom title or alternate text, or they won't be valid.
+ */
+export type RequiredAltTitleValidator = {
+    /** Whether the title for the asset must be specified */
+    title: boolean /** Whether the alternate text for the asset must be specified */;
+    alt?: boolean;
+} | {
+    /** Whether the title for the asset must be specified */
+    title?: boolean /** Whether the alternate text for the asset must be specified */;
+    alt: boolean;
+};

package/dist/types/fieldTypes/validators/required_seo_fields.d.ts

@@ -0,0 +1,28 @@
+/**
+ * SEO field has to specify one or more properties, or it won't be valid.
+ */
+export type RequiredSeoFieldsValidator = {
+    /** Whether the meta title must be specified */
+    title: boolean /** Whether the meta description must be specified */;
+    description?: boolean /** Whether the social sharing image must be specified */;
+    image?: boolean /** Whether the type of Twitter card must be specified */;
+    twitter_card?: boolean;
+} | {
+    /** Whether the meta title must be specified */
+    title?: boolean /** Whether the meta description must be specified */;
+    description: boolean /** Whether the social sharing image must be specified */;
+    image?: boolean /** Whether the type of Twitter card must be specified */;
+    twitter_card?: boolean;
+} | {
+    /** Whether the meta title must be specified */
+    title?: boolean /** Whether the meta description must be specified */;
+    description?: boolean /** Whether the social sharing image must be specified */;
+    image: boolean /** Whether the type of Twitter card must be specified */;
+    twitter_card?: boolean;
+} | {
+    /** Whether the meta title must be specified */
+    title?: boolean /** Whether the meta description must be specified */;
+    description?: boolean /** Whether the social sharing image must be specified */;
+    image?: boolean /** Whether the type of Twitter card must be specified */;
+    twitter_card: boolean;
+};

package/dist/types/fieldTypes/validators/rich_text_blocks.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Only accept references to block records of the specified block models.
+ */
+export type RichTextBlocksValidator = {
+    /** Set of allowed Block Model IDs */
+    item_types: string[];
+};

package/dist/types/fieldTypes/validators/sanitization.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks for the presence of malicious code in HTML fields: content is valid if no dangerous code is present.
+ */
+export type SanitizationValidator = {
+    /** Content is actively sanitized before applying the validation */
+    sanitize_before_validation: boolean;
+};

package/dist/types/fieldTypes/validators/single_block_blocks.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Only accept references to block records of the specified block models.
+ */
+export type SingleBlockBlocksValidator = {
+    /** Set of allowed Block Model IDs */
+    item_types: string[];
+};