import { InputSpec, LazyBuild } from './inputSpec';
import { List } from './list';
import { UnionRes, UnionResStaticValidatedAs, Variants } from './variants';
import { Pattern, RandomString, ValueSpec, ValueSpecDatetime, ValueSpecText } from '../inputSpecTypes';
import { DefaultString } from '../inputSpecTypes';
import { z } from 'zod';
import { DeepPartial } from '../../../types';
/** Zod schema for a file upload result — validates `{ path, commitment: { hash, size } }`. */
export declare const fileInfoParser: z.ZodObject<{
    path: z.ZodString;
    commitment: z.ZodObject<{
        hash: z.ZodString;
        size: z.ZodNumber;
    }, z.core.$strip>;
}, z.core.$strip>;
/** The parsed result of a file upload, containing the file path and its content commitment (hash + size). */
export type FileInfo = z.infer<typeof fileInfoParser>;
/** Conditional type: returns `T` if `Required` is `true`, otherwise `T | null`. */
export type AsRequired<T, Required extends boolean> = Required extends true ? T : T | null;
/**
 * Core builder class for defining a single form field in a service configuration spec.
 *
 * Each static factory method (e.g. `Value.text()`, `Value.toggle()`, `Value.select()`) creates
 * a typed `Value` instance representing a specific field type. Dynamic variants (e.g. `Value.dynamicText()`)
 * allow the field options to be computed lazily at runtime.
 *
 * Use with {@link InputSpec} to compose complete form specifications.
 *
 * @typeParam Type - The runtime type this field produces when filled in
 * @typeParam StaticValidatedAs - The compile-time validated type (usually same as Type)
 * @typeParam OuterType - The parent form's type context (used by dynamic variants)
 */
