@openreachtech/furo-vue 1.3.1

package/types/generated/components/atoms/FuroButton/FuroButtonContext.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Context class for managing FuroButton component.
+ *
+ * @extends {BaseFuroContext<null, Props, EmitEventName>}
+ */
+export default class FuroButtonContext extends BaseFuroContext<null, Props, "CLICK"> {
+    /**
+     * Factory method.
+     *
+     * @template {X extends typeof FuroButtonContext ? X : never} T, X
+     * @override
+     * @param {FuroButtonContextFactoryParams} params - Parameters of this factory method.
+     * @returns {InstanceType<T>} An instance of this class.
+     * @this {T}
+     */
+    static override create<T extends X extends typeof FuroButtonContext ? X : never, X>(this: T, { props, componentContext, }: FuroButtonContextFactoryParams): InstanceType<T>;
+    /**
+     * Get emit event name.
+     *
+     * @override
+     * @returns {Readonly<{
+     *   CLICK: 'click'
+     * }>}
+     */
+    static override get EMIT_EVENT_NAME(): Readonly<{
+        CLICK: "click";
+    }>;
+    /**
+     * Get emit options.
+     *
+     * @returns {{
+     *   click: (payload: import('./ButtonEmitPayload.js').default) => void
+     * }}
+     */
+    static get EMIT_EVENT_HASH(): {
+        click: (payload: import("./ButtonEmitPayload.js").default) => void;
+    };
+    /**
+     * get: Constructor of `EmitPayload`.
+     *
+     * @returns {typeof ButtonEmitPayload}
+     */
+    static get EmitPayloadCtor(): typeof ButtonEmitPayload;
+    /**
+     * Constructor.
+     *
+     * @param {FuroButtonContextParams} params
+     */
+    constructor({ props, componentContext, }: FuroButtonContextParams);
+    /**
+     * get: Constructor of this class.
+     *
+     * @override
+     * @returns {typeof FuroButtonContext}
+     */
+    override get Ctor(): typeof FuroButtonContext;
+    /**
+     * Whether the button is disabled.
+     *
+     * @returns {boolean}
+     */
+    isDisabled(): boolean;
+    /**
+     * Whether the button is in a loading state.
+     *
+     * @returns {boolean}
+     */
+    isLoading(): boolean;
+    /**
+     * Whether interaction should be blocked.
+     *
+     * @returns {boolean}
+     */
+    isInteractionBlocked(): boolean;
+    /**
+     * Extract CSS class map for the button root.
+     *
+     * @returns {Record<string, boolean>}
+     */
+    extractRootClassNames(): Record<string, boolean>;
+    /**
+     * Extract root attributes forwarded to Reka Primitive.
+     *
+     * @returns {Record<string, unknown>}
+     */
+    extractRootAttributes(): Record<string, unknown>;
+    /**
+     * Extract Reka Primitive props from parcel.
+     *
+     * @returns {{
+     *   as: 'button'
+     *   asChild: boolean
+     *   disabled: boolean
+     *   type: FuroButtonType
+     * }}
+     */
+    extractPrimitiveParcel(): {
+        as: "button";
+        asChild: boolean;
+        disabled: boolean;
+        type: FuroButtonType;
+    };
+    /**
+     * Extract ARIA attributes for the button root.
+     *
+     * @returns {{
+     *   'aria-disabled': 'true' | undefined
+     *   'aria-busy': 'true' | undefined
+     * }}
+     */
+    extractAriaAttributes(): {
+        "aria-disabled": "true" | undefined;
+        "aria-busy": "true" | undefined;
+    };
+    /**
+     * Handle native click on the button root.
+     *
+     * @param {{
+     *   rawEvent: MouseEvent | PointerEvent
+     * }} params - Parameters.
+     */
+    onClick({ rawEvent, }: {
+        rawEvent: MouseEvent | PointerEvent;
+    }): void;
+}
+export type FuroButtonContextParams = import("../../../contexts/BaseFuroContext.js").BaseFuroContextParams & {
+    props: Props;
+    componentContext: ComponentContext;
+};
+export type FuroButtonContextFactoryParams = FuroButtonContextParams;
+export type EmitEventName = keyof typeof FuroButtonContext.EMIT_EVENT_NAME;
+export type FuroButtonVariant = "default" | "secondary" | "destructive" | "outline" | "ghost" | "link";
+export type FuroButtonSize = "default" | "sm" | "lg" | "icon";
+export type FuroButtonType = "button" | "submit" | "reset";
+export type Props = {
+    parcel?: FuroButtonParcel | null;
+};
+export type FuroButtonParcel = {
+    variant?: FuroButtonVariant;
+    size?: FuroButtonSize;
+    disabled?: boolean;
+    loading?: boolean;
+    asChild?: boolean;
+    type?: FuroButtonType;
+};
+export type FuroButtonSetup = (props: Props, componentContext: ComponentContext) => {
+    context: FuroButtonContext;
+};
+export type FuroButtonEmitHash = typeof FuroButtonContext.EMIT_EVENT_HASH;
+export type FuroButtonSlots = import("vue").SlotsType<{
+    default: {};
+    loading: {};
+}>;
+export type ComponentContext = import("vue").SetupContext<FuroButtonEmitHash, FuroButtonSlots>;
+import BaseFuroContext from '../../../contexts/BaseFuroContext.js';
+import ButtonEmitPayload from './ButtonEmitPayload.js';

