@datocms/cma-client 5.0.0 → 5.1.0

package/dist/esm/fieldTypes/single_block.js

@@ -0,0 +1,63 @@
+/**
+ * =============================================================================
+ * SHARED UTILITY FUNCTIONS
+ * =============================================================================
+ * These functions are used internally and can be imported by other modules
+ */
+/**
+ * Validates if a single block item is a string ID
+ */
+export function isBlockStringId(block) {
+    return typeof block === 'string';
+}
+/**
+ * Validates if a single block item is a SchemaTypes.Item object (with or without ID)
+ */
+export function isBlockObject(block) {
+    return (typeof block === 'object' &&
+        block !== null &&
+        'type' in block &&
+        'attributes' in block);
+}
+/**
+ * Validates if a single block item is a complete SchemaTypes.Item object with ID
+ */
+export function isBlockObjectWithId(block) {
+    return isBlockObject(block) && 'id' in block && typeof block.id === 'string';
+}
+/**
+ * =============================================================================
+ * TYPE GUARDS - Runtime validation functions
+ * =============================================================================
+ */
+/**
+ * Type guard for basic Single Block field values (block as string ID only).
+ * Checks for string structure and ensures block is a string reference.
+ */
+export function isSingleBlockFieldValue(value) {
+    return typeof value === 'string' || value === null;
+}
+/**
+ * Type guard for Single Block field values in API request format.
+ * Allows block as string ID, full object with ID, or object without ID.
+ */
+export function isSingleBlockFieldValueAsRequest(value) {
+    if (value === null)
+        return true;
+    // String ID _ referencing existing block
+    if (isBlockStringId(value))
+        return true;
+    // Object (either with or without ID for updates/creation)
+    return isBlockObject(value);
+}
+/**
+ * Type guard for Single Block field values with nested blocks (?nested=true format).
+ * Ensures block is a full SchemaTypes.Item object with complete data.
+ */
+export function isSingleBlockFieldValueWithResolvedBlocks(value) {
+    if (value === null)
+        return true;
+    // Must be a full object with ID (nested format always includes complete block objects)
+    return isBlockObjectWithId(value);
+}
+//# sourceMappingURL=single_block.js.map

package/dist/esm/fieldTypes/single_block.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"single_block.js","sourceRoot":"","sources":["../../../src/fieldTypes/single_block.ts"],"names":[],"mappings":"AAiFA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,KAAc;IAC5C,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC;AACnC,CAAC;AAOD;;GAEG;AACH,MAAM,UAAU,aAAa,CAC3B,KAAc;IAEd,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,MAAM,IAAI,KAAK;QACf,YAAY,IAAI,KAAK,CACtB,CAAC;AACJ,CAAC;AAID;;GAEG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAc;IAEd,OAAO,aAAa,CAAC,KAAK,CAAC,IAAI,IAAI,IAAI,KAAK,IAAI,OAAO,KAAK,CAAC,EAAE,KAAK,QAAQ,CAAC;AAC/E,CAAC;AAED;;;;GAIG;AAEH;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CACrC,KAAc;IAEd,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AACrD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gCAAgC,CAC9C,KAAc;IAEd,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAEhC,yCAAyC;IACzC,IAAI,eAAe,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAExC,0DAA0D;IAC1D,OAAO,aAAa,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,yCAAyC,CACvD,KAAc;IAEd,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAEhC,uFAAuF;IACvF,OAAO,mBAAmB,CAAC,KAAK,CAAC,CAAC;AACpC,CAAC"}

package/dist/esm/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/esm/fieldTypes/slug.js

@@ -0,0 +1,6 @@
+export function isSlugFieldValue(value) {
+    if (value === null)
+        return true;
+    return typeof value === 'string' && /^[a-z0-9_]+(?:-[a-z0-9]+)*$/.test(value);
+}
+//# sourceMappingURL=slug.js.map

