@epam/ai-dial-ui-kit 0.15.0-dev.45 → 0.15.0-dev.47

package/dist/src/components/New/SchemaRenderer/components/SchemaAnyOfEditor.d.ts

@@ -0,0 +1,37 @@
+import { FC } from 'react';
+import { JsonSchemaDef } from '../../../../models/json-schema';
+export interface SchemaAnyOfEditorProps {
+    schema: JsonSchemaDef;
+    value: unknown;
+    onChange: (value: unknown) => void;
+    path: string[];
+    level: number;
+    ariaLabel?: string;
+}
+/**
+ * Renders an `anyOf` schema field as a type select with the selected variant's editor.
+ * aliases: AnyOfSchemaEditor|SchemaUnionEditor
+ * Design system 2.0
+ *
+ * A `null` variant has no editor, so selecting it clears the value.
+ *
+ * @example
+ * ```tsx
+ * <SchemaAnyOfEditor
+ *   schema={{ anyOf: [{ type: 'null' }, { type: 'string' }] }}
+ *   value={null}
+ *   onChange={(v) => console.log(v)}
+ *   path={['field']}
+ *   level={1}
+ *   ariaLabel="Field"
+ * />
+ * ```
+ *
+ * @param schema - The JSON Schema definition containing an `anyOf` array
+ * @param value - Current field value
+ * @param onChange - Called with the new value when the type or sub-value changes
+ * @param path - Field path segments used for validation error tracking
+ * @param level - Nesting depth passed to child field components
+ * @param [ariaLabel] - Accessible name of the type select and the variant's control
+ */
+export declare const SchemaAnyOfEditor: FC<SchemaAnyOfEditorProps>;

package/dist/src/components/New/SchemaRenderer/components/SchemaArrayEditor.d.ts

@@ -0,0 +1,35 @@
+import { FC } from 'react';
+import { JsonSchemaDef } from '../../../../models/json-schema';
+export interface SchemaArrayEditorProps {
+    schema: JsonSchemaDef;
+    value: unknown;
+    onChange: (value: unknown) => void;
+    path: string[];
+    level: number;
+}
+/**
+ * Renders a JSON Schema array as a list of collapsible items with add and remove controls.
+ * aliases: ArraySchemaEditor|SchemaListEditor
+ * Design system 2.0
+ *
+ * An item schema with a `discriminator` adds a type select next to the add
+ * button; the new item gets that variant's defaults.
+ *
+ * @example
+ * ```tsx
+ * <SchemaArrayEditor
+ *   schema={{ type: 'array', items: { type: 'string' } }}
+ *   value={['foo', 'bar']}
+ *   onChange={(v) => console.log(v)}
+ *   path={['tags']}
+ *   level={1}
+ * />
+ * ```
+ *
+ * @param schema - The JSON Schema array definition (must include an `items` sub-schema)
+ * @param value - Current array value
+ * @param onChange - Called with the updated array when items are added, removed, or changed
+ * @param path - Field path segments used for validation error tracking
+ * @param level - Nesting depth passed to child section components
+ */
+export declare const SchemaArrayEditor: FC<SchemaArrayEditorProps>;

package/dist/src/components/New/SchemaRenderer/components/SchemaField.d.ts

@@ -0,0 +1,33 @@
+import { FC } from 'react';
+import { SchemaFieldProps } from '../types';
+/**
+ * Renders a single schema property: a labelled field for a primitive, or a
+ * collapsible section for an object or an array.
+ * aliases: SchemaPropertyField|SchemaFormField
+ * Design system 2.0
+ *
+ * The label and the required error sit outside {@link SchemaFieldContent}, so
+ * a `renderField` override replaces the control and keeps both.
+ *
+ * @example
+ * ```tsx
+ * <SchemaField
+ *   schema={{ type: 'string' }}
+ *   value="hello"
+ *   onChange={(v) => console.log(v)}
+ *   path={['name']}
+ *   level={1}
+ *   required
+ *   label="Name"
+ * />
+ * ```
+ *
+ * @param schema - The JSON Schema definition for this field
+ * @param value - Current field value
+ * @param onChange - Called with the updated value when the field changes
+ * @param path - Field path segments used for validation error tracking
+ * @param [level=0] - Nesting depth; object/array fields render as collapsible sections
+ * @param [required] - Whether the field is required (shows error when empty)
+ * @param [label] - Display label; falls back to schema title or path segment
+ */
+export declare const SchemaField: FC<SchemaFieldProps>;