package/types/generated/components/atoms/FuroCheckbox/CheckboxEmitPayload.d.ts

@@ -0,0 +1,55 @@
+/**
+ * CheckboxEmitPayload.
+ *
+ * @extends {BaseEmitPayload<CheckboxRawEvent, HTMLElement>}
+ */
+export default class CheckboxEmitPayload extends BaseEmitPayload<CheckboxRawEvent, HTMLElement> {
+    constructor({ rawEvent, }: import("../../../emit-payload/BaseEmitPayload.js").BaseEmitPayloadParams<CheckboxRawEvent>);
+    /**
+     * Get the event detail.
+     *
+     * @returns {CheckboxRawEvent['detail'] | null}
+     */
+    get eventDetail(): CheckboxRawEvent["detail"] | null;
+    /**
+     * Current checked state after the change.
+     *
+     * @returns {FuroCheckboxValue | null}
+     */
+    get value(): FuroCheckboxValue | null;
+    /**
+     * Whether the checkbox is indeterminate after the change.
+     *
+     * @returns {boolean}
+     */
+    get indeterminate(): boolean;
+    /**
+     * Whether the checkbox is in the indeterminate state.
+     *
+     * @returns {boolean}
+     */
+    isIndeterminate(): boolean;
+    /**
+     * Whether the checkbox is checked.
+     *
+     * @returns {boolean | null}
+     */
+    isChecked(): boolean | null;
+    /**
+     * Whether the checkbox is unchecked.
+     *
+     * @returns {boolean | null}
+     */
+    isUnchecked(): boolean | null;
+}
+export type FuroCheckboxValue = import("./FuroCheckboxContext.js").FuroCheckboxValue;
+export type CheckboxEmitPayloadParams = {
+    rawEvent: CheckboxRawEvent;
+};
+export type CheckboxRawEvent = CustomEvent<{
+    target: HTMLElement | null;
+    value: FuroCheckboxValue | null;
+    indeterminate: boolean;
+}>;
+export type CheckboxEmitPayloadFactoryParams = CheckboxEmitPayloadParams;
+import BaseEmitPayload from '../../../emit-payload/BaseEmitPayload.js';

package/types/generated/components/atoms/FuroCheckbox/FuroCheckbox.vue.d.ts

