@schema-forms-data/renderer 0.3.21

package/dist/index.d.ts

@@ -0,0 +1,773 @@
+import { Context } from 'react';
+import { Control } from 'react-hook-form';
+import { default as default_2 } from 'react';
+import { FieldConditionalExpr } from '@schema-forms-data/core';
+import { FieldOption } from '@schema-forms-data/core';
+import { FieldValidation } from '@schema-forms-data/core';
+import { FieldValidatorConfig } from '@schema-forms-data/core';
+import { FormContainer } from '@schema-forms-data/core';
+import { FormField } from '@schema-forms-data/core';
+import { FormSchema } from '@schema-forms-data/core';
+import { FormStep } from '@schema-forms-data/core';
+import { JSX as JSX_2 } from 'react/jsx-runtime';
+import { Resolver } from 'react-hook-form';
+
+declare interface CepFillMap {
+    logradouro?: string;
+    bairro?: string;
+    cidade?: string;
+    estado?: string;
+}
+
+export declare interface CepLookupResult {
+    logradouro?: string;
+    bairro?: string;
+    cidade?: string;
+    estado?: string;
+    erro?: boolean;
+}
+
+/**
+ * Mapa de componentes customizados indexados pelo `tipo` do campo.
+ *
+ * Registre componentes para **substituir** ou **complementar** os defaults do renderer.
+ * Funciona para todos os `FieldType` existentes e também para tipos customizados.
+ *
+ * @example
+ * ```tsx
+ * import { FieldType } from '@schema-forms-data/core';
+ *
+ * const componentMapper: ComponentMapper = {
+ *   // Substitui o DFTextField padrão pelo Input do shadcn/ui
+ *   [FieldType.TEXTO]: MeuTextField,
+ *   // Adiciona um novo tipo de campo 'rating-stars'
+ *   'rating-stars': MeuRatingStars,
+ * };
+ *
+ * <FormRenderer schema={schema} componentMapper={componentMapper} />
+ * ```
+ */
+export declare type ComponentMapper = Record<string, React.ComponentType<FieldComponentProps>>;
+
+export declare const ContainerRenderer: (props: ContainerRendererProps) => JSX_2.Element;
+
+declare interface ContainerRendererProps {
+    container: FormContainer;
+    control: Control<Record<string, unknown>>;
+}
+
+export declare const DFCepField: ({ name, control, placeholder, disabled, readOnly, cepFillMap, }: DFCepFieldProps) => JSX_2.Element;
+
+declare interface DFCepFieldProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    /** Mapa de nomes de campos a preencher após lookup. Quando ausente usa `_address_*`. */
+    cepFillMap?: CepFillMap;
+}
+
+export declare const DFCheckbox: ({ name, control, label, disabled, readOnly, }: DFCheckboxProps) => JSX_2.Element;
+
+export declare const DFCheckboxGroup: ({ name, control, options, disabled, }: DFCheckboxGroupProps) => JSX_2.Element;
+
+declare interface DFCheckboxGroupProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+    options: FieldOption[];
+    disabled?: boolean;
+}
+
+declare interface DFCheckboxProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+    label?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+}
+
+export declare const DFDateField: ({ name, control, isDatetime, disabled, readOnly, validacao, }: DFDateFieldProps) => JSX_2.Element;
+
+declare interface DFDateFieldProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+    placeholder?: string;
+    isDatetime?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    validacao?: FieldValidation;
+}
+
+export declare const DFFieldArray: ({ name, control, subFields, minItems, maxItems, itemLabel, addLabel, }: DFFieldArrayProps) => JSX_2.Element;
+
+declare interface DFFieldArrayProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+    subFields?: FormField[];
+    minItems?: number;
+    maxItems?: number;
+    itemLabel?: string;
+    addLabel?: string;
+}
+
+export declare const DFFileUpload: ({ name, control, disabled, campo, fileTypes, maxFileSize, }: DFFileUploadProps) => JSX_2.Element;
+
+declare interface DFFileUploadProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+    disabled?: boolean;
+    campo?: string;
+    fileTypes?: string[];
+    maxFileSize?: number;
+}
+
+export declare const DFHidden: ({ name, control }: DFHiddenProps) => JSX_2.Element;
+
+declare interface DFHiddenProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+}
+
+export declare const DFMaskedInput: ({ name, control, placeholder, maskType, disabled, readOnly, }: DFMaskedInputProps) => JSX_2.Element;
+
+declare interface DFMaskedInputProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+    placeholder?: string;
+    maskType?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+}
+
+export declare const DFParticipationType: ({ name, control }: DFParticipationTypeProps) => JSX_2.Element;
+
+export declare interface DFParticipationTypeProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+}
+
+export declare const DFPaymentMethod: ({ name, control, relatedFieldName, }: DFPaymentMethodProps) => JSX_2.Element;
+
+export declare interface DFPaymentMethodProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+    /** Nome do campo de tipo de participação a ser observado. Padrão: `"tipo_participacao"`. */
+    relatedFieldName?: string;
+}
+
+export declare const DFRadioGroup: ({ name, control, options, visualStyle, disabled, }: DFRadioGroupProps) => JSX_2.Element;
+
+declare interface DFRadioGroupProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+    options: FieldOption[];
+    visualStyle?: "default" | "card";
+    disabled?: boolean;
+}
+
+export declare const DFSelect: ({ name, control, placeholder, options, disabled, readOnly, }: DFSelectProps) => JSX_2.Element;
+
+declare interface DFSelectProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+    placeholder?: string;
+    options: FieldOption[];
+    disabled?: boolean;
+    readOnly?: boolean;
+}
+
+export declare const DFTerms: ({ name, control, label, termoTexto, termoPdfUrl, termoPdfUploadId, }: DFTermsProps) => JSX_2.Element;
+
+declare interface DFTermsProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+    label?: string;
+    termoTexto?: string;
+    termoPdfUrl?: string;
+    /** ID do upload armazenado. Quando presente, busca URL via `resolveTermsUploadUrl` do context. */
+    termoPdfUploadId?: string;
+}
+
+export declare const DFTextarea: ({ name, control, placeholder, disabled, readOnly, }: DFTextareaProps) => JSX_2.Element;
+
+declare interface DFTextareaProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+}
+
+export declare const DFTextField: ({ name, control, placeholder, type, disabled, readOnly, }: DFTextFieldProps) => JSX_2.Element;
+
+declare interface DFTextFieldProps {
+    name: string;
+    control: Control<Record<string, unknown>>;
+    placeholder?: string;
+    type?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+}
+
+/**
+ * Avalia uma FieldConditionalExpr recursivamente.
+ */
+export declare const evaluateFieldCondition: (cond: FieldConditionalExpr | undefined, values: Record<string, unknown>, externalData?: Record<string, unknown>) => boolean;
+
+/**
+ * API de campo com props de input e metadados.
+ * Retornada por `useFieldApi(name)` — use para criar componentes de campo customizados.
+ */
+export declare interface FieldApiReturn {
+    /** Props prontas para passar num element de input (`<input {...input} />`) */
+    input: {
+        name: string;
+        value: unknown;
+        onChange: (...args: unknown[]) => void;
+        onBlur: () => void;
+        ref: React.Ref<unknown>;
+    };
+    /** Metadados de estado do campo */
+    meta: {
+        error?: string;
+        warning?: string;
+        touched: boolean;
+        dirty: boolean;
+        valid: boolean;
+    };
+}
+
+/**
+ * Props recebidas por qualquer componente registrado no `componentMapper`.
+ *
+ * O campo `field` já vem **resolvido** (após `resolveProps` e `opcoesFromVar`),
+ * então o componente customizado pode ler `field.opcoes`, `field.isDisabled`, etc.
+ *
+ * @example
+ * ```tsx
+ * const MeuTextField: React.FC<FieldComponentProps> = ({ name, control, field }) => (
+ *   <Controller
+ *     name={name}
+ *     control={control}
+ *     render={({ field: f, fieldState }) => (
+ *       <MyInput
+ *         {...f}
+ *         label={field.label}
+ *         error={fieldState.error?.message}
+ *         disabled={field.isDisabled}
+ *       />
+ *     )}
+ *   />
+ * );
+ * ```
+ */
+export declare interface FieldComponentProps {
+    /** Nome do campo no formulário (path do react-hook-form) */
+    name: string;
+    /** Control do react-hook-form da etapa atual */
+    control: Control<Record<string, unknown>>;
+    /** Field config resolvido — contém label, opcoes, isDisabled, placeholder, etc. */
+    field: FormField;
+}
+
+/**
+ * Tipo de um resolver de props de campo.
+ * Recebe o field original, os valores atuais do form e os dados externos,
+ * e retorna um objeto parcial que é mesclado sobre o field antes da renderização.
+ *
+ * @example
+ * ```ts
+ * const resolvers: FieldResolvers = {
+ *   // Carrega opções de camiseta dinamicamente baseado no evento
+ *   opcoes_camiseta: (field, _values, external) => ({
+ *     opcoes: (external['evento.tamanhosCamiseta'] as string[])
+ *       ?.map(t => ({ valor: t, label: t })) ?? field.opcoes,
+ *   }),
+ *   // Desabilita campo se participante já pagou
+ *   forma_pagamento: (_field, values) => ({
+ *     isDisabled: values['pagamento_confirmado'] === true,
+ *   }),
+ * };
+ * ```
+ */
+export declare type FieldResolver = (field: FormField, formValues: Record<string, unknown>, externalData: Record<string, unknown>) => Partial<FormField>;
+
+export declare type FieldResolvers = Record<string, FieldResolver>;
+
+/**
+ * Estado de um campo individual.
+ * Retornado por `useField(name)`.
+ */
+export declare interface FieldState {
+    /** Valor atual do campo */
+    value: unknown;
+    /** Mensagem de erro de validação, se houver */
+    error?: string;
+    /** Mensagem de aviso (warn), se houver */
+    warning?: string;
+    /** `true` se o campo foi alterado em relação ao defaultValue */
+    dirty: boolean;
+    /** `true` se o campo já recebeu foco e perdeu */
+    touched: boolean;
+    /** `true` se o campo não tem erros */
+    valid: boolean;
+}
+
+/**
+ * Função validadora customizada registrada no `validatorMapper`.
+ *
+ * Recebe:
+ * - `value` — valor atual do campo
+ * - `allValues` — todos os valores do step (cross-field)
+ * - `config` — configuração do validador (`type`, `message` e params extras)
+ * - `externalData` — dados externos do formulário
+ *
+ * Retorna `undefined` se válido, ou a mensagem de erro (sync ou async).
+ *
+ * @example
+ * ```ts
+ * const validatorMapper: ValidatorMapper = {
+ *   cpfUnico: async (value, _allValues, _config, external) => {
+ *     const exists = await api.checkCpf(String(value), external['evento.id']);
+ *     return exists ? 'CPF já cadastrado' : undefined;
+ *   },
+ *   senhasIguais: (value, allValues, config) => {
+ *     const other = allValues[config['field'] as string];
+ *     return value === other ? undefined : 'As senhas não conferem';
+ *   },
+ * };
+ * ```
+ */
+export declare type FieldValidatorFn = (value: unknown, allValues: Record<string, unknown>, config: FieldValidatorConfig, externalData: Record<string, unknown>) => string | undefined | Promise<string | undefined>;
+
+/**
+ * API programática do formulário, acessível de qualquer componente filho.
+ * Retornada por `useFormApi()`.
+ */
+export declare interface FormApi {
+    /**
+     * Altera o valor de um campo e dispara a revalidação.
+     * Equivalente a `setValue(name, value, { shouldValidate: true })`.
+     */
+    change: (name: string, value: unknown) => void;
+    /**
+     * Dispara o submit do formulário (equivale ao clique no botão "Próximo/Finalizar").
+     */
+    submit: () => void;
+    /**
+     * Reseta o formulário para os valores fornecidos (ou os `defaultValues`).
+     */
+    reset: (values?: Record<string, unknown>) => void;
+    /**
+     * Retorna um snapshot síncrono do estado atual do formulário.
+     */
+    getState: () => FormStateSnapshot;
+}
+
+export declare const FormRenderer: ({ schema, initialValues, initialStep, onSubmitStep, onComplete, template, formTitle, externalData, fieldErrors, uploadFile, cepLookup, resolveTermsUploadUrl, fieldResolvers, validatorMapper, componentMapper, paymentMethodOptions, onValuesChange, className, StepIndicator, }: FormRendererProps) => JSX_2.Element;
+
+export declare interface FormRendererProps {
+    schema: FormSchema;
+    initialValues?: Record<string, unknown>;
+    /** Step inicial (0-based), restaurado do backend */
+    initialStep?: number;
+    onSubmitStep?: (stepIndex: number, data: Record<string, unknown>) => Promise<void>;
+    onComplete?: (data: Record<string, unknown>) => Promise<void>;
+    /** Template visual — define cores e estilo dos containers */
+    template?: string | null;
+    /** Título exibido no topo (era eventoNome) */
+    formTitle?: string;
+    /** Dados externos/contextuais para interpolação e campos especiais (era eventoData) */
+    externalData?: Record<string, unknown>;
+    /** Erros de campo vindos do servidor (ex: validação 422) */
+    fieldErrors?: Record<string, string>;
+    uploadFile?: RendererContextValue["uploadFile"];
+    cepLookup?: RendererContextValue["cepLookup"];
+    resolveTermsUploadUrl?: RendererContextValue["resolveTermsUploadUrl"];
+    /**
+     * Mapa de resolvers de props de campo para `resolvePropsKey`.
+     * @see FieldResolvers
+     */
+    fieldResolvers?: FieldResolvers;
+    /**
+     * Mapa de validadores customizados para `validate` e `warn` dos campos.
+     * @see ValidatorMapper
+     */
+    validatorMapper?: ValidatorMapper;
+    /**
+     * Mapa de componentes customizados por tipo de campo.
+     * Substitui (ou estende) os componentes internos do renderer.
+     *
+     * @example
+     * ```tsx
+     * import { FieldType } from '@schema-forms-data/core';
+     *
+     * <FormRenderer
+     *   schema={schema}
+     *   componentMapper={{
+     *     [FieldType.TEXTO]: MeuTextField,
+     *     [FieldType.SELECT]: MeuSelect,
+     *   }}
+     * />
+     * ```
+     */
+    componentMapper?: ComponentMapper;
+    /**
+     * Opções customizadas de pagamento para o `DFPaymentMethod`.
+     * Substitui os defaults do modelo IPB para `porDia` e/ou `todosOsDias`.
+     * @see PaymentOption
+     */
+    paymentMethodOptions?: RendererContextValue["paymentMethodOptions"];
+    /**
+     * Chamada sempre que qualquer campo do step atual for alterado.
+     * Recebe os valores atuais do step — útil para autosave, analytics, etc.
+     *
+     * @example
+     * ```tsx
+     * <FormRenderer
+     *   schema={schema}
+     *   onValuesChange={(values) => sessionStorage.setItem('draft', JSON.stringify(values))}
+     * />
+     * ```
+     */
+    onValuesChange?: (values: Record<string, unknown>) => void;
+    className?: string;
+    /** Componente indicador de progress steps customizado */
+    StepIndicator?: React.ComponentType<StepIndicatorProps>;
+}
+
+/**
+ * Componente observador do estado do formulário.
+ * Deve ser montado dentro do `<FormRenderer>`.
+ */
+export declare const FormSpy: default_2.FC<FormSpyProps>;
+
+export declare interface FormSpyProps {
+    /**
+     * Função-filho que recebe o estado atual e retorna JSX.
+     * Também aceita children estáticos (JSX comum).
+     */
+    children?: ((state: FormStateValue) => default_2.ReactNode) | default_2.ReactNode;
+    /**
+     * Alternativa ao children como função.
+     * Chamada com o estado atual a cada mudança.
+     */
+    render?: (state: FormStateValue) => default_2.ReactNode;
+    /**
+     * Chamada a cada mudança do estado do formulário.
+     * Não produz nenhuma saída visual — use para autosave, logging, analytics, etc.
+     *
+     * ⚠️ Também é chamada no mount inicial com os valores padrão.
+     */
+    onChange?: (state: FormStateValue) => void;
+}
+
+/**
+ * Snapshot do estado do formulário retornado por `useFormApi().getState()`.
+ */
+export declare interface FormStateSnapshot {
+    values: Record<string, unknown>;
+    errors: Record<string, string | undefined>;
+    warnings: Record<string, string>;
+    dirty: boolean;
+    valid: boolean;
+    submitting: boolean;
+}
+
+/**
+ * Estado observável do formulário, atualizado a cada mudança de campo.
+ * Retornado por `useFormState()`.
+ */
+export declare interface FormStateValue {
+    /** Todos os valores atuais do formulário (reativo via `useWatch`) */
+    values: Record<string, unknown>;
+    /** Erros de validação indexados por nome de campo */
+    errors: Record<string, string | undefined>;
+    /** Avisos (warn) indexados por nome de campo */
+    warnings: Record<string, string>;
+    /** `true` se qualquer campo foi alterado em relação aos defaultValues */
+    dirty: boolean;
+    /** `true` se não há erros de validação */
+    valid: boolean;
+    /** `true` durante o submit/onSubmit assíncrono */
+    submitting: boolean;
+}
+
+export declare const interpolate: (text: string | undefined | null, vars: Record<string, string>) => string;
+
+export declare const interpolateContainer: (container: FormContainer, vars: Record<string, string>) => FormContainer;
+
+export declare const interpolateField: (field: FormField, vars: Record<string, string>) => FormField;
+
+export declare const interpolateStep: (step: FormStep, vars: Record<string, string>) => FormStep;
+
+export declare const makeStepResolver: (step: FormStep, externalData?: Record<string, unknown>, validatorMapper?: ValidatorMapper) => Resolver<Record<string, unknown>>;
+
+/**
+ * Retorna uma função que computa os avisos (`warn`) de todos os campos do step.
+ * Os avisos não bloqueiam o submit — são apenas informativos.
+ * Chame o resultado com os valores do form para obter `Record<fieldName, warnMessage>`.
+ */
+export declare const makeStepWarnComputer: (step: FormStep, externalData?: Record<string, unknown>, validatorMapper?: ValidatorMapper) => (values: Record<string, unknown>) => Promise<Record<string, string>>;
+
+/**
+ * Opções de pagamento padrão para participação por dia (IPB).
+ * Use como base ao customizar via `paymentMethodOptions.porDia`.
+ */
+export declare const OPCOES_POR_DIA: PaymentOption[];
+
+/**
+ * Opções de pagamento padrão para participação em todos os dias (IPB).
+ * Use como base ao customizar via `paymentMethodOptions.todosOsDias`.
+ */
+export declare const OPCOES_TODOS_OS_DIAS: PaymentOption[];
+
+export declare interface ParticipationValue {
+    tipo: "todos_os_dias" | "por_dia" | null;
+    data: string | null;
+    genero?: "masculino" | "feminino" | null;
+}
+
+export declare interface PaymentMethodValue {
+    metodo: string;
+    parcelas?: number;
+    valorTotal: number;
+}
+
+/**
+ * Opção de pagamento exibida pelo `DFPaymentMethod`.
+ *
+ * Exporte suas próprias listas a partir dos defaults `OPCOES_POR_DIA` e
+ * `OPCOES_TODOS_OS_DIAS` (renderer/src/components/DFPaymentMethod) para usar
+ * como ponto de partida ao customizar.
+ *
+ * @example
+ * ```ts
+ * import { OPCOES_POR_DIA, PaymentOption } from '@schema-forms-data/renderer';
+ *
+ * const opcoes: PaymentOption[] = [
+ *   ...OPCOES_POR_DIA,
+ *   { id: 'boleto', label: 'Boleto', description: '3 dias úteis', Icon: File, taxa: 0 },
+ * ];
+ * ```
+ */
+export declare interface PaymentOption {
+    /** Identificador único gravado no campo (ex: `"pix"`, `"cartao"`) */
+    id: string;
+    /** Rótulo curto exibido no card */
+    label: string;
+    /** Descrição exibida abaixo do label */
+    description: string;
+    /** Ícone Lucide ou qualquer `React.FC` */
+    Icon: React.FC<{
+        className?: string;
+    }>;
+    /** Taxa percentual decimal. Ex: 0.0315 = 3,15%. Use 0 para sem taxa. */
+    taxa: number;
+    /** Número de parcelas. Omitir (ou 1) para à vista. */
+    parcelas?: number;
+    /** Texto de taxa exibido abaixo da descrição. Ex: `"Taxa: 3,15%"` */
+    taxaLabel?: string;
+    /** Se `true`, o card é renderizado desabilitado */
+    disabled?: boolean;
+}
+
+export declare const RendererContext: Context<RendererContextValue>;
+
+export declare interface RendererContextValue {
+    /**
+     * Função para upload de arquivos.
+     * Recebe o File, o nome do campo e um callback opcional de progresso (0-100).
+     * Deve retornar o uploadId (string) para armazenar no form.
+     *
+     * O callback `onProgress` é chamado durante o upload com valores de 0 a 100.
+     * Suporta uploads simples e multipart — a implementação decide como reportar.
+     *
+     * Quando não fornecida, o campo FILE exibe aviso de preview.
+     *
+     * @example
+     * ```ts
+     * uploadFile={async (file, fieldName, onProgress) => {
+     *   const { uploadUrl } = await api.initiateUpload({ file, campo: fieldName });
+     *   await uploadWithProgress(uploadUrl, file, onProgress);
+     *   return uploadId;
+     * }}
+     * ```
+     */
+    uploadFile?: (file: File, fieldName: string, onProgress?: (percent: number) => void) => Promise<string>;
+    /**
+     * Função de lookup de CEP.
+     * Recebe o CEP sem máscara (8 dígitos) e retorna os dados de endereço.
+     *
+     * Quando não fornecida, usa a API pública https://viacep.com.br (padrão).
+     */
+    cepLookup?: (cep: string) => Promise<CepLookupResult>;
+    /**
+     * Função para resolver a URL de preview de um PDF de termos armazenado.
+     * Recebe o uploadId e deve retornar a URL temporária de preview.
+     *
+     * Quando não fornecida, o campo TERMS ignora termoPdfUploadId e usa
+     * apenas termoPdfUrl (URL direta) ou termoTexto como fallback.
+     */
+    resolveTermsUploadUrl?: (uploadId: string) => Promise<string>;
+    /**
+     * Dados externos injetados no formulário.
+     * Usados para condicionais com source='evento' e campos como
+     * PARTICIPATION_TYPE e PAYMENT_METHOD.
+     *
+     * Exemplo: { 'evento.dataInicioEvento': '2026-01-01', 'evento.valor': 5000 }
+     */
+    externalData?: Record<string, unknown>;
+    /**
+     * Mapa de resolvers de props de campo indexados por `resolvePropsKey`.
+     * Cada resolver recebe o field, os valores atuais do form e os dados externos,
+     * e retorna um `Partial<FormField>` mesclado dinamicamente antes da renderização.
+     *
+     * @see FieldResolver
+     */
+    fieldResolvers?: FieldResolvers;
+    /**
+     * Mapa de validadores customizados indexados pela chave `type`.
+     * Usado pelos arrays `validate` e `warn` de cada campo.
+     * Suporta funções síncronas e assíncronas.
+     *
+     * @example
+     * ```ts
+     * validatorMapper={{
+     *   emailUnico: async (value) => {
+     *     const exists = await api.checkEmail(String(value));
+     *     return exists ? 'E-mail já cadastrado' : undefined;
+     *   },
+     *   senhasIguais: (value, allValues, config) => {
+     *     return value === allValues[config['field'] as string]
+     *       ? undefined
+     *       : 'As senhas não conferem';
+     *   },
+     * }}
+     * ```
+     */
+    validatorMapper?: ValidatorMapper;
+    /**
+     * Avisos de campo computados a partir dos validadores `warn`.
+     * Não bloqueiam o submit — são apenas informativos.
+     * Injetado automaticamente pelo FormRenderer.
+     */
+    fieldWarnings?: Record<string, string>;
+    /**
+     * Mapa de componentes customizados por tipo de campo.
+     * Quando fornecido, substitui o componente padrão do renderer para os tipos registrados.
+     *
+     * @see ComponentMapper
+     */
+    componentMapper?: ComponentMapper;
+    /**
+     * Opções customizadas de pagamento para o `DFPaymentMethod`.
+     *
+     * Quando definidas, substituem os defaults internos (baseados no modelo IPB).
+     * Use `OPCOES_POR_DIA` e `OPCOES_TODOS_OS_DIAS` como ponto de partida.
+     *
+     * Para substituir o componente inteiramente use `componentMapper[FieldType.PAYMENT_METHOD]`.
+     *
+     * @example
+     * ```tsx
+     * import { OPCOES_POR_DIA, OPCOES_TODOS_OS_DIAS, PaymentOption } from '@schema-forms-data/renderer';
+     *
+     * const paymentMethodOptions = {
+     *   porDia: [
+     *     ...OPCOES_POR_DIA,
+     *     { id: 'boleto', label: 'Boleto', description: '3 dias úteis', Icon: File, taxa: 0 },
+     *   ],
+     *   todosOsDias: OPCOES_TODOS_OS_DIAS,
+     * };
+     *
+     * <FormRenderer schema={schema} paymentMethodOptions={paymentMethodOptions} />
+     * ```
+     */
+    paymentMethodOptions?: {
+        /** Opções exibidas quando o campo `relatedField` indica `"por_dia"` */
+        porDia?: PaymentOption[];
+        /** Opções exibidas quando `relatedField` indica `"todos_os_dias"` ou é nulo */
+        todosOsDias?: PaymentOption[];
+    };
+}
+
+export declare interface StepIndicatorProps {
+    steps: Array<{
+        id: string;
+        label?: string;
+        icone?: string;
+    }>;
+    currentStep: number;
+    onStepClick?: (index: number) => void;
+}
+
+export declare const StepRenderer: ({ step, control, externalData, }: StepRendererProps) => JSX_2.Element;
+
+declare interface StepRendererProps {
+    step: FormStep;
+    control: Control<Record<string, unknown>>;
+    externalData?: Record<string, unknown>;
+}
+
+/**
+ * Retorna o estado de um campo individual, reativo a mudanças.
+ * Funciona a partir de **qualquer componente** dentro do `<FormRenderer>`.
+ *
+ * @example
+ * ```tsx
+ * const { value, error, warning, dirty, touched } = useField('email');
+ * ```
+ */
+export declare const useField: (name: string) => FieldState;
+
+/**
+ * Retorna `input` props + `meta` para construir componentes de campo customizados.
+ * Funciona a partir de **qualquer componente** dentro do `<FormRenderer>`.
+ *
+ * @example
+ * ```tsx
+ * const { input, meta } = useFieldApi('email');
+ * return (
+ *   <div>
+ *     <input type="email" {...input} />
+ *     {meta.error && <span>{meta.error}</span>}
+ *   </div>
+ * );
+ * ```
+ */
+export declare const useFieldApi: (name: string) => FieldApiReturn;
+
+/**
+ * Retorna a API programática do formulário.
+ * Funciona a partir de **qualquer componente** dentro do `<FormRenderer>`.
+ *
+ * @example
+ * ```tsx
+ * const api = useFormApi();
+ * api.change('plano', 'premium');
+ * const state = api.getState();
+ * ```
+ */
+export declare const useFormApi: () => FormApi;
+
+/**
+ * Retorna o estado observável do formulário, reativo a cada mudança de campo.
+ * Funciona a partir de **qualquer componente** dentro do `<FormRenderer>`.
+ *
+ * @example
+ * ```tsx
+ * const { values, errors, dirty, valid, submitting, warnings } = useFormState();
+ * ```
+ */
+export declare const useFormState: () => FormStateValue;
+
+export declare const useRendererContext: () => RendererContextValue;
+
+/**
+ * Mapa de validadores customizados indexados pela chave `type`
+ * usada em `FormField.validate` e `FormField.warn`.
+ */
+export declare type ValidatorMapper = Record<string, FieldValidatorFn>;
+
+export { }