package/dist/src/components/New/SchemaRenderer/components/SchemaFieldContent.d.ts

@@ -0,0 +1,30 @@
+import { FC } from 'react';
+import { SchemaFieldContentProps } from '../types';
+/**
+ * Routes a resolved schema to the editor that renders it.
+ * aliases: SchemaEditorRouter|SchemaContentDispatcher
+ * Design system 2.0
+ *
+ * @example
+ * ```tsx
+ * <SchemaFieldContent
+ *   schema={{ type: 'string' }}
+ *   value="hello"
+ *   onChange={(v) => console.log(v)}
+ *   path={['name']}
+ *   level={1}
+ *   ariaLabel="Name"
+ * />
+ * ```
+ *
+ * @param schema - The JSON Schema definition to render
+ * @param value - Current field value
+ * @param onChange - Called with the updated value when the field changes
+ * @param path - Field path segments used for validation error tracking
+ * @param level - Nesting depth passed to child editor components
+ * @param [required] - Whether the field is required (passed to primitive fields for error styling)
+ * @param [suppressInlineError=false] - Leaves the required error to the caller, which renders it under its own label
+ * @param [fieldId] - Id given to a primitive control, for a visible label to point at
+ * @param [ariaLabel] - Accessible name of the control
+ */
+export declare const SchemaFieldContent: FC<SchemaFieldContentProps>;

package/dist/src/components/New/SchemaRenderer/components/SchemaJsonEditor.d.ts

@@ -0,0 +1,29 @@
+import { FC } from 'react';
+export interface SchemaJsonEditorProps {
+    value: unknown;
+    onChange: (value: unknown) => void;
+    id?: string;
+    ariaLabel?: string;
+}
+/**
+ * Edits a value the schema does not describe as raw JSON text: a key absent
+ * from the schema's `properties`, an object with no fixed properties, or a
+ * key-value entry switched to the object or array type.
+ * aliases: SchemaRawJsonEditor|SchemaUnknownPropertyEditor
+ * Design system 2.0
+ *
+ * A plain monospace {@link Textarea} rather than a code editor, so the form
+ * pulls in no editor bundle. The draft text is kept locally and `onChange`
+ * fires only once it parses.
+ *
+ * @example
+ * ```tsx
+ * <SchemaJsonEditor value={{ retries: 3 }} onChange={setValue} />
+ * ```
+ *
+ * @param value - The current value (any JSON type)
+ * @param onChange - Called with the parsed value whenever the edited text is valid JSON
+ * @param [id] - Id of the textarea, for a visible label to point at
+ * @param [ariaLabel] - Accessible name of the textarea
+ */
+export declare const SchemaJsonEditor: FC<SchemaJsonEditorProps>;

package/dist/src/components/New/SchemaRenderer/components/SchemaKeyValueEditor.d.ts