@@ -0,0 +1,87 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    parcel?: import("./FuroCheckboxContext.js").FuroCheckboxParcel | null;
+}, {
+    context: FuroCheckboxContext;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'change-value': (payload: import("./CheckboxEmitPayload.js").default) => void;
+    'update:value': (value: FuroCheckboxValue) => void;
+    'update:indeterminate': (indeterminate: boolean) => void;
+}, string, import("vue").PublicProps, Readonly<{
+    parcel?: import("./FuroCheckboxContext.js").FuroCheckboxParcel | null;
+}> & Readonly<{
+    "onChange-value"?: (payload: import("./CheckboxEmitPayload.js").default) => any;
+    "onUpdate:value"?: (value: boolean) => any;
+    "onUpdate:indeterminate"?: (indeterminate: boolean) => any;
+}>, {
+    parcel: import("./FuroCheckboxContext.js").FuroCheckboxParcel;
+}, {}, {
+    FuroIcon: import("vue").DefineComponent<{
+        name: string;
+        size?: string | number | null;
+    }, {
+        context: import("../FuroIcon/FuroIconContext.js").default;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+        name: string;
+        size?: string | number | null;
+    }> & Readonly<{}>, {
+        size: string | number;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    CheckboxRoot: <T = boolean>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        attrs: any;
+        slots: {
+            default?: (props: {
+                modelValue: "indeterminate" | T;
+                state: import("reka-ui").CheckboxCheckedState;
+            }) => any;
+        };
+        emit: (evt: "update:modelValue", value: "indeterminate" | T) => void;
+    }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: import("vue").PublicProps & {
+            defaultValue?: "indeterminate" | T;
+            modelValue?: "indeterminate" | T;
+            disabled?: boolean;
+            value?: import("reka-ui").AcceptableValue;
+            id?: string;
+            trueValue?: T;
+            falseValue?: T;
+            asChild?: boolean;
+            as?: import("reka-ui").AsTag | import("vue").Component;
+            name?: string;
+            required?: boolean;
+            "onUpdate:modelValue"?: ((value: "indeterminate" | T) => any) | undefined;
+        } & (typeof globalThis extends {
+            __VLS_PROPS_FALLBACK: infer P;
+        } ? P : {});
+        expose: (exposed: {}) => void;
+        attrs: any;
+        slots: {
+            default?: (props: {
+                modelValue: "indeterminate" | T;
+                state: import("reka-ui").CheckboxCheckedState;
+            }) => any;
+        };
+        emit: (evt: "update:modelValue", value: "indeterminate" | T) => void;
+    }>) => import("vue").VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    CheckboxIndicator: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("reka-ui").CheckboxIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("reka-ui").CheckboxIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("reka-ui").CheckboxIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    });
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+import FuroCheckboxContext from './FuroCheckboxContext.js';

package/types/generated/components/atoms/FuroCheckbox/FuroCheckboxContext.d.ts

