@gravity-ui/dynamic-forms 5.19.0 → 5.19.1

package/build/cjs/lib/unstable/core/types/validation.d.ts

@@ -0,0 +1,39 @@
+import type { SchemaToValueType } from './helpers';
+import type { JsonSchema } from './schema';
+import type { ObjectValue } from './values';
+type ArrayError = SyncValidateError[];
+interface ObjectError extends Record<string, SyncValidateError> {
+}
+export type SyncValidateError = ArrayError | boolean | string | ObjectError | undefined;
+export type AsyncValidateError = Promise<SyncValidateError>;
+export type SyncValidator<Schema extends JsonSchema> = (value: SchemaToValueType<Schema> | null | undefined, allValues: ObjectValue) => SyncValidateError;
+export type AsyncValidator<Schema extends JsonSchema> = (value: SchemaToValueType<Schema> | null | undefined, allValues: ObjectValue) => AsyncValidateError;
+export type Validator<Schema extends JsonSchema> = SyncValidator<Schema> | AsyncValidator<Schema>;
+export interface ErrorMessages {
+    additionalItems?: string;
+    additionalProperties?: string;
+    anyOf?: string;
+    const?: string;
+    contains?: string;
+    dependencies?: string;
+    enum?: string;
+    exclusiveMaximum?: string;
+    exclusiveMinimum?: string;
+    maxItems?: string;
+    maxLength?: string;
+    maxProperties?: string;
+    maximum?: string;
+    minItems?: string;
+    minLength?: string;
+    minProperties?: string;
+    minimum?: string;
+    multipleOf?: string;
+    not?: string;
+    oneOf?: string;
+    pattern?: string;
+    propertyNames?: string;
+    required?: string;
+    type?: string;
+    uniqueItems?: string;
+}
+export {};

package/build/cjs/lib/unstable/core/types/values.d.ts

@@ -0,0 +1,4 @@
+export type ArrayValue = FieldValue[];
+export interface ObjectValue extends Record<string, FieldValue> {
+}
+export type FieldValue = number | boolean | string | ArrayValue | ObjectValue | null | undefined;

package/build/cjs/lib/unstable/core/useSchemaRenderer/constants.d.ts

@@ -0,0 +1 @@
+export declare const ENTITY_SERVICE_FIELD = "ENTITY_SERVICE_FIELD";

package/build/cjs/lib/unstable/core/useSchemaRenderer/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { useEntitiesState } from './useEntitiesState';
+export { useSchemaRendererMutators } from './useSchemaRendererMutators';

package/build/cjs/lib/unstable/core/useSchemaRenderer/hooks/useEntitiesState.d.ts

@@ -0,0 +1,7 @@
+export declare const useEntitiesState: (name: string) => {
+    config: import("../..").SchemaRendererConfig | undefined;
+    error: import("../..").SyncValidateError;
+    headName: string | undefined;
+    mode: import("../..").SchemaRendererMode | undefined;
+    rootSchema: import("../..").JsonSchema | undefined;
+};

package/build/cjs/lib/unstable/core/useSchemaRenderer/hooks/useSchemaRendererMutators.d.ts

@@ -0,0 +1,10 @@
+import type { RemoveExternalErrorsMutator, RemoveSchemaMutatorsMutator, SetAsyncValidationCacheMutator, SetAsyncValidationWaitersMutator, SetExternalErrorsMutator, SetSchemaMutatorsMutator, TriggerFieldsMutator } from '../mutators';
+export declare const useSchemaRendererMutators: () => {
+    removeExternalErrors: RemoveExternalErrorsMutator | undefined;
+    removeSchemaMutators: RemoveSchemaMutatorsMutator | undefined;
+    setAsyncValidationCache: SetAsyncValidationCacheMutator | undefined;
+    setAsyncValidationWaiters: SetAsyncValidationWaitersMutator | undefined;
+    setExternalErrors: SetExternalErrorsMutator | undefined;
+    setSchemaMutators: SetSchemaMutatorsMutator | undefined;
+    triggerFields: TriggerFieldsMutator | undefined;
+};

package/build/cjs/lib/unstable/core/useSchemaRenderer/index.d.ts

@@ -0,0 +1,3 @@
+export { useEntitiesState, useSchemaRendererMutators } from './hooks';
+export { schemaRendererMutators } from './mutators';
+export { type UseSchemaRendererParams, type UseSchemaRendererReturn, useSchemaRenderer, } from './useSchemaRenderer';

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/async-validation/async-validation.d.ts

