import { EventEmitter, OnInit } from '@angular/core';
import { FormControl } from '@angular/forms';
import { FieldOption } from '../../../services/forms/types';
import { InputMetadata } from '../../types';
import { EditableFieldDef, FieldSchemaEditorMetadata, FieldSchemaEditorPreset } from './types';
import * as i0 from "@angular/core";
/**
 * Tipos cuyo valor sale de una lista cerrada que define quien arma el
 * formulario — sin al menos una opción, el campo no se puede responder.
 * Espejo de `fieldRequiresOptions` que vivía duplicado en bingo.
 */
export declare const FIELD_TYPES_WITH_OPTIONS: string[];
/**
 * val-field-schema-editor
 *
 * Edita UN campo de un formulario dinámico: texto, tipo, placeholder, nota,
 * obligatoriedad y opciones. Es la pieza que faltaba en la lib — hasta ahora
 * el único editor de campos con este nivel vivía dentro de bingo
 * (`checkout-field-modal.component.ts`), invisible para el resto del factory,
 * y `val-survey-builder` había terminado con una versión pobre de lo mismo
 * (dos tipos fijos, sin placeholder ni opciones).
 *
 * Es agnóstico de dominio a propósito:
 * - el **catálogo de tipos** (`allowedTypes`) lo decide el consumer, porque es
 *   él quien sabe qué sabe renderizar su formulario;
 * - los **presets** los pasa el consumer, porque "correo del comprador" es de
 *   checkout y no significa nada en una encuesta.
 *
 * No trae cáscara de modal: el consumer lo envuelve en `val-modal-layout` (o
 * en lo que quiera) y dispara `submit()` desde su propio botón, igual que hace
 * `survey-create-modal` con `val-survey-builder`.
 */
export declare class FieldSchemaEditorComponent implements OnInit {
    props: FieldSchemaEditorMetadata;
    readonly save: EventEmitter<EditableFieldDef>;
    /**
     * Emite en cada tecla, sin validar. Existe porque el consumer necesita el
     * borrador en vivo: si solo tuviera `save`, lo escrito acá no existiría para
     * él hasta que alguien toque su botón — y lo escrito ES la intención del
     * usuario, no un borrador que haya que confirmar.
     */
    readonly changed: EventEmitter<EditableFieldDef>;
    private readonly i18n;
    private readonly formSchemas;
    readonly labelControl: FormControl<string>;
    readonly placeholderControl: FormControl<string>;
    readonly hintControl: FormControl<string>;
    readonly requiredControl: FormControl<boolean>;
    readonly typeControl: FormControl<string>;
    readonly options: import("@angular/core").WritableSignal<FieldOption[]>;
    readonly validationError: import("@angular/core").WritableSignal<string>;
    readonly selectedPresetId: import("@angular/core").WritableSignal<string>;
    /** Se refresca con cada cambio de tipo — `needsOptions` no puede leer el control directo. */
    private readonly currentType;
    /** Una vez que se toca el token a mano (o se edita un campo ya guardado) deja de derivarse del label. */
    private nameLocked;
    private name;
    private fieldId;
    constructor();
    ngOnInit(): void;
    t(key: string): string;
    state(): import("../../types").ComponentState;
    showPresets(): boolean;
    needsOptions(): boolean;
    typeLabel(type: string): string;
    readonly typeSelectProps: import("@angular/core").Signal<Partial<InputMetadata>>;
    readonly optionsEditorProps: import("@angular/core").Signal<{
        title: string;
        hint: string;
        addLabel: string;
        optionsLabel: string;
        placeholder: string;
        emptyText: string;
        removeOptionLabel: string;
        reorderOptionLabel: string;
        state: import("../../types").ComponentState;
        options: FieldOption[];
    }>;
    setOptions(options: FieldOption[]): void;
    private emitChange;
    selectPreset(preset: FieldSchemaEditorPreset): void;
    /**
     * Valida y emite. Público a propósito: lo llama el consumer desde el botón
     * de su propia cáscara (modal, página o acordeón).
     */
    submit(): boolean;
    /** El campo tal como está en pantalla, sin validar. */
    value(): EditableFieldDef;
    private allowedTypes;
    /**
     * Un tipo fuera del catálogo del consumer cae al primero permitido. Pasa al
     * editar un campo guardado con un tipo que la app ya no ofrece (bingo lo
     * hacía con ATTACHMENT cuando el medio de pago no lo admite): sin esto, el
     * select queda en un valor que no está en su lista y se ve vacío.
     */
    private coerceType;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldSchemaEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldSchemaEditorComponent, "val-field-schema-editor", never, { "props": { "alias": "props"; "required": false; }; }, { "save": "save"; "changed": "changed"; }, never, never, true, never>;
}