@@ -0,0 +1,37 @@
+import { FC } from 'react';
+import { JsonSchemaDef } from '../../../../models/json-schema';
+export interface SchemaKeyValueEditorProps {
+    schema: JsonSchemaDef;
+    value: unknown;
+    onChange: (value: unknown) => void;
+    path: string[];
+    level: number;
+}
+/**
+ * Renders an `additionalProperties` object schema as an editable key-value list.
+ * aliases: KeyValueSchemaEditor|AdditionalPropertiesEditor
+ * Design system 2.0
+ *
+ * Primitive values render inline; object, `oneOf` and array values render as a
+ * collapsible section recursing back into `SchemaFieldContent`. With
+ * `additionalProperties: true` each entry also gets a type select, and an
+ * object or array entry is edited as raw JSON.
+ *
+ * @example
+ * ```tsx
+ * <SchemaKeyValueEditor
+ *   schema={{ type: 'object', additionalProperties: { type: 'string' } }}
+ *   value={{ foo: 'bar' }}
+ *   onChange={(v) => console.log(v)}
+ *   path={['metadata']}
+ *   level={1}
+ * />
+ * ```
+ *
+ * @param schema - The JSON Schema object definition with `additionalProperties`
+ * @param value - Current object value (treated as a key-value map)
+ * @param onChange - Called with the updated object when pairs are added, removed, or changed
+ * @param path - Field path segments used for validation error tracking
+ * @param level - Nesting depth passed to child section components
+ */
+export declare const SchemaKeyValueEditor: FC<SchemaKeyValueEditorProps>;

package/dist/src/components/New/SchemaRenderer/components/SchemaObjectEditor.d.ts

@@ -0,0 +1,32 @@
+import { FC } from 'react';
+import { JsonSchemaDef } from '../../../../models/json-schema';
+export interface SchemaObjectEditorProps {
+    schema: JsonSchemaDef;
+    value: unknown;
+    onChange: (value: unknown) => void;
+    path: string[];
+    level: number;
+}
+/**
+ * Renders the properties of a JSON Schema object as labelled form fields.
+ * aliases: ObjectSchemaEditor|SchemaPropertiesEditor
+ * Design system 2.0
+ *
+ * @example
+ * ```tsx
+ * <SchemaObjectEditor
+ *   schema={{ type: 'object', properties: { name: { type: 'string' } } }}
+ *   value={{ name: 'Alice' }}
+ *   onChange={(v) => console.log(v)}
+ *   path={['config']}
+ *   level={1}
+ * />
+ * ```
+ *
+ * @param schema - The JSON Schema object definition
+ * @param value - Current object value
+ * @param onChange - Called with the updated object when any property changes
+ * @param path - Field path segments used for validation error tracking
+ * @param level - Nesting depth passed to child SchemaField instances
+ */
+export declare const SchemaObjectEditor: FC<SchemaObjectEditorProps>;

package/dist/src/components/New/SchemaRenderer/components/SchemaOneOfEditor.d.ts

@@ -0,0 +1,39 @@
+import { FC } from 'react';
+import { JsonSchemaDef } from '../../../../models/json-schema';
+export interface SchemaOneOfEditorProps {
+    schema: JsonSchemaDef;
+    value: unknown;
+    onChange: (value: unknown) => void;
+    path: string[];
+    level: number;
+    ariaLabel?: string;
+}
+/**
+ * Renders a `oneOf` schema field as a type selector with the selected variant's editor.
+ * aliases: OneOfSchemaEditor|SchemaDiscriminatorEditor
+ * Design system 2.0
+ *
+ * The selector is a select by default, or a radio group with
+ * `discriminatorDisplay: 'radio'`. A column radio group reveals the variant's
+ * editor under its own option; a row one shows it below the whole row.
+ *
+ * @example
+ * ```tsx
+ * <SchemaOneOfEditor
+ *   schema={{ oneOf: [...], discriminator: { propertyName: 'type', mapping: {...} } }}
+ *   value={{ type: 'foo' }}
+ *   onChange={(v) => console.log(v)}
+ *   path={['config']}
+ *   level={1}
+ *   ariaLabel="Provider"
+ * />
+ * ```
+ *
+ * @param schema - The JSON Schema definition containing a `oneOf` array and optional `discriminator`
+ * @param value - Current field value
+ * @param onChange - Called with the new value when the selected type or sub-value changes
+ * @param path - Field path segments used for validation error tracking
+ * @param level - Nesting depth passed to child editor components
+ * @param [ariaLabel] - Accessible name of the type selector; defaults to the select-type placeholder
+ */
+export declare const SchemaOneOfEditor: FC<SchemaOneOfEditorProps>;