@@ -0,0 +1,3 @@
+import type { SetAsyncValidationCacheFunction, SetAsyncValidationWaitersFunction } from './types';
+export declare const setAsyncValidationWaiters: SetAsyncValidationWaitersFunction;
+export declare const setAsyncValidationCache: SetAsyncValidationCacheFunction;

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/async-validation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './async-validation';
+export * from './types';

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/async-validation/types.d.ts

@@ -0,0 +1,34 @@
+import type { MutableState, Tools } from 'final-form';
+import type { FieldValue, JsonSchema, SyncValidateError, Validator } from '../../../types';
+export interface AsyncValidationWaiter {
+    schema: JsonSchema;
+    validator: Validator<JsonSchema>;
+    value: FieldValue;
+}
+export interface AsyncValidationCache extends AsyncValidationWaiter {
+    result: SyncValidateError;
+}
+export interface AsyncValidationState {
+    cache?: {
+        [key: string]: AsyncValidationCache[] | undefined;
+    };
+    waiters?: {
+        [key: string]: AsyncValidationWaiter | undefined;
+    };
+}
+export interface SetAsyncValidationWaitersParams {
+    headName: string;
+    waiters: {
+        [key: string]: AsyncValidationWaiter;
+    };
+}
+export type SetAsyncValidationWaitersFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetAsyncValidationWaitersParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type SetAsyncValidationWaitersMutator = (params: SetAsyncValidationWaitersParams) => void;
+export interface SetAsyncValidationCacheParams {
+    cache: {
+        [key: string]: AsyncValidationCache;
+    };
+    headName: string;
+}
+export type SetAsyncValidationCacheFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetAsyncValidationCacheParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type SetAsyncValidationCacheMutator = (params: SetAsyncValidationCacheParams) => void;

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/external-errors/external-errors.d.ts

@@ -0,0 +1,3 @@
+import type { RemoveExternalErrorsFunction, SetExternalErrorsFunction } from './types';
+export declare const setExternalErrors: SetExternalErrorsFunction;
+export declare const removeExternalErrors: RemoveExternalErrorsFunction;

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/external-errors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './external-errors';
+export * from './types';

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/external-errors/types.d.ts