@@ -0,0 +1,342 @@
+/**
+ * Context class for managing FuroCheckbox component.
+ *
+ * @extends {BaseFuroContext<null, Props, EmitEventName>}
+ */
+export default class FuroCheckboxContext extends BaseFuroContext<null, Props, "CHANGE_VALUE" | "UPDATE_VALUE" | "UPDATE_INDETERMINATE"> {
+    /**
+     * Factory method.
+     *
+     * @template {X extends typeof FuroCheckboxContext ? X : never} T, X
+     * @override
+     * @param {FuroCheckboxContextFactoryParams} params - Parameters of this factory method.
+     * @returns {InstanceType<T>} An instance of this class.
+     * @this {T}
+     */
+    static override create<T extends X extends typeof FuroCheckboxContext ? X : never, X>(this: T, { props, componentContext, refHash, }: FuroCheckboxContextFactoryParams): InstanceType<T>;
+    /**
+     * Build ref hash.
+     *
+     * @override
+     */
+    static override buildRefHash(): {
+        internalValueRef: import("vue").Ref<boolean, boolean>;
+        checkboxRootElementRef: import("vue").Ref<any, any>;
+    };
+    /**
+     * Get emit event name.
+     *
+     * @override
+     * @returns {Readonly<{
+     *   CHANGE_VALUE: 'change-value'
+     *   UPDATE_VALUE: 'update:value'
+     *   UPDATE_INDETERMINATE: 'update:indeterminate'
+     * }>}
+     */
+    static override get EMIT_EVENT_NAME(): Readonly<{
+        CHANGE_VALUE: "change-value";
+        UPDATE_VALUE: "update:value";
+        UPDATE_INDETERMINATE: "update:indeterminate";
+    }>;
+    /**
+     * Get emit options.
+     *
+     * @returns {{
+     *   'change-value': (payload: import('./CheckboxEmitPayload.js').default) => void
+     *   'update:value': (value: FuroCheckboxValue) => void
+     *   'update:indeterminate': (indeterminate: boolean) => void
+     * }}
+     */
+    static get EMIT_EVENT_HASH(): {
+        "change-value": (payload: import("./CheckboxEmitPayload.js").default) => void;
+        "update:value": (value: FuroCheckboxValue) => void;
+        "update:indeterminate": (indeterminate: boolean) => void;
+    };
+    /**
+     * Get indeterminate value.
+     *
+     * @returns {'indeterminate'}
+     */
+    static get INDETERMINATE_VALUE(): "indeterminate";
+    /**
+     * Default checkbox box size (width and height).
+     *
+     * @returns {string}
+     */
+    static get DEFAULT_CHECKBOX_SIZE(): string;
+    /**
+     * Default indicator icon size (proportional to {@link DEFAULT_CHECKBOX_SIZE}).
+     *
+     * @returns {string}
+     */
+    static get DEFAULT_CHECKBOX_ICON_SIZE(): string;
+    /**
+     * Icon size as a fraction of box size (1rem / 1.125rem).
+     *
+     * @returns {number}
+     */
+    static get CHECKBOX_ICON_SIZE_RATIO(): number;
+    /**
+     * get: Constructor of `EmitPayload`.
+     *
+     * @returns {typeof CheckboxEmitPayload}
+     */
+    static get EmitPayloadCtor(): typeof CheckboxEmitPayload;
+    /**
+     * Constructor.
+     *
+     * @param {FuroCheckboxContextParams} params
+     */
+    constructor({ props, componentContext, refHash, }: FuroCheckboxContextParams);
+    refHash: {
+        internalValueRef: import("vue").Ref<FuroCheckboxState>;
+        checkboxRootElementRef: import("vue").Ref<HTMLElement | null>;
+    };
+    /**
+     * get: Constructor of this class.
+     *
+     * @override
+     * @returns {typeof FuroCheckboxContext}
+     */
+    override get Ctor(): typeof FuroCheckboxContext;
+    /**
+     * Get the internal tri-state check state ref.
+     *
+     * @returns {import('vue').Ref<FuroCheckboxState>}
+     */
+    get internalValueRef(): import("vue").Ref<FuroCheckboxState>;
+    /**
+     * Get checkbox root element ref.
+     *
+     * @returns {import('vue').Ref<HTMLElement | null>}
+     */
+    get checkboxRootElementRef(): import("vue").Ref<HTMLElement | null>;
+    /**
+     * Whether the parent controls `parcel.value`.
+     *
+     * @returns {boolean}
+     */
+    isControlled(): boolean;
+    /**
+     * Resolve the check state from parcel, attrs, and indeterminate flag.
+     *
+     * @returns {FuroCheckboxState}
+     */
+    resolveSyncedValue(): FuroCheckboxState;
+    /**
+     * Resolve controlled checked boolean from parcel or fallthrough attrs.
+     *
+     * @returns {FuroCheckboxValue}
+     */
+    resolveControlledSyncedValue(): FuroCheckboxValue;
+    /**
+     * Resolve uncontrolled checkbox value (unchecked).
+     *
+     * @returns {FuroCheckboxValue}
+     */
+    resolveUncontrolledSyncedValue(): FuroCheckboxValue;
+    /**
+     * Extract checked boolean while internal model is indeterminate.
+     *
+     * @returns {FuroCheckboxValue}
+     */
+    extractCheckedWhileIndeterminate(): FuroCheckboxValue;
+    /**
+     * Whether the given check state is indeterminate.
+     *
+     * @param {{
+     *   checkState: FuroCheckboxState
+     * }} params - Parameters.
+     * @returns {boolean}
+     */
+    isIndeterminateState({ checkState, }: {
+        checkState: FuroCheckboxState;
+    }): boolean;
+    /**
+     * Extract the checked boolean from a check state.
+     *
+     * @param {{
+     *   checkState: FuroCheckboxState
+     * }} params - Parameters.
+     * @returns {FuroCheckboxValue}
+     */
+    extractCheckedFromState({ checkState, }: {
+        checkState: FuroCheckboxState;
+    }): FuroCheckboxValue;
+    /**
+     * Normalize a check-state change into public boolean channels.
+     *
+     * @param {{
+     *   rawValue: FuroCheckboxState
+     *   previousCheckState: FuroCheckboxState
+     * }} params - Parameters.
+     * @returns {{
+     *   checkState: FuroCheckboxState
+     *   value: FuroCheckboxValue
+     *   indeterminate: boolean
+     * }}
+     */
+    normalizeStateChange({ rawValue, previousCheckState, }: {
+        rawValue: FuroCheckboxState;
+        previousCheckState: FuroCheckboxState;
+    }): {
+        checkState: FuroCheckboxState;
+        value: FuroCheckboxValue;
+        indeterminate: boolean;
+    };
+    /**
+     * Whether the checkbox is invalid.
+     *
+     * @returns {boolean}
+     */
+    isInvalid(): boolean;
+    /**
+     * Whether the checkbox is disabled.
+     *
+     * @returns {boolean}
+     */
+    isDisabled(): boolean;
+    /**
+     * Whether the checkbox is required.
+     *
+     * @returns {boolean}
+     */
+    isRequired(): boolean;
+    /**
+     * Parse a simple CSS length (`rem`, `px`, `em`).
+     *
+     * @param {{
+     *   length: string
+     * }} params - Parameters.
+     * @returns {{ amount: number, unit: string } | null}
+     */
+    parseCssLength({ length, }: {
+        length: string;
+    }): {
+        amount: number;
+        unit: string;
+    } | null;
+    /**
+     * Extract indicator icon size proportional to checkbox box size.
+     *
+     * @returns {string}
+     */
+    extractCheckboxIconSize(): string;
+    /**
+     * Extract inline style for checkbox dimensions (CSS custom properties).
+     *
+     * @returns {{
+     *   '--furo-checkbox-size': string
+     *   '--furo-checkbox-icon-size': string
+     * }}
+     */
+    extractCheckboxRootStyle(): {
+        "--furo-checkbox-size": string;
+        "--furo-checkbox-icon-size": string;
+    };
+    /**
+     * Extract root attributes forwarded to Reka CheckboxRoot.
+     *
+     * @returns {Record<string, unknown>}
+     */
+    extractRootAttributes(): Record<string, unknown>;
+    /**
+     * Build a custom event for checkbox value changes.
+     *
+     * @param {{
+     *   name: string
+     *   value: FuroCheckboxValue
+     *   indeterminate: boolean
+     * }} params - Parameters.
+     * @returns {import('./CheckboxEmitPayload.js').CheckboxRawEvent}
+     */
+    buildCustomEvent({ name, value, indeterminate, }: {
+        name: string;
+        value: FuroCheckboxValue;
+        indeterminate: boolean;
+    }): import("./CheckboxEmitPayload.js").CheckboxRawEvent;
+    /**
+     * Setup component context.
+     *
+     * @template {X extends FuroCheckboxContext ? X : never} T, X
+     * @override
+     * @returns {T} - For method chaining.
+     * @this {T}
+     */
+    override setupComponent<T extends X extends FuroCheckboxContext ? X : never, X>(this: T): T;
+    /**
+     * Handle a value update emitted by Reka CheckboxRoot.
+     *
+     * @param {{
+     *   rawValue: FuroCheckboxState
+     * }} params - Parameters.
+     */
+    onChangeValue({ rawValue, }: {
+        rawValue: FuroCheckboxState;
+    }): void;
+    /**
+     * Apply an interaction result to the internal check state.
+     *
+     * A controlled checkbox only follows its parent, never its own interaction.
+     *
+     * @param {{
+     *   checkState: FuroCheckboxState
+     * }} params - Parameters.
+     */
+    applyInternalValue({ checkState, }: {
+        checkState: FuroCheckboxState;
+    }): void;
+    /**
+     * Whether the checkbox is in the indeterminate state.
+     *
+     * @returns {boolean}
+     */
+    isIndeterminate(): boolean;
+    /**
+     * Whether the checkbox is checked.
+     *
+     * @returns {boolean}
+     */
+    isChecked(): boolean;
+}
+export type FuroCheckboxContextParams = import("../../../contexts/BaseFuroContext.js").BaseFuroContextParams & {
+    props: Props;
+    componentContext: ComponentContext;
+    refHash: {
+        internalValueRef: import("vue").Ref<FuroCheckboxState>;
+        checkboxRootElementRef: import("vue").Ref<HTMLElement | null>;
+    };
+};
+export type FuroCheckboxContextFactoryParams = Omit<FuroCheckboxContextParams, "refHash"> & {
+    refHash?: {
+        internalValueRef: import("vue").Ref<FuroCheckboxState>;
+        checkboxRootElementRef: import("vue").Ref<HTMLElement | null>;
+    };
+};
+export type EmitEventName = keyof typeof FuroCheckboxContext.EMIT_EVENT_NAME;
+/**
+ * Public checked model (`v-model:value`, `parcel.value`).
+ */
+export type FuroCheckboxValue = boolean;
+/**
+ * Internal tri-state check state (includes the indeterminate sentinel).
+ */
+export type FuroCheckboxState = FuroCheckboxValue | typeof FuroCheckboxContext.INDETERMINATE_VALUE;
+export type Props = {
+    parcel?: FuroCheckboxParcel | null;
+};
+export type FuroCheckboxParcel = {
+    value?: FuroCheckboxValue;
+    indeterminate?: boolean;
+    invalid?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    size?: string;
+};
+export type ComponentContext = import("vue").SetupContext<typeof FuroCheckboxContext.EMIT_EVENT_HASH>;
+export type FuroCheckboxEmitHash = typeof FuroCheckboxContext.EMIT_EVENT_HASH;
+export type FuroCheckboxSetup = (props: Props, componentContext: ComponentContext) => {
+    context: FuroCheckboxContext;
+};
+import BaseFuroContext from '../../../contexts/BaseFuroContext.js';
+import CheckboxEmitPayload from './CheckboxEmitPayload.js';