package/dist/src/components/New/SchemaRenderer/components/SchemaPrimitiveField.d.ts

@@ -0,0 +1,38 @@
+import { FC } from 'react';
+import { JsonSchemaDef } from '../../../../models/json-schema';
+export interface SchemaPrimitiveFieldProps {
+    schema: JsonSchemaDef;
+    value: unknown;
+    onChange: (value: unknown) => void;
+    invalid?: boolean;
+    id?: string;
+    ariaLabel?: string;
+}
+/**
+ * Renders a single primitive schema field: string, integer, number, boolean, enum, or const.
+ * - `dial:resource` with `acceptableResourceTypes` → select over the live resource options
+ * - `isProtected: true` → masked password input
+ * - `enum` + `enumDisplay: 'radio'` → radio group (`enumOrientation: 'row'` lays it out horizontally)
+ * - `enum` without `enumDisplay` → select
+ * - `const` → disabled read-only input
+ * aliases: SchemaInputField|PrimitiveSchemaField
+ * Design system 2.0
+ *
+ * @example
+ * ```tsx
+ * <SchemaPrimitiveField
+ *   schema={{ type: 'string', enum: ['a', 'b'], enumDisplay: 'radio', enumOrientation: 'row' }}
+ *   value="a"
+ *   onChange={(v) => console.log(v)}
+ *   ariaLabel="Mode"
+ * />
+ * ```
+ *
+ * @param schema - The resolved JSON Schema definition; supports `isProtected`, `enumDisplay`, `enumOrientation`
+ * @param value - Current field value
+ * @param onChange - Called with the new value when the field changes
+ * @param [invalid] - Whether the field has a validation error (applies error styling)
+ * @param [id] - Id of the control, for a visible label to point at
+ * @param [ariaLabel] - Accessible name of the control
+ */
+export declare const SchemaPrimitiveField: FC<SchemaPrimitiveFieldProps>;

package/dist/src/components/New/SchemaRenderer/components/SchemaSection.d.ts

@@ -0,0 +1,39 @@
+import { FC, ReactNode } from 'react';
+export interface SchemaSectionProps {
+    title: string;
+    description?: string;
+    summary?: string;
+    errorCount?: number;
+    level?: number;
+    children?: ReactNode;
+    onRemove?: () => void;
+    defaultExpanded?: boolean;
+    removeItemAriaLabel?: string;
+}
+/**
+ * A collapsible card wrapping a group of schema properties.
+ * aliases: CollapsibleSchemaSection|SchemaCard
+ * Design system 2.0
+ *
+ * Only the chevron and the title sit inside the toggle button. The info button
+ * and the remove button are its siblings, since a button nested in a button is
+ * invalid and its clicks would toggle the section too.
+ *
+ * @example
+ * ```tsx
+ * <SchemaSection title="Settings" level={0} summary="3/4 fields" errorCount={1}>
+ *   <p>Content</p>
+ * </SchemaSection>
+ * ```
+ *
+ * @param title - Section header title
+ * @param [description] - Explanatory text, exposed through an info button in the header
+ * @param [summary] - Short summary text shown in the header (e.g. "3/4 fields", "2 items")
+ * @param [errorCount=0] - Number of validation errors; shows an error count when > 0
+ * @param [level=0] - Nesting depth; 0 is the top-level card, 1+ the nested one
+ * @param [children] - Section body, mounted only while expanded
+ * @param [onRemove] - If provided, shows a remove button in the header
+ * @param [defaultExpanded=true] - Whether the section starts expanded
+ * @param [removeItemAriaLabel='Remove item'] - Accessible name of the remove button
+ */
+export declare const SchemaSection: FC<SchemaSectionProps>;