package/dist/esm/fieldTypes/slug.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slug.js","sourceRoot":"","sources":["../../../src/fieldTypes/slug.ts"],"names":[],"mappings":"AAQA,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAChC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,6BAA6B,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAChF,CAAC"}

package/dist/esm/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/esm/fieldTypes/string.js

@@ -0,0 +1,4 @@
+export function isStringFieldValue(value) {
+    return typeof value === 'string' || value === null;
+}
+//# sourceMappingURL=string.js.map

package/dist/esm/fieldTypes/string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.js","sourceRoot":"","sources":["../../../src/fieldTypes/string.ts"],"names":[],"mappings":"AAWA,MAAM,UAAU,kBAAkB,CAAC,KAAc;IAC/C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AACrD,CAAC"}

package/dist/esm/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/esm/fieldTypes/structured_text.js

@@ -0,0 +1,81 @@
+import { isBlock, isInlineBlock, isNode, } from 'datocms-structured-text-utils';
+import { everyNode } from '../utilities/structuredText';
+import { isBlockObject, isBlockObjectWithId, isBlockStringId, } from './single_block';
+/**
+ * Helper function to validate if a value has the expected structured text document structure.
+ * Checks for the presence of 'schema' and 'document' properties on a non-null object.
+ */
+function isValidDocumentStructure(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'schema' in value &&
+        'document' in value);
+}
+/**
+ * Utility function to validate all block/inlineBlock nodes in a structured text document tree.
+ * Calls the provided callback for each block/inlineBlock node found and returns true only if all pass.
+ */
+function validateAllBlockNodes(node, callback) {
+    return everyNode(node, (currentNode) => {
+        // If this is a block or inlineBlock node, validate it with the callback
+        if (isNode(currentNode) &&
+            (isBlock(currentNode) || isInlineBlock(currentNode))) {
+            return callback(currentNode);
+        }
+        // For all other node types, they're valid by default
+        return true;
+    });
+}
+/**
+ * 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 function isStructuredTextFieldValue(value) {
+    if (value === null)
+        return true;
+    if (!isValidDocumentStructure(value)) {
+        return false;
+    }
+    // Check that all block/inlineBlock nodes have string item IDs
+    return validateAllBlockNodes(value.document, (node) => {
+        return typeof node.item === 'string';
+    });
+}
+/**
+ * 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 function isStructuredTextFieldValueAsRequest(value) {
+    if (value === null)
+        return true;
+    if (!isValidDocumentStructure(value)) {
+        return false;
+    }
+    // Check that all block/inlineBlock nodes have valid request format items
+    return validateAllBlockNodes(value.document, (node) => {
+        const item = node.item;
+        // String ID
+        if (isBlockStringId(item))
+            return true;
+        // Object (either with or without ID)
+        return isBlockObject(item);
+    });
+}
+/**
+ * Type guard for structured text field values with nested blocks (?nested=true format).
+ * Ensures all block/inlineBlock nodes have full SchemaTypes.Item objects.
+ */
+export function isStructuredTextFieldValueWithResolvedBlocks(value) {
+    if (value === null)
+        return true;
+    if (!isValidDocumentStructure(value)) {
+        return false;
+    }
+    // Check that all block/inlineBlock nodes have full item objects
+    return validateAllBlockNodes(value.document, (node) => {
+        const item = node.item;
+        // Must be a full object with ID (nested format always includes full items)
+        return isBlockObjectWithId(item);
+    });
+}
+//# sourceMappingURL=structured_text.js.map