export declare class Value<Type extends StaticValidatedAs, StaticValidatedAs = Type, OuterType = unknown> {
    build: LazyBuild<{
        spec: ValueSpec;
        validator: z.ZodType<Type>;
    }, OuterType>;
    readonly validator: z.ZodType<StaticValidatedAs>;
    protected constructor(build: LazyBuild<{
        spec: ValueSpec;
        validator: z.ZodType<Type>;
    }, OuterType>, validator: z.ZodType<StaticValidatedAs>);
    _TYPE: Type;
    _PARTIAL: DeepPartial<Type>;
    /** @internal Used by {@link InputSpec.filter} to support nested filtering of object-typed fields. */
    _objectSpec?: {
        inputSpec: InputSpec<any, any>;
        params: {
            name: string;
            description?: string | null;
        };
    };
    /**
     * @description Displays a boolean toggle to enable/disable
     * @example
     * ```
      toggleExample: Value.toggle({
        // required
        name: 'Toggle Example',
        default: true,
      
        // optional
        description: null,
        warning: null,
        immutable: false,
      }),
      * ```
     */
    static toggle(a: {
        name: string;
        description?: string | null;
        /** Presents a warning prompt before permitting the value to change. */
        warning?: string | null;
        default: boolean;
        /**
         * @description Once set, the value can never be changed.
         * @default false
         */
        immutable?: boolean;
    }): Value<boolean, boolean, unknown>;
    /** Like {@link Value.toggle} but options are resolved lazily at runtime via a builder function. */
    static dynamicToggle<OuterType = unknown>(a: LazyBuild<{
        name: string;
        description?: string | null;
        warning?: string | null;
        default: boolean;
        disabled?: false | string;
    }, OuterType>): Value<boolean, boolean, OuterType>;
    /**
     * @description Displays a text input field
     * @example
     * ```
      textExample: Value.text({
        // required
        name: 'Text Example',
        required: false,
        default: null,
      
        // optional
        description: null,
        placeholder: null,
        warning: null,
        generate: null,
        inputmode: 'text',
        masked: false,
        minLength: null,
        maxLength: null,
        patterns: [],
        immutable: false,
      }),
      * ```
      */
    static text<Required extends boolean>(a: {
        name: string;
        description?: string | null;
        /** Presents a warning prompt before permitting the value to change. */
        warning?: string | null;
        /**
         * provide a default value.
         * @type { string | RandomString | null }
         * @example default: null
         * @example default: 'World'
         * @example default: { charset: 'abcdefg', len: 16 }
         */
        default: string | RandomString | null;
        required: Required;
        /**
         * @description Mask (aka camouflage) text input with dots: ● ● ●
         * @default false
         */
        masked?: boolean;
        placeholder?: string | null;
        minLength?: number | null;
        maxLength?: number | null;
        /**
         * @description A list of regular expressions to which the text must conform to pass validation. A human readable description is provided in case the validation fails.
         * @default []
         * @example
         * ```
          [
            {
              regex: "[a-z]",
              description: "May only contain lower case letters from the English alphabet."
            }
          ]
         * ```
         */
        patterns?: Pattern[];
        /**
         * @description Informs the browser how to behave and which keyboard to display on mobile
         * @default "text"
         */
        inputmode?: ValueSpecText['inputmode'];
        /**
         * @description Once set, the value can never be changed.
         * @default false
         */
        immutable?: boolean;
        /**
         * @description Displays a button that will generate a random string according to the provided charset and len attributes.
         */
        generate?: RandomString | null;
    }): Value<AsRequired<string, Required>, AsRequired<string, Required>, unknown>;
    /** Like {@link Value.text} but options are resolved lazily at runtime via a builder function. */
    static dynamicText<Required extends boolean, OuterType = unknown>(getA: LazyBuild<{
        name: string;
        description?: string | null;
        warning?: string | null;
        default: DefaultString | null;
        required: Required;
        masked?: boolean;
        placeholder?: string | null;
        minLength?: number | null;
        maxLength?: number | null;
        patterns?: Pattern[];
        inputmode?: ValueSpecText['inputmode'];
        disabled?: string | false;
        generate?: null | RandomString;
    }, OuterType>): Value<AsRequired<string, Required>, string | null, OuterType>;
    /**
     * @description Displays a large textarea field for long form entry.
     * @example
     * ```
      textareaExample: Value.textarea({
        // required
        name: 'Textarea Example',
        required: false,
        default: null,
      
        // optional
        description: null,
        placeholder: null,
        warning: null,
        minLength: null,
        maxLength: null,
        minRows: 3
        maxRows: 6
        immutable: false,
      }),
      * ```
      */
    static textarea<Required extends boolean>(a: {
        name: string;
        description?: string | null;
        /** Presents a warning prompt before permitting the value to change. */
        warning?: string | null;
        default: string | null;
        required: Required;
        minLength?: number | null;
        maxLength?: number | null;
        /**
         * @description A list of regular expressions to which the text must conform to pass validation. A human readable description is provided in case the validation fails.
         * @default []
         * @example
         * ```
          [
            {
              regex: "[a-z]",
              description: "May only contain lower case letters from the English alphabet."
            }
          ]
         * ```
         */
        patterns?: Pattern[];
        /** Defaults to 3 */
        minRows?: number;
        /** Maximum number of rows before scroll appears. Defaults to 6 */
        maxRows?: number;
        placeholder?: string | null;
        /**
         * @description Once set, the value can never be changed.
         * @default false
         */
        immutable?: boolean;
    }): Value<AsRequired<string, Required>, AsRequired<string, Required>, unknown>;
    /** Like {@link Value.textarea} but options are resolved lazily at runtime via a builder function. */
    static dynamicTextarea<Required extends boolean, OuterType = unknown>(getA: LazyBuild<{
        name: string;
        description?: string | null;
        warning?: string | null;
        default: string | null;
        required: Required;
        minLength?: number | null;
        maxLength?: number | null;
        patterns?: Pattern[];
        minRows?: number;
        maxRows?: number;
        placeholder?: string | null;
        disabled?: false | string;
    }, OuterType>): Value<AsRequired<string, Required>, string | null, OuterType>;
    /**
     * @description Displays a number input field
     * @example
     * ```
      numberExample: Value.number({
        // required
        name: 'Number Example',
        required: false,
        default: null,
        integer: true,
      
        // optional
        description: null,
        placeholder: null,
        warning: null,
        min: null,
        max: null,
        immutable: false,
        step: null,
        units: null,
      }),
      * ```
      */
    static number<Required extends boolean>(a: {
        name: string;
        description?: string | null;
        /** Presents a warning prompt before permitting the value to change. */
        warning?: string | null;
        /**
         * @description optionally provide a default value.
         * @type { default: number | null }
         * @example default: null
         * @example default: 7
         */
        default: number | null;
        required: Required;
        min?: number | null;
        max?: number | null;
        /**
         * @description How much does the number increase/decrease when using the arrows provided by the browser.
         * @default 1
         */
        step?: number | null;
        /**
         * @description Requires the number to be an integer.
         */
        integer: boolean;
        /**
         * @description Optionally display units to the right of the input box.
         */
        units?: string | null;
        placeholder?: string | null;
        /**
         * @description Once set, the value can never be changed.
         * @default false
         */
        immutable?: boolean;
    }): Value<AsRequired<number, Required>, AsRequired<number, Required>, unknown>;
    /** Like {@link Value.number} but options are resolved lazily at runtime via a builder function. */
    static dynamicNumber<Required extends boolean, OuterType = unknown>(getA: LazyBuild<{
        name: string;
        description?: string | null;
        warning?: string | null;
        default: number | null;
        required: Required;
        min?: number | null;
        max?: number | null;
        step?: number | null;
        integer: boolean;
        units?: string | null;
        placeholder?: string | null;
        disabled?: false | string;
    }, OuterType>): Value<AsRequired<number, Required>, number | null, OuterType>;
    /**
     * @description Displays a browser-native color selector.
     * @example
     * ```
      colorExample: Value.color({
        // required
        name: 'Color Example',
        required: false,
        default: null,
      
        // optional
        description: null,
        warning: null,
        immutable: false,
      }),
      * ```
      */
    static color<Required extends boolean>(a: {
        name: string;
        description?: string | null;
        /** Presents a warning prompt before permitting the value to change. */
        warning?: string | null;
        /**
         * @description optionally provide a default value.
         * @type { default: string | null }
         * @example default: null
         * @example default: 'ffffff'
         */
        default: string | null;
        required: Required;
        /**
         * @description Once set, the value can never be changed.
         * @default false
         */
        immutable?: boolean;
    }): Value<AsRequired<string, Required>, AsRequired<string, Required>, unknown>;
    /** Like {@link Value.color} but options are resolved lazily at runtime via a builder function. */
    static dynamicColor<Required extends boolean, OuterType = unknown>(getA: LazyBuild<{
        name: string;
        description?: string | null;
        warning?: string | null;
        default: string | null;
        required: Required;
        disabled?: false | string;
    }, OuterType>): Value<AsRequired<string, Required>, string | null, OuterType>;
    /**
     * @description Displays a browser-native date/time selector.
     * @example
     * ```
      datetimeExample: Value.datetime({
        // required
        name: 'Datetime Example',
        required: false,
        default: null,
      
        // optional
        description: null,
        warning: null,
        immutable: false,
        inputmode: 'datetime-local',
        min: null,
        max: null,
      }),
      * ```
      */
    static datetime<Required extends boolean>(a: {
        name: string;
        description?: string | null;
        /** Presents a warning prompt before permitting the value to change. */
        warning?: string | null;
        /**
         * @description optionally provide a default value.
         * @type { default: string | null }
         * @example default: null
         * @example default: '1985-12-16 18:00:00.000'
         */
        default: string | null;
        required: Required;
        /**
         * @description Informs the browser how to behave and which date/time component to display.
         * @default "datetime-local"
         */
        inputmode?: ValueSpecDatetime['inputmode'];
        min?: string | null;
        max?: string | null;
        /**
         * @description Once set, the value can never be changed.
         * @default false
         */
        immutable?: boolean;
    }): Value<AsRequired<string, Required>, AsRequired<string, Required>, unknown>;
    /** Like {@link Value.datetime} but options are resolved lazily at runtime via a builder function. */
    static dynamicDatetime<Required extends boolean, OuterType = unknown>(getA: LazyBuild<{
        name: string;
        description?: string | null;
        warning?: string | null;
        default: string | null;
        required: Required;
        inputmode?: ValueSpecDatetime['inputmode'];
        min?: string | null;
        max?: string | null;
        disabled?: false | string;
    }, OuterType>): Value<AsRequired<string, Required>, string | null, OuterType>;
    /**
     * @description Displays a select modal with radio buttons, allowing for a single selection.
     * @example
     * ```
      selectExample: Value.select({
        // required
        name: 'Select Example',
        default: 'radio1',
        values: {
          radio1: 'Radio 1',
          radio2: 'Radio 2',
        },
      
        // optional
        description: null,
        warning: null,
        immutable: false,
        disabled: false,
      }),
      * ```
      */
    static select<Values extends Record<string, string>>(a: {
        name: string;
        description?: string | null;
        /** Presents a warning prompt before permitting the value to change. */
        warning?: string | null;
        /**
         * @description Determines if the field is required. If so, optionally provide a default value from the list of values.
         * @type { (keyof Values & string) | null }
         * @example default: null
         * @example default: 'radio1'
         */
        default: keyof Values & string;
        /**
         * @description A mapping of unique radio options to their human readable display format.
         * @example
         * ```
          {
            radio1: "Radio 1"
            radio2: "Radio 2"
            radio3: "Radio 3"
          }
         * ```
         */
        values: Values;
        /**
         * @description Once set, the value can never be changed.
         * @default false
         */
        immutable?: boolean;
    }): Value<keyof Values & string, keyof Values & string, unknown>;
    /** Like {@link Value.select} but options are resolved lazily at runtime via a builder function. */
    static dynamicSelect<Values extends Record<string, string>, OuterType = unknown>(getA: LazyBuild<{
        name: string;
        description?: string | null;
        warning?: string | null;
        default: string;
        values: Values;
        disabled?: false | string | string[];
    }, OuterType>): Value<keyof Values & string, keyof Values & string, OuterType>;
    /**
     * @description Displays a select modal with checkboxes, allowing for multiple selections.
     * @example
     * ```
      multiselectExample: Value.multiselect({
        // required
        name: 'Multiselect Example',
        values: {
          option1: 'Option 1',
          option2: 'Option 2',
        },
        default: [],
      
        // optional
        description: null,
        warning: null,
        immutable: false,
        disabled: false,
        minlength: null,
        maxLength: null,
      }),
      * ```
      */
    static multiselect<Values extends Record<string, string>>(a: {
        name: string;
        description?: string | null;
        /** Presents a warning prompt before permitting the value to change. */
        warning?: string | null;
        /**
         * @description A simple list of which options should be checked by default.
         */
        default: (keyof Values & string)[];
        /**
         * @description A mapping of checkbox options to their human readable display format.
         * @example
         * ```
          {
            option1: "Option 1"
            option2: "Option 2"
            option3: "Option 3"
          }
         * ```
         */
        values: Values;
        minLength?: number | null;
        maxLength?: number | null;
        /**
         * @description Once set, the value can never be changed.
         * @default false
         */
        immutable?: boolean;
    }): Value<(keyof Values & string)[], (keyof Values & string)[], unknown>;
    /** Like {@link Value.multiselect} but options are resolved lazily at runtime via a builder function. */
    static dynamicMultiselect<Values extends Record<string, string>, OuterType = unknown>(getA: LazyBuild<{
        name: string;
        description?: string | null;
        warning?: string | null;
        default: string[];
        values: Values;
        minLength?: number | null;
        maxLength?: number | null;
        disabled?: false | string | string[];
    }, OuterType>): Value<(keyof Values & string)[], (keyof Values & string)[], OuterType>;
    /**
     * @description Display a collapsable grouping of additional fields, a "sub form". The second value is the inputSpec spec for the sub form.
     * @example
     * ```
      objectExample: Value.object(
        {
          // required
          name: 'Object Example',
      
          // optional
          description: null,
          warning: null,
        },
        InputSpec.of({}),
      ),
      * ```
      */
    static object<Type extends StaticValidatedAs, StaticValidatedAs extends Record<string, any>>(a: {
        name: string;
        description?: string | null;
    }, spec: InputSpec<Type, StaticValidatedAs>): Value<Type, StaticValidatedAs, unknown>;
    /**
     * Displays a file upload input field.
     *
     * @param a.extensions - Allowed file extensions (e.g. `[".pem", ".crt"]`)
     * @param a.required - Whether a file must be selected
     */
    static file<Required extends boolean>(a: {
        name: string;
        description?: string | null;
        warning?: string | null;
        extensions: string[];
        required: Required;
    }): Value<AsRequired<{
        path: string;
        commitment: {
            hash: string;
            size: number;
        };
    }, Required>, AsRequired<{
        path: string;
        commitment: {
            hash: string;
            size: number;
        };
    }, Required>, unknown>;
    /** Like {@link Value.file} but options are resolved lazily at runtime via a builder function. */
    static dynamicFile<Required extends boolean, OuterType = unknown>(a: LazyBuild<{
        name: string;
        description?: string | null;
        warning?: string | null;
        extensions: string[];
        required: Required;
    }, OuterType>): Value<AsRequired<{
        path: string;
        commitment: {
            hash: string;
            size: number;
        };
    }, Required>, {
        path: string;
        commitment: {
            hash: string;
            size: number;
        };
    } | null, OuterType>;
    /**
     * @description Displays a dropdown, allowing for a single selection. Depending on the selection, a different object ("sub form") is presented.
     * @example
     * ```
      unionExample: Value.union(
        {
          // required
          name: 'Union Example',
          default: 'option1',
      
          // optional
          description: null,
          warning: null,
          disabled: false,
          immutable: false,
        },
        Variants.of({
          option1: {
            name: 'Option 1',
            spec: InputSpec.of({}),
          },
          option2: {
            name: 'Option 2',
            spec: InputSpec.of({}),
          },
        }),
      ),
      * ```
      */
    static union<VariantValues extends {
        [K in string]: {
            name: string;
            spec: InputSpec<any>;
        };
    }>(a: {
        name: string;
        description?: string | null;
        /** Presents a warning prompt before permitting the value to change. */
        warning?: string | null;
        variants: Variants<VariantValues>;
        /**
         * @description Provide a default value from the list of variants.
         * @type { string }
         * @example default: 'variant1'
         */
        default: keyof VariantValues & string;
        /**
         * @description Once set, the value can never be changed.
         * @default false
         */
        immutable?: boolean;
    }): Value<UnionRes<VariantValues, keyof VariantValues & string>, UnionResStaticValidatedAs<VariantValues, keyof VariantValues & string>, unknown>;
    /** Like {@link Value.union} but options (including which variants are available) are resolved lazily at runtime. */
    static dynamicUnion<VariantValues extends {
        [K in string]: {
            name: string;
            spec: InputSpec<any>;
        };
    }, OuterType = unknown>(getA: LazyBuild<{
        name: string;
        description?: string | null;
        warning?: string | null;
        variants: Variants<VariantValues>;
        default: keyof VariantValues & string;
        disabled: string[] | false | string;
    }, OuterType>): Value<UnionRes<VariantValues>, UnionRes<VariantValues>, OuterType>;
    /** Like {@link Value.union} but options are resolved lazily, with an explicit static validator type. */
    static dynamicUnion<StaticVariantValues extends {
        [K in string]: {
            name: string;
            spec: InputSpec<any, any>;
        };
    }, VariantValues extends StaticVariantValues, OuterType = unknown>(getA: LazyBuild<{
        name: string;
        description?: string | null;
        warning?: string | null;
        variants: Variants<VariantValues>;
        default: keyof VariantValues & string;
        disabled: string[] | false | string;
    }, OuterType>, validator: z.ZodType<UnionResStaticValidatedAs<StaticVariantValues>>): Value<UnionRes<VariantValues>, UnionResStaticValidatedAs<StaticVariantValues>, OuterType>;
    /**
     * @description Presents an interface to add/remove/edit items in a list.
     * @example
     * In this example, we create a list of text inputs.
     *
     * ```
      listExampleText: Value.list(
        List.text(
          {
            // required
            name: 'Text List',
  
            // optional
            description: null,
            warning: null,
            default: [],
            minLength: null,
            maxLength: null,
          },
          {
            // required
            patterns: [],
  
            // optional
            placeholder: null,
            generate: null,
            inputmode: 'url',
            masked: false,
            minLength: null,
            maxLength: null,
          },
        ),
      ),
     * ```
     * @example
     * In this example, we create a list of objects.
     *
     * ```
      listExampleObject: Value.list(
        List.obj(
          {
            // required
            name: 'Object List',
  
            // optional
            description: null,
            warning: null,
            default: [],
            minLength: null,
            maxLength: null,
          },
          {
            // required
            spec: InputSpec.of({}),
  
            // optional
            displayAs: null,
            uniqueBy: null,
          },
        ),
      ),
     * ```
     */
    static list<Type>(a: List<Type>): Value<Type, Type, unknown>;
    /**
     * @description Provides a way to define a hidden field with a static value. Useful for tracking
     * @example
     * ```
      hiddenExample: Value.hidden(),
     * ```
     */
    static hidden<T>(): Value<T>;
    static hidden<T>(parser: z.ZodType<T>): Value<T>;
    /**
     * @description Provides a way to define a hidden field with a static value. Useful for tracking
     * @example
     * ```
      hiddenExample: Value.hidden(),
     * ```
     */
    static dynamicHidden<T, OuterType = unknown>(getParser: LazyBuild<z.ZodType<T>, OuterType>): Value<T, T, OuterType>;
    /**
     * Returns a new Value that produces the same field spec but with `disabled` set to the given message.
     * The field remains in the form but cannot be edited by the user.
     *
     * @param message - The reason the field is disabled, displayed to the user
     */
    withDisabled(message: string): Value<Type, StaticValidatedAs, OuterType>;
    /**
     * Transforms the validated output value using a mapping function.
     * The form field itself remains unchanged, but the value is transformed after validation.
     *
     * @param fn - A function to transform the validated value
     */
    map<U>(fn: (value: StaticValidatedAs) => U): Value<U, U, OuterType>;
}