package/dist/src/components/New/SchemaRenderer/context.d.ts

@@ -0,0 +1,8 @@
+import { SchemaRendererContextValue } from './types';
+export declare const SchemaRendererContext: import('react').Context<SchemaRendererContextValue | null>;
+export declare const useSchemaContext: () => SchemaRendererContextValue;
+/**
+ * Whether a path, or any path under it, has been touched. Every field counts as
+ * touched while `skipUntouched` is off, so errors show from the first render.
+ */
+export declare const isPathTouched: (path: string, touchedPaths?: ReadonlySet<string>, skipUntouched?: boolean, includeDescendants?: boolean) => boolean;

package/dist/src/components/New/SchemaRenderer/types.d.ts

@@ -0,0 +1,76 @@
+import { ReactElement, ReactNode } from 'react';
+import { JsonSchema, JsonSchemaDef, SchemaRendererTexts } from '../../../models/json-schema';
+import { SchemaRendererVariant } from '../../../types/json-schema';
+export type SchemaRenderField = (path: string[], schema: JsonSchemaDef, defaultElement: ReactElement) => ReactNode;
+export interface SchemaRendererProps {
+    schema: JsonSchema;
+    defaultValue?: Record<string, unknown>;
+    texts?: Partial<SchemaRendererTexts>;
+    className?: string;
+    readonly?: boolean;
+    defaultExpanded?: boolean;
+    /** Additional classes for the container of every text, number and select field. */
+    inputClassName?: string;
+    /**
+     * `Sections` (default) — every top-level property is a collapsible section card.
+     * `Flat` — primitive top-level properties render as labelled fields; object and
+     * array properties still use collapsible sections.
+     * `FlatSections` — every top-level property renders under a plain heading.
+     */
+    variant?: SchemaRendererVariant;
+    /**
+     * When `true`, required-field errors are only shown after the user has interacted
+     * with a field. When `false` (default), all unfilled required fields are highlighted immediately.
+     */
+    skipUntouched?: boolean;
+    /**
+     * Live resource options for schema properties flagged with `dial:resource: true`.
+     * Keyed by the resource type name referenced in a property's `acceptableResourceTypes`
+     * array; each value provides the selectable entries for that resource type (a string
+     * array for string-typed properties).
+     */
+    acceptableResourceTypes?: Record<string, unknown>;
+    onChange?: (value: Record<string, unknown>) => void;
+    onPropertyChange?: (path: string, value: unknown) => void;
+    onDefaultValues?: (value: Record<string, unknown>) => void;
+    /**
+     * Override the rendered element for any field by path. The field's label and
+     * error stay outside the element, so an override replaces the control only.
+     * Return `defaultElement` to fall back to the built-in renderer.
+     * @param path - Array of schema property keys leading to this field (e.g. ['connection', 'token'])
+     * @param schema - The resolved JSON Schema definition for this field
+     * @param defaultElement - The element that would be rendered without customization
+     */
+    renderField?: SchemaRenderField;
+}
+export interface SchemaFieldContentProps {
+    schema: JsonSchemaDef;
+    value: unknown;
+    onChange: (value: unknown) => void;
+    path: string[];
+    level: number;
+    required?: boolean;
+    suppressInlineError?: boolean;
+    /** The id given to a primitive control, so a visible label can point at it. */
+    fieldId?: string;
+    /**
+     * Accessible name for the control. Sections, array items and key-value rows
+     * have no visible label next to their control, so this is what names it.
+     */
+    ariaLabel?: string;
+}
+export interface SchemaFieldProps extends Omit<SchemaFieldContentProps, 'fieldId' | 'ariaLabel' | 'suppressInlineError'> {
+    label?: string;
+}
+export interface SchemaRendererContextValue {
+    rootSchema: JsonSchema;
+    texts: SchemaRendererTexts;
+    readonly?: boolean;
+    defaultExpanded?: boolean;
+    inputClassName?: string;
+    acceptableResourceTypes?: Record<string, unknown>;
+    renderField?: SchemaRenderField;
+    touchedPaths?: ReadonlySet<string>;
+    markTouched?: (path: string) => void;
+    skipUntouched?: boolean;
+}