package/dist/esm/fieldTypes/structured_text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured_text.js","sourceRoot":"","sources":["../../../src/fieldTypes/structured_text.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,OAAO,EACP,aAAa,EACb,MAAM,GACP,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AACxD,OAAO,EAEL,aAAa,EACb,mBAAmB,EACnB,eAAe,GAChB,MAAM,gBAAgB,CAAC;AA8HxB;;;GAGG;AACH,SAAS,wBAAwB,CAC/B,KAAc;IAEd,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,QAAQ,IAAI,KAAK;QACjB,UAAU,IAAI,KAAK,CACpB,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAS,qBAAqB,CAC5B,IAAa,EACb,QAQY;IAEZ,OAAO,SAAS,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE;QACrC,wEAAwE;QACxE,IACE,MAAM,CAAC,WAAW,CAAC;YACnB,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,aAAa,CAAC,WAAW,CAAC,CAAC,EACpD;YACA,OAAO,QAAQ,CAAC,WAAW,CAAC,CAAC;SAC9B;QACD,qDAAqD;QACrD,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,0BAA0B,CACxC,KAAc;IAEd,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAEhC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,EAAE;QACpC,OAAO,KAAK,CAAC;KACd;IAED,8DAA8D;IAC9D,OAAO,qBAAqB,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE;QACpD,OAAO,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC;IACvC,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,mCAAmC,CACjD,KAAc;IAEd,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAEhC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,EAAE;QACpC,OAAO,KAAK,CAAC;KACd;IAED,yEAAyE;IACzE,OAAO,qBAAqB,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE;QACpD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QAEvB,YAAY;QACZ,IAAI,eAAe,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;QAEvC,qCAAqC;QACrC,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,4CAA4C,CAC1D,KAAc;IAEd,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAEhC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,EAAE;QACpC,OAAO,KAAK,CAAC;KACd;IAED,gEAAgE;IAChE,OAAO,qBAAqB,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE;QACpD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QAEvB,2EAA2E;QAC3E,OAAO,mBAAmB,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/esm/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/esm/fieldTypes/text.js

@@ -0,0 +1,4 @@
+export function isTextFieldValue(value) {
+    return typeof value === 'string' || value === null;
+}
+//# sourceMappingURL=text.js.map

package/dist/esm/fieldTypes/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","sourceRoot":"","sources":["../../../src/fieldTypes/text.ts"],"names":[],"mappings":"AAUA,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AACrD,CAAC"}

package/dist/esm/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/esm/fieldTypes/validators/date_range.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=date_range.js.map

package/dist/esm/fieldTypes/validators/date_range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date_range.js","sourceRoot":"","sources":["../../../../src/fieldTypes/validators/date_range.ts"],"names":[],"mappings":""}

package/dist/esm/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/esm/fieldTypes/validators/date_time_range.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=date_time_range.js.map

package/dist/esm/fieldTypes/validators/date_time_range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date_time_range.js","sourceRoot":"","sources":["../../../../src/fieldTypes/validators/date_time_range.ts"],"names":[],"mappings":""}

package/dist/esm/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/esm/fieldTypes/validators/description_length.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=description_length.js.map

package/dist/esm/fieldTypes/validators/description_length.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"description_length.js","sourceRoot":"","sources":["../../../../src/fieldTypes/validators/description_length.ts"],"names":[],"mappings":""}

package/dist/esm/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/esm/fieldTypes/validators/enum.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=enum.js.map

package/dist/esm/fieldTypes/validators/enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.js","sourceRoot":"","sources":["../../../../src/fieldTypes/validators/enum.ts"],"names":[],"mappings":""}

package/dist/esm/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/esm/fieldTypes/validators/extension.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=extension.js.map

package/dist/esm/fieldTypes/validators/extension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension.js","sourceRoot":"","sources":["../../../../src/fieldTypes/validators/extension.ts"],"names":[],"mappings":""}

package/dist/esm/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/esm/fieldTypes/validators/file_size.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=file_size.js.map

package/dist/esm/fieldTypes/validators/file_size.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file_size.js","sourceRoot":"","sources":["../../../../src/fieldTypes/validators/file_size.ts"],"names":[],"mappings":""}

package/dist/esm/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/esm/fieldTypes/validators/format.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=format.js.map

package/dist/esm/fieldTypes/validators/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../../../../src/fieldTypes/validators/format.ts"],"names":[],"mappings":""}