@@ -0,0 +1,25 @@
+import type { MutableState, Tools } from 'final-form';
+import type { SyncValidateError } from '../../../types';
+export interface ExternalErrorsState {
+    priorityErrors?: {
+        [key: string]: SyncValidateError;
+    };
+    regularErrors?: {
+        [key: string]: SyncValidateError;
+    };
+}
+export interface SetExternalErrorsParams {
+    priorityErrors?: {
+        [key: string]: SyncValidateError;
+    };
+    regularErrors?: {
+        [key: string]: SyncValidateError;
+    };
+}
+export type SetExternalErrorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetExternalErrorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type SetExternalErrorsMutator = (params: SetExternalErrorsParams) => void;
+export interface RemoveExternalErrorsParams {
+    removeFunctionOrNames: string[] | ((headName: string, state: ExternalErrorsState) => ExternalErrorsState);
+}
+export type RemoveExternalErrorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [RemoveExternalErrorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type RemoveExternalErrorsMutator = (params: RemoveExternalErrorsParams) => void;

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/index.d.ts

@@ -0,0 +1,13 @@
+export type * from './async-validation';
+export type * from './external-errors';
+export type * from './schema-mutators';
+export type * from './trigger-fields';
+export declare const schemaRendererMutators: {
+    removeExternalErrors: import("./external-errors").RemoveExternalErrorsFunction;
+    removeSchemaMutators: import("./schema-mutators").RemoveSchemaMutatorsFunction;
+    setAsyncValidationCache: import("./async-validation").SetAsyncValidationCacheFunction;
+    setAsyncValidationWaiters: import("./async-validation").SetAsyncValidationWaitersFunction;
+    setExternalErrors: import("./external-errors").SetExternalErrorsFunction;
+    setSchemaMutators: import("./schema-mutators").SetSchemaMutatorsFunction;
+    triggerFields: import("./trigger-fields").TriggerFieldsFunction;
+};

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './schema-mutators';
+export * from './types';

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/schema-mutators.d.ts

@@ -0,0 +1,3 @@
+import type { RemoveSchemaMutatorsFunction, SetSchemaMutatorsFunction } from './types';
+export declare const setSchemaMutators: SetSchemaMutatorsFunction;
+export declare const removeSchemaMutators: RemoveSchemaMutatorsFunction;

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/types.d.ts

@@ -0,0 +1,26 @@
+import type { MutableState, Tools } from 'final-form';
+import type { JsonSchema } from '../../../types';
+export interface SchemaMutatorsState {
+    mutators?: {
+        name: string;
+        schema: JsonSchema;
+    }[];
+    originalSchema?: JsonSchema;
+    schema?: JsonSchema;
+}
+export interface SetSchemaMutatorsParams {
+    mutators: {
+        name: string;
+        schema: JsonSchema;
+    }[];
+}
+export type SetSchemaMutatorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetSchemaMutatorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type SetSchemaMutatorsMutator = (params: SetSchemaMutatorsParams) => void;
+export interface RemoveSchemaMutatorsParams {
+    mutatorsToRemove: {
+        name: string;
+        schema: JsonSchema | true;
+    }[];
+}
+export type RemoveSchemaMutatorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [RemoveSchemaMutatorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type RemoveSchemaMutatorsMutator = (params: RemoveSchemaMutatorsParams) => void;

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/index.d.ts

@@ -0,0 +1,2 @@
+export * from './trigger-fields';
+export * from './types';

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/trigger-fields.d.ts

@@ -0,0 +1,2 @@
+import type { TriggerFieldsFunction } from './types';
+export declare const triggerFields: TriggerFieldsFunction;

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/types.d.ts

@@ -0,0 +1,6 @@
+import type { MutableState, Tools } from 'final-form';
+export interface TriggerFieldsParams {
+    fields: string[];
+}
+export type TriggerFieldsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [TriggerFieldsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type TriggerFieldsMutator = (params: TriggerFieldsParams) => void;

package/build/cjs/lib/unstable/core/useSchemaRenderer/types.d.ts

@@ -0,0 +1,22 @@
+import type { ErrorObject } from 'ajv';
+import type { SchemaRendererMode } from '../constants';
+import type { FieldValue, JsonSchema, SchemaRendererConfig, SyncValidateError, Validator } from '../types';
+import type { AsyncValidationState, ExternalErrorsState, SchemaMutatorsState } from './mutators';
+export type EntityParametersError = ErrorObject<'entityParameters', {
+    schema: JsonSchema;
+    validator: Validator<JsonSchema>;
+    value: FieldValue;
+}>;
+export interface ValidateErrorItem {
+    error: SyncValidateError;
+    path: string[];
+}
+export interface EntitiesState {
+    config?: SchemaRendererConfig;
+    errorsRef?: React.RefObject<Record<string, SyncValidateError>>;
+    headName?: string;
+    mode?: SchemaRendererMode;
+    schema?: SchemaMutatorsState['schema'];
+}
+export interface SchemaRendererState extends AsyncValidationState, ExternalErrorsState, SchemaMutatorsState {
+}

package/build/cjs/lib/unstable/core/useSchemaRenderer/useSchemaRenderer.d.ts

@@ -0,0 +1,37 @@
+import type { FieldValidator } from 'final-form';
+import { type SchemaRendererMode } from '../constants';
+import type { ErrorMessages, FieldValue, JsonSchema, SchemaRendererConfig } from '../types';
+export interface UseSchemaRendererParams {
+    config: SchemaRendererConfig;
+    connectValidate?: boolean;
+    errorMessages?: ErrorMessages;
+    mode: SchemaRendererMode;
+    /**
+     * The `name` prop must be a non-empty string.
+     *
+     * In `final-form` and `react-final-form`, the `name` is used as a key to register
+     * the field within the form. If you pass an empty string (`name=""`), the field will
+     * not be registered, its value will not be tracked, and validation will not work.
+     *
+     * This can lead to:
+     * - the field being missing from the form `values`;
+     * - the `validate` function not being called;
+     * - no error or touched state updates;
+     * - inconsistent or broken form behavior.
+     *
+     * Always provide a unique, non-empty string for the field name.
+     */
+    name: string;
+    schema: JsonSchema;
+}
+export type UseSchemaRendererReturn = {
+    schema: JsonSchema | undefined;
+    validate: FieldValidator<FieldValue> | undefined;
+};
+export declare const useSchemaRenderer: ({ config, connectValidate, errorMessages, mode, name, schema: originalSchema, }: UseSchemaRendererParams) => {
+    schema: JsonSchema | undefined;
+    validate?: undefined;
+} | {
+    schema: JsonSchema | undefined;
+    validate: (value?: FieldValue) => any;
+};

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/common.d.ts

@@ -0,0 +1 @@
+export declare const guessHeadName: (registeredFields: string[], name: string) => string | undefined;

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/get-ajv-validate.d.ts

@@ -0,0 +1,11 @@
+import type { ErrorObject, ValidateFunction } from 'ajv';
+import type { JsonSchema, SchemaRendererConfig } from '../../types';
+import type { EntityParametersError } from '../types';
+export interface GetAjvValidateParams {
+    config: SchemaRendererConfig;
+    schema: JsonSchema;
+}
+export interface GetAjvValidateReturn extends ValidateFunction {
+    errors?: (ErrorObject | EntityParametersError)[];
+}
+export declare const getAjvValidate: ({ config, schema }: GetAjvValidateParams) => GetAjvValidateReturn;

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/get-validate.d.ts

@@ -0,0 +1,14 @@
+import { type FieldValidator } from 'final-form';
+import type { ErrorMessages, FieldValue, SchemaRendererConfig, SyncValidateError } from '../../types';
+import type { SetAsyncValidationCacheMutator, SetAsyncValidationWaitersMutator } from '../mutators';
+export type GetValidateParams = {
+    config: SchemaRendererConfig;
+    errorMessages: ErrorMessages;
+    name: string;
+    setAsyncValidationCache?: SetAsyncValidationCacheMutator;
+    setAsyncValidationWaiters?: SetAsyncValidationWaitersMutator;
+    setErrors: (errors: Record<string, SyncValidateError>) => void;
+};
+type GetValidateReturn = FieldValidator<FieldValue>;
+export declare const getValidate: ({ config, errorMessages, name, setAsyncValidationCache, setAsyncValidationWaiters, setErrors, }: GetValidateParams) => GetValidateReturn;
+export {};

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { guessHeadName } from './common';
+export { getValidate } from './get-validate';

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/process-ajv-error.d.ts

@@ -0,0 +1,10 @@
+import type { ErrorObject } from 'ajv';
+import type { ErrorMessages, JsonSchema } from '../../types';
+import type { ValidateErrorItem } from '../types';
+export interface ProcessAjvErrorParams<Schema extends JsonSchema> {
+    error: ErrorObject;
+    errorMessages: ErrorMessages;
+    schema: Schema;
+    onError: (error: ValidateErrorItem) => void;
+}
+export declare const processAjvError: <Schema extends JsonSchema>({ error, errorMessages, schema, onError, }: ProcessAjvErrorParams<Schema>) => void;

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/process-ajv-validate-errors.d.ts

@@ -0,0 +1,20 @@
+import type { ErrorObject } from 'ajv';
+import type { ErrorMessages, JsonSchema, ObjectValue } from '../../types';
+import type { AsyncValidationState, AsyncValidationWaiter, SetAsyncValidationCacheMutator } from '../mutators';
+import type { EntityParametersError, ValidateErrorItem } from '../types';
+export interface ProcessAjvValidateErrorsParams<Schema extends JsonSchema> {
+    ajvValidateErrors: (ErrorObject | EntityParametersError)[];
+    allValues: ObjectValue;
+    errorMessages: ErrorMessages;
+    name: string;
+    schema: Schema;
+    setAsyncValidationCache?: SetAsyncValidationCacheMutator;
+    validationState: AsyncValidationState | undefined;
+}
+interface ProcessAjvValidateErrorsReturn {
+    ajvErrorItems: ValidateErrorItem[];
+    entityParametersErrorItems: ValidateErrorItem[];
+    waiters: Record<string, AsyncValidationWaiter>;
+}
+export declare const processAjvValidateErrors: <Schema extends JsonSchema>({ ajvValidateErrors, allValues, errorMessages, name, schema, setAsyncValidationCache, validationState, }: ProcessAjvValidateErrorsParams<Schema>) => ProcessAjvValidateErrorsReturn;
+export {};

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/process-entity-parameters-error.d.ts

@@ -0,0 +1,15 @@
+import type { AsyncValidateError, ObjectValue } from '../../types';
+import type { AsyncValidationState } from '../mutators';
+import type { EntityParametersError, ValidateErrorItem } from '../types';
+export interface ProcessEntityParametersErrorParams {
+    allValues: ObjectValue;
+    error: EntityParametersError;
+    onAsyncError: (waiter: {
+        instancePath: string;
+        params: EntityParametersError['params'];
+        promise: AsyncValidateError;
+    }) => void;
+    onError: (error: ValidateErrorItem) => void;
+    validationState: AsyncValidationState | undefined;
+}
+export declare const processEntityParametersError: ({ allValues, error, onAsyncError, onError, validationState, }: ProcessEntityParametersErrorParams) => void;

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/process-errors-state.d.ts

@@ -0,0 +1,12 @@
+import type { ExternalErrorsState } from '../mutators';
+import type { ValidateErrorItem } from '../types';
+interface ProcessErrorsStateParams {
+    errorsState: ExternalErrorsState | undefined;
+    name: string;
+}
+interface ProcessErrorsStateReturn {
+    externalPriorityErrorItems: ValidateErrorItem[];
+    externalRegularErrorItems: ValidateErrorItem[];
+}
+export declare const processErrorsState: ({ errorsState, name, }: ProcessErrorsStateParams) => ProcessErrorsStateReturn;
+export {};

package/build/cjs/lib/unstable/core/utils/common.d.ts

@@ -0,0 +1,49 @@
+import type { JsonSchema } from '../types';
+/**
+ * Parses an AJV `schemaPath` (JSON Pointer) into an array of path segments
+ * suitable for lodash `get`.
+ *
+ * Strips the `#/` prefix, decodes URI-encoded characters, splits on `/`,
+ * and unescapes JSON Pointer tokens (`~1` → `/`, `~0` → `~`).
+ *
+ * Returns all segments unchanged; stripping a trailing validation keyword
+ * (e.g. `minLength`) before lookup is the caller's responsibility.
+ *
+ * @param schemaPath - JSON Pointer string, e.g. `"#/properties/name/minLength"`.
+ * @returns Path segments, e.g. `['properties', 'name', 'minLength']`.
+ */
+export declare const parseSchemaPath: (schemaPath: string) => string[];
+export declare const parseInstancePath: (instancePath: string) => string[];
+export declare const parseFinalFormName: (finalFormName: string) => string[];
+export declare const formatFinalFormPath: (finalFormPath: string[]) => string;
+export declare const getSchemaPath: (finalFormNameOrPath: string | string[], finalFormHeadName: string, schema: JsonSchema) => string[] | undefined;
+/**
+ * Resolves a sub-schema from the root schema by an AJV `schemaPath`.
+ *
+ * Parses `schemaPath` via `parseSchemaPath` and looks up the node with lodash `get`.
+ * The path must point to a schema object, not to a validation keyword — callers
+ * should strip the trailing keyword first (see `processAjvError`).
+ *
+ * @param schemaPath - JSON Pointer string pointing to a schema node,
+ *   e.g. `"#/properties/name"`.
+ * @param schema - The root JSON schema object.
+ *
+ * @example
+ * const nameSchema = {
+ *   minLength: 5,
+ * };
+ * const objectSchema = {
+ *   properties: {
+ *     name: nameSchema,
+ *   },
+ * };
+ * getSchemaBySchemaPath("#/properties/name", objectSchema); // returns nameSchema
+ *
+ * @returns The sub-schema at the given path, or the root schema when the path is empty.
+ */
+export declare const getSchemaBySchemaPath: (schemaPath: string, schema: JsonSchema) => JsonSchema | undefined;
+export declare const getSchemaByInstancePath: (instancePath: string, schema: JsonSchema) => JsonSchema | undefined;
+export declare const getSchemaByFinalFormPath: (finalFormNameOrPath: string | string[], finalFormHeadName: string, schema: JsonSchema) => JsonSchema | undefined;
+export declare const getValuePaths: (value: unknown, path?: string[]) => string[][];
+export declare const smartSet: (object: object, path: string[], value: unknown) => object;
+export declare const smartMerge: (first: object, second: object, deep?: boolean) => {};

package/build/cjs/lib/unstable/core/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './common';

package/build/cjs/lib/unstable/kit/Accordeon.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { JsonSchema, WrapperProps } from '../core/types';
+export declare const Accordeon: <Schema extends JsonSchema>({ schema, input, meta, children, wrapperProps, }: WrapperProps<Schema>) => React.ReactNode;

package/build/cjs/lib/unstable/kit/Any.d.ts

@@ -0,0 +1,2 @@
+import type { Control, JsonSchemaAny } from '../core/types';
+export declare const AnyInput: Control<JsonSchemaAny>;

package/build/cjs/lib/unstable/kit/ArrayBase.d.ts

@@ -0,0 +1,2 @@
+import type { Control, JsonSchemaArray } from '../core/types';
+export declare const ArrayBase: Control<JsonSchemaArray>;

package/build/cjs/lib/unstable/kit/MultiSelect.d.ts

@@ -0,0 +1,6 @@
+import type { SelectProps as SelectBaseProps } from '@gravity-ui/uikit';
+import type { Control, JsonSchemaArray } from '../core/types';
+export interface MultiSelectProps extends Omit<SelectBaseProps, 'onUpdate' | 'value' | 'onOpenChange' | 'disabled' | 'placeholder' | 'filterPlaceholder' | 'multiple' | 'qa'> {
+    withCustomOptions?: boolean;
+}
+export declare const MultiSelect: Control<JsonSchemaArray>;

package/build/cjs/lib/unstable/kit/ObjectBase.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { Control, ControlProps, JsonSchemaObject } from '../core/types';
+export interface ObjectBaseProps extends ControlProps<JsonSchemaObject> {
+    inline?: boolean;
+}
+export declare const ObjectBase: React.FC<ObjectBaseProps>;
+export declare const ObjectInline: Control<JsonSchemaObject>;

package/build/cjs/lib/unstable/kit/Row.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { JsonSchema, WrapperProps } from '../core/types';
+export declare const Row: React.MemoExoticComponent<(<Schema extends JsonSchema>(props: WrapperProps<Schema, {
+    qtest: boolean;
+    qwa?: string;
+}>) => React.JSX.Element)>;
+export declare const RowVerbose: React.MemoExoticComponent<(<Schema extends JsonSchema>(props: WrapperProps<Schema, {
+    qtest: boolean;
+    qwa?: string;
+}>) => React.JSX.Element)>;

package/build/cjs/lib/unstable/kit/Text.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { type TextInputProps as TextInputBaseProps } from '@gravity-ui/uikit';
+import type { ControlProps, JsonSchemaNumber, JsonSchemaString } from '../core/types';
+export interface TextProps extends Omit<TextInputBaseProps, 'value' | 'onBlur' | 'onFocus' | 'onUpdate' | 'disabled' | 'placeholder' | 'qa'> {
+}
+export declare const Text: React.MemoExoticComponent<(<T extends ControlProps<JsonSchemaNumber, TextProps> | ControlProps<JsonSchemaString, TextProps>>({ input, meta, schema, }: T) => React.JSX.Element)>;

package/build/cjs/lib/unstable/kit/components/ArrayRemoveButton/ArrayRemoveButton.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export interface ArrayRemoveButtonProps {
+    name: string;
+}
+export declare const ArrayRemoveButton: React.FC<ArrayRemoveButtonProps>;

package/build/cjs/lib/unstable/kit/components/ArrayRemoveButton/index.d.ts

@@ -0,0 +1 @@
+export { ArrayRemoveButton, type ArrayRemoveButtonProps } from './ArrayRemoveButton';

package/build/cjs/lib/unstable/kit/components/ControlError/ControlError.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface ControlErrorProps {
+    className?: string;
+    errorMessage?: string;
+    validationState?: 'invalid';
+    children: React.ReactNode;
+}
+export declare const ControlError: React.FC<ControlErrorProps>;

package/build/cjs/lib/unstable/kit/components/ControlError/index.d.ts

@@ -0,0 +1 @@
+export { ControlError, type ControlErrorProps } from './ControlError';

package/build/cjs/lib/unstable/kit/components/HTMLContent/HTMLContent.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { type TextProps } from '@gravity-ui/uikit';
+export interface HTMLContentProps extends TextProps {
+    html: string;
+}
+export declare const HTMLContent: React.FC<HTMLContentProps>;

package/build/cjs/lib/unstable/kit/components/HTMLContent/index.d.ts

@@ -0,0 +1 @@
+export { HTMLContent, type HTMLContentProps } from './HTMLContent';

package/build/cjs/lib/unstable/kit/components/index.d.ts

@@ -0,0 +1,3 @@
+export { ArrayRemoveButton, type ArrayRemoveButtonProps } from './ArrayRemoveButton';
+export { ControlError, type ControlErrorProps } from './ControlError';
+export { HTMLContent, type HTMLContentProps } from './HTMLContent';

package/build/cjs/lib/unstable/kit/config.d.ts

@@ -0,0 +1,95 @@
+import type { AsyncValidator, SchemaRendererConfig, SyncValidator } from '../core/types';
+import type { JsonSchemaArray, JsonSchemaBoolean, JsonSchemaNumber, JsonSchemaObject, JsonSchemaString } from '../core/types/schema';
+export declare const untypedConfig: {
+    readonly any: {
+        readonly controls: {
+            readonly baseAny: {
+                readonly Component: import("../core/types").Control<import("../core/types").JsonSchemaAny<any>>;
+            };
+        };
+        readonly views: {};
+        readonly wrappers: {};
+        readonly validators: {};
+    };
+    readonly array: {
+        readonly controls: {
+            readonly selectArray: {
+                readonly Component: import("../core/types").Control<JsonSchemaArray<any>>;
+            };
+            readonly baseArray: {
+                readonly Component: import("../core/types").Control<JsonSchemaArray<any>>;
+            };
+        };
+        readonly views: {};
+        readonly wrappers: {
+            readonly accordeonArray: <Schema extends import("../core/types").JsonSchema>({ schema, input, meta, children, wrapperProps, }: import("../core/types").WrapperProps<Schema>) => React.ReactNode;
+            readonly rowArray: import("react").MemoExoticComponent<(<Schema extends import("../core/types").JsonSchema>(props: import("../core/types").WrapperProps<Schema, {
+                qtest: boolean;
+                qwa?: string;
+            }>) => import("react").JSX.Element)>;
+        };
+        readonly validators: {
+            readonly baseArray: SyncValidator<JsonSchemaArray>;
+        };
+    };
+    readonly boolean: {
+        readonly controls: {};
+        readonly views: {};
+        readonly wrappers: {};
+        readonly validators: {
+            readonly baseBoolean: SyncValidator<JsonSchemaBoolean>;
+        };
+    };
+    readonly number: {
+        readonly controls: {
+            readonly baseNumber: {
+                readonly Component: import("react").MemoExoticComponent<(<T extends import("../core/types").ControlProps<JsonSchemaNumber, import("./Text").TextProps> | import("../core/types").ControlProps<JsonSchemaString, import("./Text").TextProps>>({ input, meta, schema, }: T) => import("react").JSX.Element)>;
+            };
+        };
+        readonly views: {};
+        readonly wrappers: {
+            readonly rowNumber: import("react").MemoExoticComponent<(<Schema extends import("../core/types").JsonSchema>(props: import("../core/types").WrapperProps<Schema, {
+                qtest: boolean;
+                qwa?: string;
+            }>) => import("react").JSX.Element)>;
+        };
+        readonly validators: {
+            readonly baseNumber: () => boolean;
+            readonly asyncNumber: AsyncValidator<JsonSchemaNumber>;
+        };
+    };
+    readonly object: {
+        readonly controls: {
+            readonly baseObject: {
+                readonly Component: import("react").FC<import("./ObjectBase").ObjectBaseProps>;
+                readonly independent: true;
+            };
+        };
+        readonly views: {};
+        readonly wrappers: {
+            readonly accordeonObject: <Schema extends import("../core/types").JsonSchema>({ schema, input, meta, children, wrapperProps, }: import("../core/types").WrapperProps<Schema>) => React.ReactNode;
+        };
+        readonly validators: {
+            readonly baseObject: SyncValidator<JsonSchemaObject>;
+        };
+    };
+    readonly string: {
+        readonly controls: {
+            readonly baseString: {
+                readonly Component: import("react").MemoExoticComponent<(<T extends import("../core/types").ControlProps<JsonSchemaNumber, import("./Text").TextProps> | import("../core/types").ControlProps<JsonSchemaString, import("./Text").TextProps>>({ input, meta, schema, }: T) => import("react").JSX.Element)>;
+            };
+        };
+        readonly views: {};
+        readonly wrappers: {
+            readonly rowString: import("react").MemoExoticComponent<(<Schema extends import("../core/types").JsonSchema>(props: import("../core/types").WrapperProps<Schema, {
+                qtest: boolean;
+                qwa?: string;
+            }>) => import("react").JSX.Element)>;
+        };
+        readonly validators: {
+            readonly baseString: SyncValidator<JsonSchemaString>;
+            readonly cccString: SyncValidator<JsonSchemaString>;
+        };
+    };
+};
+export declare const config: SchemaRendererConfig;