package/dist/src/components/New/Slider/Slider.d.ts

@@ -1,4 +1,4 @@
-import { FC, InputHTMLAttributes } from 'react';
+import { FC, InputHTMLAttributes, ReactNode } from 'react';
 import { LabelProps } from '../Label/Label';
 type NativeInputProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'value' | 'defaultValue' | 'onChange' | 'size'>;
 export interface SliderProps extends NativeInputProps {
@@ -14,6 +14,14 @@ export interface SliderProps extends NativeInputProps {
     formatValue?: (value: number) => string;
     /** Renders the current value at the end of the label row */
     showValue?: boolean;
+    /** Renders the current value in a bubble above the thumb */
+    showTooltip?: boolean;
+    /** Renders a tick mark at every value the thumb can snap to */
+    showTicks?: boolean;
+    /** Content before the track, e.g. an icon */
+    leftContent?: ReactNode;
+    /** Content after the track, e.g. a `NumberInput` or the formatted value */
+    rightContent?: ReactNode;
     caption?: string;
     error?: string;
     onChange?: (value: number) => void;
@@ -39,6 +47,13 @@ export interface SliderProps extends NativeInputProps {
  * />
  * ```
  *
+ * With `showTooltip` the value sits in a bubble above the thumb, and with
+ * `showTicks` the track marks every value the thumb snaps to — the discrete
+ * slider of the design. `leftContent` and `rightContent` are the container's
+ * side slots, centred on the track: an icon on the left, a `NumberInput` or the
+ * formatted value on the right. The kit does not wire a `NumberInput` to the
+ * slider; the caller passes both the same `value` and `onChange`.
+ *
  * Built on a native `<input type="range">`, so the browser owns the drag, the
  * arrow / Home / End steps, touch and the writing direction. Only the thumb is
  * restyled; the track and its fill are separate elements so the fill can be
@@ -58,6 +73,10 @@ export interface SliderProps extends NativeInputProps {
  * @param [labels] - 2 or 3 strings rendered below the track (start, [middle,] end)
  * @param [formatValue] - Custom formatter for the displayed value; also becomes the announced `aria-valuetext`
  * @param [showValue=false] - Renders the current value at the end of the label row
+ * @param [showTooltip=false] - Renders the current value in a bubble above the thumb; hidden while disabled
+ * @param [showTicks=false] - Renders a tick mark at every step on the unfilled track; hidden while disabled
+ * @param [leftContent] - Content before the track, vertically centred on it
+ * @param [rightContent] - Content after the track, vertically centred on it
  * @param [caption] - Helper text rendered below the track, and described by the slider
  * @param [error] - Error message rendered below the track; replaces the caption
  * @param [onChange] - Callback fired with the new value

package/dist/src/components/New/Slider/utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Percent positions of every value a slider thumb can snap to, from `min` (0)
+ * up. A step that does not divide the range stops short of `max`, the way the
+ * native range input does.
+ */
+export declare const getTickPercents: (range: number, step: number) => number[];

package/dist/src/components/New/Slider/utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/SchemaRenderer/types.d.ts

@@ -1,98 +1,10 @@
 import { default as React } from 'react';
 import { EditorThemes } from '../../types/editor';
-export declare enum SchemaRendererVariant {
-    Sections = "sections",
-    Flat = "flat",
-    FlatSections = "flat-sections"
-}
-export declare enum SchemaDisplayMode {
-    Select = "select",
-    Radio = "radio"
-}
-export declare enum SchemaOrientation {
-    Row = "row",
-    Column = "column"
-}
-export declare enum JsonSchemaType {
-    String = "string",
-    Number = "number",
-    Integer = "integer",
-    Boolean = "boolean",
-    Object = "object",
-    Array = "array",
-    Null = "null"
-}
-export interface DialMeta {
-    'dial:propertyOrder'?: number;
-    [key: string]: unknown;
-}
-export interface JsonSchemaDef {
-    $ref?: string;
-    type?: string | string[];
-    title?: string;
-    description?: string;
-    isHidden?: boolean;
-    isProtected?: boolean;
-    enumDisplay?: SchemaDisplayMode;
-    enumOrientation?: SchemaOrientation;
-    discriminatorDisplay?: SchemaDisplayMode;
-    discriminatorOrientation?: SchemaOrientation;
-    default?: unknown;
-    const?: unknown;
-    enum?: unknown[];
-    properties?: Record<string, JsonSchemaDef>;
-    required?: string[];
-    items?: JsonSchemaDef;
-    oneOf?: JsonSchemaDef[];
-    anyOf?: JsonSchemaDef[];
-    allOf?: JsonSchemaDef[];
-    discriminator?: {
-        propertyName: string;
-        mapping: Record<string, string>;
-    };
-    'dial:meta'?: DialMeta;
-    'dial:resource'?: boolean;
-    acceptableResourceTypes?: string[];
-    [key: string]: unknown;
-}
-export interface JsonSchema extends JsonSchemaDef {
-    $defs?: Record<string, JsonSchemaDef>;
-}
-export interface ValidationError {
-    path: string;
-    message: string;
-}
-export interface SchemaRendererTexts {
-    noItemSchema: string;
-    noItemsYet: string;
-    addItem: string;
-    selectTypeToAdd: string;
-    noConfigurableProperties: string;
-    noFieldsYet: string;
-    keyColumnHeader: string;
-    valueColumnHeader: string;
-    addField: string;
-    keyInputPlaceholder: string;
-    stringInputPlaceholder: string;
-    integerInputPlaceholder: string;
-    numberInputPlaceholder: string;
-    enumSelectPlaceholder: string;
-    selectTypePlaceholder: string;
-    removeItemAriaLabel: string;
-    removeFieldAriaLabel: string;
-    typeColumnHeader: string;
-    entryTypeString: string;
-    entryTypeNumber: string;
-    entryTypeBoolean: string;
-    entryTypeNull: string;
-    entryTypeObject: string;
-    entryTypeArray: string;
-    entryTypeChangeWarning: string;
-    booleanTrueOption: string;
-    booleanFalseOption: string;
-    invalidJsonError: string;
-}
-export declare const DEFAULT_SCHEMA_TEXTS: SchemaRendererTexts;
+import { SchemaRendererVariant } from '../../types/json-schema';
+import { JsonSchema, JsonSchemaDef, SchemaRendererTexts } from '../../models/json-schema';
+export { SchemaRendererVariant, SchemaDisplayMode, SchemaOrientation, JsonSchemaType, } from '../../types/json-schema';
+export type { DialMeta, JsonSchemaDef, JsonSchema, ValidationError, SchemaRendererTexts, } from '../../models/json-schema';
+export { DEFAULT_SCHEMA_TEXTS } from '../../constants/schema-renderer';
 export interface DialSchemaRendererProps {
     schema: JsonSchema;
     defaultValue?: Record<string, unknown>;

package/dist/src/components/SchemaRenderer/utils.d.ts

@@ -1,22 +1 @@
-import { JsonSchemaType, JsonSchema, JsonSchemaDef, ValidationError } from './types';
-export declare function resolveRef(schema: JsonSchemaDef, rootSchema: JsonSchema, depth?: number): JsonSchemaDef;
-export declare function sortByPropertyOrder(entries: [string, JsonSchemaDef][]): [string, JsonSchemaDef][];
-export declare function isMissingRequiredValue(value: unknown): boolean;
-export declare function isObjectType(schema: JsonSchemaDef): boolean;
-export declare function toFieldLabel(key: string): string;
-/**
- * Builds the "required" error message for a field. The label is quoted so a
- * long title stays visually separate from the "is required" suffix.
- */
-export declare const toRequiredMessage: (label: string) => string;
-export declare function getOptionLabel(schema: JsonSchemaDef, rootSchema: JsonSchema): string;
-export declare function extractDefaults(schema: JsonSchemaDef, rootSchema: JsonSchema, depth?: number): unknown;
-export declare function validateRequired(value: unknown, schema: JsonSchemaDef, rootSchema: JsonSchema, path?: string, depth?: number): ValidationError[];
-export declare function buildSummary(value: unknown, schema: JsonSchemaDef, rootSchema: JsonSchema): string;
-export declare function detectAnyOfVariant(value: unknown, schemas: JsonSchemaDef[], rootSchema: JsonSchema): number;
-export declare function getItemTitle(item: unknown, discriminatorProp: string | undefined, index: number): string;
-export declare function getSchemaDefault(schema: JsonSchemaDef): unknown;
-export type EntryType = JsonSchemaType.String | JsonSchemaType.Number | JsonSchemaType.Boolean | JsonSchemaType.Null | JsonSchemaType.Object | JsonSchemaType.Array;
-export declare const ENTRY_TYPE_OPTIONS: EntryType[];
-export declare function inferEntryType(value: unknown): EntryType;
-export declare function getEntryTypeDefault(type: EntryType): unknown;
+export * from '../../utils/json-schema';

package/dist/src/constants/public-class-names.d.ts

@@ -111,6 +111,14 @@ export declare const DIAL_KIT_CLASS: {
     readonly inlineSelect: "dial-kit-inline-select";
     /** The root of a `Calendar`, wrapping its label and date field. */
     readonly calendar: "dial-kit-calendar";
+    /** The root of a `SchemaRenderer`, wrapping its top-level sections or fields. */
+    readonly schemaRenderer: "dial-kit-schema-renderer";
+    /**
+     * The card of one collapsible `SchemaRenderer` section, at any depth: a
+     * top-level property, a nested object or array, an array item, or a
+     * key-value entry holding an object.
+     */
+    readonly schemaRendererSection: "dial-kit-schema-renderer-section";
     /** The drop area of a `FileDropzone`. */
     readonly fileDropzone: "dial-kit-file-dropzone";
     /**

package/dist/src/constants/schema-renderer.d.ts

@@ -0,0 +1,2 @@
+import { SchemaRendererTexts } from '../models/json-schema';
+export declare const DEFAULT_SCHEMA_TEXTS: SchemaRendererTexts;

package/dist/src/index.d.ts

@@ -146,7 +146,9 @@ export { NOT_ALLOWED_SYMBOLS, NOT_ALLOWED_SPACES, NOT_ALLOWED_SYMBOLS_REGEXP, NO
 export { DIAL_KIT_CLASS } from './constants/public-class-names';
 export { DialSchemaRenderer } from './components/SchemaRenderer/SchemaRenderer';
 export { SchemaRendererVariant, SchemaDisplayMode, SchemaOrientation, JsonSchemaType, } from './components/SchemaRenderer/types';
-export type { DialSchemaRendererProps, JsonSchema, JsonSchemaDef, ValidationError, } from './components/SchemaRenderer/types';
+export type { DialSchemaRendererProps, JsonSchema, JsonSchemaDef, ValidationError, SchemaRendererTexts, } from './components/SchemaRenderer/types';
+export { SchemaRenderer } from './components/New/SchemaRenderer/SchemaRenderer';
+export type { SchemaRendererProps, SchemaRenderField, } from './components/New/SchemaRenderer/types';
 export { LazyDialJsonEditor } from './components/JsonEditor/lazy';
 export { LazyDialMarkdownEditor } from './components/MarkdownEditor/lazy';
 export { NotificationVariant, NotificationType } from './types/notification.ts';