package/types/generated/components/atoms/FuroEmailField/EmailFieldEmitPayload.d.ts

@@ -0,0 +1,46 @@
+/**
+ * EmailFieldEmitPayload.
+ *
+ * @extends {BaseEmitPayload<EmailFieldRawEvent, HTMLInputElement>}
+ */
+export default class EmailFieldEmitPayload extends BaseEmitPayload<EmailFieldRawEvent, HTMLInputElement> {
+    constructor({ rawEvent, }: import("../../../emit-payload/BaseEmitPayload.js").BaseEmitPayloadParams<EmailFieldRawEvent>);
+    /**
+     * Current string value of the email field.
+     *
+     * @returns {string | null}
+     */
+    get value(): string | null;
+    /**
+     * Extract trimmed string value from the email field.
+     *
+     * @returns {string | null}
+     */
+    extractTrimmedValue(): string | null;
+    /**
+     * Whether the raw field value is empty (missing control is treated as empty).
+     *
+     * @returns {boolean}
+     */
+    hasEmptyText(): boolean;
+    /**
+     * Whether the trimmed field value is empty (missing control is treated as empty).
+     *
+     * @returns {boolean}
+     */
+    hasEmptyTrimmedText(): boolean;
+    /**
+     * Whether the raw field value has at least one character (whitespace counts).
+     *
+     * @returns {boolean}
+     */
+    hasEnteredText(): boolean;
+    /**
+     * Whether the trimmed field value has at least one non-whitespace character.
+     *
+     * @returns {boolean}
+     */
+    hasEnteredTrimmedText(): boolean;
+}
+export type EmailFieldRawEvent = InputEvent | FocusEvent | KeyboardEvent;
+import BaseEmitPayload from '../../../emit-payload/BaseEmitPayload.js';