@ng-forge/dynamic-forms-ionic 1.1.0 → 1.2.0-next.10

package/types/ng-forge-dynamic-forms-ionic-lazy-button.d.ts

@@ -0,0 +1,119 @@
+import { FormEvent, AppendArrayItemEvent, ArrayAllowedChildren, InsertArrayItemEvent, NextPageEvent, PopArrayItemEvent, PrependArrayItemEvent, PreviousPageEvent, RemoveAtIndexEvent, ShiftArrayItemEvent, FormSubmitEvent } from '@ng-forge/dynamic-forms';
+import * as _ng_forge_dynamic_forms_integration from '@ng-forge/dynamic-forms/integration';
+import { ButtonField } from '@ng-forge/dynamic-forms/integration';
+import * as _angular_core from '@angular/core';
+
+interface IonicButtonProps {
+    expand?: 'full' | 'block';
+    fill?: 'clear' | 'outline' | 'solid' | 'default';
+    shape?: 'round';
+    size?: 'small' | 'default' | 'large';
+    color?: 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger' | 'light' | 'medium' | 'dark';
+    strong?: boolean;
+    type?: 'button' | 'submit' | 'reset';
+}
+type IonicButtonField<TEvent extends FormEvent> = ButtonField<IonicButtonProps, TEvent>;
+/** Specific button field types with preconfigured events */
+/** Submit button field - automatically disabled when form is invalid */
+type IonicSubmitButtonField = Omit<IonicButtonField<FormSubmitEvent>, 'event' | 'type' | 'eventArgs'> & {
+    type: 'submit';
+};
+/** Next page button field - with preconfigured NextPageEvent */
+type IonicNextButtonField = Omit<IonicButtonField<NextPageEvent>, 'event' | 'type' | 'eventArgs'> & {
+    type: 'next';
+};
+/** Previous page button field - with preconfigured PreviousPageEvent */
+type IonicPreviousButtonField = Omit<IonicButtonField<PreviousPageEvent>, 'event' | 'type' | 'eventArgs'> & {
+    type: 'previous';
+};
+/** Add array item button field - dispatches AppendArrayItemEvent */
+type IonicAddArrayItemButtonField = Omit<IonicButtonField<AppendArrayItemEvent>, 'event' | 'type' | 'eventArgs'> & {
+    type: 'add-array-item' | 'addArrayItem';
+    /**
+     * The key of the array field to add items to.
+     * Required when the button is placed outside the array.
+     * When inside an array, this is automatically determined from context.
+     */
+    arrayKey?: string;
+    /**
+     * Template for the new array item. REQUIRED.
+     * - Single field (ArrayAllowedChildren): Creates a primitive item (field's value is extracted directly)
+     * - Array of fields (ArrayAllowedChildren[]): Creates an object item (fields merged into object)
+     */
+    template: ArrayAllowedChildren | readonly ArrayAllowedChildren[];
+};
+/** Prepend array item button field - dispatches PrependArrayItemEvent (adds at beginning) */
+type IonicPrependArrayItemButtonField = Omit<IonicButtonField<PrependArrayItemEvent>, 'event' | 'type' | 'eventArgs'> & {
+    type: 'prepend-array-item' | 'prependArrayItem';
+    /**
+     * The key of the array field to prepend items to.
+     * Required when the button is placed outside the array.
+     * When inside an array, this is automatically determined from context.
+     */
+    arrayKey?: string;
+    /**
+     * Template for the new array item. REQUIRED.
+     * - Single field (ArrayAllowedChildren): Creates a primitive item (field's value is extracted directly)
+     * - Array of fields (ArrayAllowedChildren[]): Creates an object item (fields merged into object)
+     */
+    template: ArrayAllowedChildren | readonly ArrayAllowedChildren[];
+};
+/** Insert array item button field - dispatches InsertArrayItemEvent (adds at specific index) */
+type IonicInsertArrayItemButtonField = Omit<IonicButtonField<InsertArrayItemEvent>, 'event' | 'type' | 'eventArgs'> & {
+    type: 'insert-array-item' | 'insertArrayItem';
+    /**
+     * The key of the array field to insert items into.
+     * Required when the button is placed outside the array.
+     * When inside an array, this is automatically determined from context.
+     */
+    arrayKey?: string;
+    /** The index at which to insert the new item. */
+    index: number;
+    /**
+     * Template for the new array item. REQUIRED.
+     * - Single field (ArrayAllowedChildren): Creates a primitive item (field's value is extracted directly)
+     * - Array of fields (ArrayAllowedChildren[]): Creates an object item (fields merged into object)
+     */
+    template: ArrayAllowedChildren | readonly ArrayAllowedChildren[];
+};
+/** Remove array item button field - dispatches RemoveAtIndexEvent or PopArrayItemEvent */
+type IonicRemoveArrayItemButtonField = Omit<IonicButtonField<RemoveAtIndexEvent>, 'event' | 'type' | 'eventArgs'> & {
+    type: 'remove-array-item' | 'removeArrayItem';
+    /**
+     * The key of the array field to remove items from.
+     * Required when the button is placed outside the array.
+     * When inside an array, this is automatically determined from context.
+     */
+    arrayKey?: string;
+};
+/** Pop array item button field - dispatches PopArrayItemEvent (removes last item) */
+type IonicPopArrayItemButtonField = Omit<IonicButtonField<PopArrayItemEvent>, 'event' | 'type' | 'eventArgs'> & {
+    type: 'pop-array-item' | 'popArrayItem';
+    /**
+     * The key of the array field to remove the last item from.
+     * REQUIRED - must specify which array to pop from.
+     */
+    arrayKey: string;
+};
+/** Shift array item button field - dispatches ShiftArrayItemEvent (removes first item) */
+type IonicShiftArrayItemButtonField = Omit<IonicButtonField<ShiftArrayItemEvent>, 'event' | 'type' | 'eventArgs'> & {
+    type: 'shift-array-item' | 'shiftArrayItem';
+    /**
+     * The key of the array field to remove the first item from.
+     * REQUIRED - must specify which array to shift from.
+     */
+    arrayKey: string;
+};
+
+declare class IonicButtonFieldComponent<TEvent extends FormEvent> {
+    protected readonly action: _ng_forge_dynamic_forms_integration.NgForgeAction<TEvent>;
+    readonly props: _angular_core.InputSignal<IonicButtonProps | undefined>;
+    readonly buttonType: _angular_core.Signal<"button" | "submit" | "reset">;
+    readonly buttonTestId: _angular_core.Signal<string>;
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IonicButtonFieldComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IonicButtonFieldComponent<any>, "df-ion-button", never, { "props": { "alias": "props"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ng_forge_dynamic_forms_integration.NgForgeActionHost; inputs: {}; outputs: {}; }]>;
+}
+
+export { IonicButtonFieldComponent };
+export type { IonicAddArrayItemButtonField, IonicButtonField, IonicButtonProps, IonicInsertArrayItemButtonField, IonicNextButtonField, IonicPopArrayItemButtonField, IonicPrependArrayItemButtonField, IonicPreviousButtonField, IonicRemoveArrayItemButtonField, IonicShiftArrayItemButtonField, IonicSubmitButtonField };

package/types/ng-forge-dynamic-forms-ionic-lazy-checkbox.d.ts

@@ -0,0 +1,23 @@
+import { DynamicText } from '@ng-forge/dynamic-forms';
+import * as _ng_forge_dynamic_forms_integration from '@ng-forge/dynamic-forms/integration';
+import { CheckboxField } from '@ng-forge/dynamic-forms/integration';
+import * as i0 from '@angular/core';
+
+interface IonicCheckboxProps {
+    labelPlacement?: 'start' | 'end' | 'fixed' | 'stacked';
+    justify?: 'start' | 'end' | 'space-between';
+    color?: 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger';
+    indeterminate?: boolean;
+    hint?: DynamicText;
+}
+type IonicCheckboxField = CheckboxField<IonicCheckboxProps>;
+
+declare class IonicCheckboxFieldComponent {
+    protected readonly ngf: _ng_forge_dynamic_forms_integration.TypedNgForgeField<boolean>;
+    readonly props: i0.InputSignal<IonicCheckboxProps | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IonicCheckboxFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IonicCheckboxFieldComponent, "df-ion-checkbox", never, { "props": { "alias": "props"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ng_forge_dynamic_forms_integration.NgForgeFieldHost; inputs: {}; outputs: {}; }]>;
+}
+
+export { IonicCheckboxFieldComponent };
+export type { IonicCheckboxField, IonicCheckboxProps };

package/types/ng-forge-dynamic-forms-ionic-lazy-datepicker.d.ts

@@ -0,0 +1,39 @@
+import * as _angular_core from '@angular/core';
+import * as _ng_forge_dynamic_forms_integration from '@ng-forge/dynamic-forms/integration';
+import { DatepickerField, DatepickerProps } from '@ng-forge/dynamic-forms/integration';
+import { DynamicText } from '@ng-forge/dynamic-forms';
+
+interface IonicDatepickerProps extends DatepickerProps {
+    presentation?: 'date' | 'date-time' | 'time' | 'time-date' | 'month' | 'month-year' | 'year';
+    multiple?: boolean;
+    preferWheel?: boolean;
+    showDefaultButtons?: boolean;
+    showDefaultTitle?: boolean;
+    showDefaultTimeLabel?: boolean;
+    showClearButton?: boolean;
+    doneText?: string;
+    cancelText?: string;
+    size?: 'cover' | 'fixed';
+    color?: 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger';
+    hint?: DynamicText;
+}
+type IonicDatepickerField = DatepickerField<IonicDatepickerProps>;
+
+declare class IonicDatepickerFieldComponent {
+    protected readonly ngf: _ng_forge_dynamic_forms_integration.TypedNgForgeField<Date | null>;
+    readonly minDate: _angular_core.InputSignal<Date | null>;
+    readonly maxDate: _angular_core.InputSignal<Date | null>;
+    readonly startAt: _angular_core.InputSignal<Date | null>;
+    readonly props: _angular_core.InputSignal<IonicDatepickerProps | undefined>;
+    readonly isModalOpen: _angular_core.WritableSignal<boolean>;
+    openModal(): void;
+    closeModal(): void;
+    onDateChange(event: CustomEvent): void;
+    dateToIsoString(date: Date | null | undefined): string | undefined;
+    formatDisplayDate(date: Date | null | undefined): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IonicDatepickerFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IonicDatepickerFieldComponent, "df-ion-datepicker", never, { "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "startAt": { "alias": "startAt"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ng_forge_dynamic_forms_integration.NgForgeFieldHost; inputs: {}; outputs: {}; }]>;
+}
+
+export { IonicDatepickerFieldComponent };
+export type { IonicDatepickerField, IonicDatepickerProps };

package/types/ng-forge-dynamic-forms-ionic-lazy-input.d.ts

@@ -0,0 +1,70 @@
+import * as _ng_forge_dynamic_forms from '@ng-forge/dynamic-forms';
+import { DynamicText, TextAddon, TemplateAddon } from '@ng-forge/dynamic-forms';
+import * as _ng_forge_dynamic_forms_integration from '@ng-forge/dynamic-forms/integration';
+import { InputField, InputProps, WrapperFieldInputs } from '@ng-forge/dynamic-forms/integration';
+import * as _ng_forge_dynamic_forms_ionic_shared from '@ng-forge/dynamic-forms-ionic/shared';
+import { IonicIconAddon, IonicButtonAddon } from '@ng-forge/dynamic-forms-ionic/shared';
+import * as _angular_core from '@angular/core';
+
+interface IonicInputProps extends InputProps {
+    fill?: 'solid' | 'outline';
+    shape?: 'round';
+    labelPlacement?: 'start' | 'end' | 'fixed' | 'stacked' | 'floating';
+    color?: 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger' | 'light' | 'medium' | 'dark';
+    hint?: DynamicText;
+    errorText?: DynamicText;
+    counter?: boolean;
+    clearInput?: boolean;
+}
+/**
+ * Module-augmentable seam for adding custom addon types to `ion-input` at
+ * the type level. Pair with `withCustomAddon(...)` for the runtime side:
+ */
+interface IonicAddonExtensions {
+}
+type IonicAddonExtension = IonicAddonExtensions[keyof IonicAddonExtensions];
+/** Addon types accepted by `ion-input`. */
+type IonicInputAddon = IonicIconAddon | IonicButtonAddon | TextAddon | TemplateAddon | IonicAddonExtension;
+type IonicInputField = InputField<IonicInputProps> & {
+    addons?: ReadonlyArray<IonicInputAddon>;
+};
+
+declare class IonicInputFieldComponent {
+    private readonly elementRef;
+    private ionicConfig;
+    protected readonly ngf: _ng_forge_dynamic_forms_integration.TypedNgForgeField<string>;
+    protected readonly ngfa: _ng_forge_dynamic_forms_integration.TypedNgForgeAddons<IonicInputAddon>;
+    readonly props: _angular_core.InputSignal<IonicInputProps | undefined>;
+    /**
+     * Wrapper-style host bag pushed by `DfFieldOutlet`. Declared at the
+     * component level so `setInputIfDeclared` (which uses
+     * `reflectComponentType`) can write it.
+     */
+    readonly fieldInputs: _angular_core.InputSignal<WrapperFieldInputs | undefined>;
+    /** Per-instance type override populated by `toggle-password-visibility` preset. */
+    private readonly typeOverride;
+    protected readonly fill: _angular_core.Signal<"solid" | "outline">;
+    protected readonly shape: _angular_core.Signal<"round" | undefined>;
+    /**  Bootstrap / PrimeNG. Consumers can opt into Ionic's native inline 'start' */
+    protected readonly labelPlacement: _angular_core.Signal<"start" | "end" | "fixed" | "stacked" | "floating">;
+    protected readonly color: _angular_core.Signal<"primary" | "secondary" | "tertiary" | "success" | "warning" | "danger" | "light" | "medium" | "dark" | undefined>;
+    /** Override (set by `toggle-password-visibility` preset) wins over `props().type`. */
+    protected readonly type: _angular_core.Signal<string>;
+    /** Per-type split: ion-button addons render inline via the attribute-
+     *  selector inline component (so the slotted element is a native
+     *  <ion-button> Ionic can style); everything else (icon/text/template/
+     *  component types) goes through the universal <df-addon-slot> dispatcher
+     *  wrapped in <span slot="start|end"> for safe shadow-DOM projection. */
+    protected readonly buttonPrefixAddons: _angular_core.Signal<_ng_forge_dynamic_forms_ionic_shared.IonicButtonAddon[]>;
+    protected readonly buttonSuffixAddons: _angular_core.Signal<_ng_forge_dynamic_forms_ionic_shared.IonicButtonAddon[]>;
+    protected readonly decorativePrefixAddons: _angular_core.Signal<(_ng_forge_dynamic_forms_ionic_shared.IonicIconAddon | _ng_forge_dynamic_forms.TextAddon | _ng_forge_dynamic_forms.TemplateAddon)[]>;
+    protected readonly decorativeSuffixAddons: _angular_core.Signal<(_ng_forge_dynamic_forms_ionic_shared.IonicIconAddon | _ng_forge_dynamic_forms.TextAddon | _ng_forge_dynamic_forms.TemplateAddon)[]>;
+    /** Set when the component is destroyed — guards async aria-describedby sync against teardown. */
+    private destroyed;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IonicInputFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IonicInputFieldComponent, "df-ion-input", never, { "props": { "alias": "props"; "required": false; "isSignal": true; }; "fieldInputs": { "alias": "fieldInputs"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ng_forge_dynamic_forms_integration.NgForgeFieldHost; inputs: {}; outputs: {}; }, { directive: typeof _ng_forge_dynamic_forms_integration.NgForgeAddons; inputs: {}; outputs: {}; }]>;
+}
+
+export { IonicInputFieldComponent };
+export type { IonicInputField, IonicInputProps };

package/types/ng-forge-dynamic-forms-ionic-lazy-multi-checkbox.d.ts

@@ -0,0 +1,28 @@
+import * as _angular_core from '@angular/core';
+import * as _ng_forge_dynamic_forms_integration from '@ng-forge/dynamic-forms/integration';
+import { MultiCheckboxField } from '@ng-forge/dynamic-forms/integration';
+import { DynamicText, ValueType, FieldOption } from '@ng-forge/dynamic-forms';
+
+interface IonicMultiCheckboxProps {
+    labelPlacement?: 'start' | 'end' | 'fixed' | 'stacked';
+    justify?: 'start' | 'end' | 'space-between';
+    color?: 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger';
+    hint?: DynamicText;
+}
+type IonicMultiCheckboxField<T> = MultiCheckboxField<T, IonicMultiCheckboxProps>;
+
+declare class IonicMultiCheckboxFieldComponent {
+    protected readonly ngf: _ng_forge_dynamic_forms_integration.TypedNgForgeField<ValueType[]>;
+    readonly options: _angular_core.InputSignal<FieldOption<ValueType>[]>;
+    readonly props: _angular_core.InputSignal<IonicMultiCheckboxProps | undefined>;
+    valueViewModel: _angular_core.WritableSignal<FieldOption<ValueType>[]>;
+    /** Computed map of checked option values for O(1) lookup in template */
+    readonly checkedValuesMap: _angular_core.Signal<Record<string, boolean>>;
+    constructor();
+    onCheckboxChange(option: FieldOption<ValueType>, checked: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IonicMultiCheckboxFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IonicMultiCheckboxFieldComponent, "df-ion-multi-checkbox", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ng_forge_dynamic_forms_integration.NgForgeFieldHost; inputs: {}; outputs: {}; }]>;
+}
+
+export { IonicMultiCheckboxFieldComponent };
+export type { IonicMultiCheckboxField, IonicMultiCheckboxProps };

package/types/ng-forge-dynamic-forms-ionic-lazy-radio.d.ts

@@ -0,0 +1,25 @@
+import { ValueType, DynamicText, FieldOption } from '@ng-forge/dynamic-forms';
+import * as _ng_forge_dynamic_forms_integration from '@ng-forge/dynamic-forms/integration';
+import { RadioField } from '@ng-forge/dynamic-forms/integration';
+import * as _angular_core from '@angular/core';
+
+interface IonicRadioProps {
+    labelPlacement?: 'start' | 'end' | 'fixed' | 'stacked';
+    justify?: 'start' | 'end' | 'space-between';
+    color?: 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger';
+    compareWith?: (o1: ValueType, o2: ValueType) => boolean;
+    hint?: DynamicText;
+}
+type IonicRadioField<T> = RadioField<T, IonicRadioProps>;
+
+declare class IonicRadioFieldComponent {
+    protected readonly ngf: _ng_forge_dynamic_forms_integration.TypedNgForgeField<ValueType>;
+    readonly options: _angular_core.InputSignal<FieldOption<ValueType>[]>;
+    readonly props: _angular_core.InputSignal<IonicRadioProps | undefined>;
+    defaultCompare: (value1: any, value2: any) => boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IonicRadioFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IonicRadioFieldComponent, "df-ion-radio", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ng_forge_dynamic_forms_integration.NgForgeFieldHost; inputs: {}; outputs: {}; }]>;
+}
+
+export { IonicRadioFieldComponent };
+export type { IonicRadioField, IonicRadioProps };

package/types/ng-forge-dynamic-forms-ionic-lazy-select.d.ts

@@ -0,0 +1,31 @@
+import * as _angular_core from '@angular/core';
+import * as _ng_forge_dynamic_forms_integration from '@ng-forge/dynamic-forms/integration';
+import { SelectField, SelectProps } from '@ng-forge/dynamic-forms/integration';
+import { ValueType, DynamicText, FieldOption } from '@ng-forge/dynamic-forms';
+
+interface IonicSelectProps extends SelectProps {
+    multiple?: boolean;
+    interface?: 'action-sheet' | 'popover' | 'alert';
+    interfaceOptions?: unknown;
+    cancelText?: string;
+    okText?: string;
+    fill?: 'solid' | 'outline';
+    shape?: 'round';
+    labelPlacement?: 'start' | 'end' | 'fixed' | 'stacked' | 'floating';
+    color?: 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger';
+    compareWith?: (o1: ValueType, o2: ValueType) => boolean;
+    hint?: DynamicText;
+}
+type IonicSelectField<T> = SelectField<T, IonicSelectProps>;
+
+declare class IonicSelectFieldComponent {
+    protected readonly ngf: _ng_forge_dynamic_forms_integration.TypedNgForgeField<ValueType>;
+    readonly options: _angular_core.InputSignal<FieldOption<ValueType>[]>;
+    readonly props: _angular_core.InputSignal<IonicSelectProps | undefined>;
+    defaultCompare: (value1: any, value2: any) => boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IonicSelectFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IonicSelectFieldComponent, "df-ion-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ng_forge_dynamic_forms_integration.NgForgeFieldHost; inputs: {}; outputs: {}; }]>;
+}
+
+export { IonicSelectFieldComponent };
+export type { IonicSelectField, IonicSelectProps };

package/types/ng-forge-dynamic-forms-ionic-lazy-slider.d.ts

@@ -0,0 +1,43 @@
+import * as _angular_core from '@angular/core';
+import * as i1 from '@ng-forge/dynamic-forms/integration';
+import { SliderField } from '@ng-forge/dynamic-forms/integration';
+import { DynamicText } from '@ng-forge/dynamic-forms';
+
+interface IonicSliderProps {
+    /**
+     * Adapter-level override for the slider minimum.
+     * Field-level `minValue` (or the validator `min`) takes precedence.
+     */
+    min?: number;
+    /**
+     * Adapter-level override for the slider maximum.
+     * Field-level `maxValue` (or the validator `max`) takes precedence.
+     */
+    max?: number;
+    /**
+     * Adapter-level override for the slider step increment.
+     * Field-level `step` on `SliderField` takes precedence.
+     */
+    step?: number;
+    dualKnobs?: boolean;
+    pin?: boolean;
+    pinFormatter?: (value: number) => string | number;
+    ticks?: boolean;
+    snaps?: boolean;
+    color?: 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger';
+    labelPlacement?: 'start' | 'end' | 'fixed' | 'stacked';
+    hint?: DynamicText;
+}
+type IonicSliderField = SliderField<IonicSliderProps>;
+
+declare class IonicSliderFieldComponent {
+    protected readonly ngf: i1.TypedNgForgeField<number>;
+    readonly step: _angular_core.InputSignal<number | undefined>;
+    readonly props: _angular_core.InputSignal<IonicSliderProps | undefined>;
+    protected defaultPinFormatter: (value: number) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IonicSliderFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IonicSliderFieldComponent, "df-ion-slider", never, { "step": { "alias": "step"; "required": false; "isSignal": true; }; "props": { "alias": "props"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NgForgeFieldHost; inputs: {}; outputs: {}; }, { directive: typeof i1.NgForgeHostControl; inputs: {}; outputs: {}; }]>;
+}
+
+export { IonicSliderFieldComponent };
+export type { IonicSliderField, IonicSliderProps };

package/types/ng-forge-dynamic-forms-ionic-lazy-textarea.d.ts

@@ -0,0 +1,28 @@
+import * as i0 from '@angular/core';
+import * as _ng_forge_dynamic_forms_integration from '@ng-forge/dynamic-forms/integration';
+import { TextareaField, TextareaProps } from '@ng-forge/dynamic-forms/integration';
+import { DynamicText } from '@ng-forge/dynamic-forms';
+
+interface IonicTextareaProps extends TextareaProps {
+    autoGrow?: boolean;
+    counter?: boolean;
+    fill?: 'solid' | 'outline';
+    shape?: 'round';
+    labelPlacement?: 'start' | 'end' | 'fixed' | 'stacked' | 'floating';
+    hint?: DynamicText;
+    errorText?: DynamicText;
+    color?: 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger' | 'light' | 'medium' | 'dark';
+}
+type IonicTextareaField = TextareaField<IonicTextareaProps>;
+
+declare class IonicTextareaFieldComponent {
+    private readonly elementRef;
+    protected readonly ngf: _ng_forge_dynamic_forms_integration.TypedNgForgeField<string>;
+    readonly props: i0.InputSignal<IonicTextareaProps | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<IonicTextareaFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IonicTextareaFieldComponent, "df-ion-textarea", never, { "props": { "alias": "props"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ng_forge_dynamic_forms_integration.NgForgeFieldHost; inputs: {}; outputs: {}; }]>;
+}
+
+export { IonicTextareaFieldComponent };
+export type { IonicTextareaField, IonicTextareaProps };

package/types/ng-forge-dynamic-forms-ionic-lazy-toggle.d.ts

@@ -0,0 +1,66 @@
+import * as _angular_core from '@angular/core';
+import * as _ng_forge_dynamic_forms_integration from '@ng-forge/dynamic-forms/integration';
+import { ToggleField } from '@ng-forge/dynamic-forms/integration';
+import { DynamicText } from '@ng-forge/dynamic-forms';
+import { FormCheckboxControl } from '@angular/forms/signals';
+
+interface IonicToggleProps {
+    labelPlacement?: 'start' | 'end' | 'fixed' | 'stacked';
+    justify?: 'start' | 'end' | 'space-between';
+    color?: 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger';
+    enableOnOffLabels?: boolean;
+    hint?: DynamicText;
+}
+type IonicToggleField = ToggleField<IonicToggleProps>;
+
+declare class IonicToggleFieldComponent {
+    protected readonly ngf: _ng_forge_dynamic_forms_integration.TypedNgForgeField<boolean>;
+    readonly props: _angular_core.InputSignal<IonicToggleProps | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IonicToggleFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IonicToggleFieldComponent, "df-ion-toggle", never, { "props": { "alias": "props"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof _ng_forge_dynamic_forms_integration.NgForgeFieldHost; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * ion-toggle wrapper implementing FormCheckboxControl. Rendered inside
+ * `df-ion-toggle`. `NgForgeControl` on `<ion-toggle>` claims the ambient
+ * parent NgForgeField and routes meta + aria onto that element.
+ */
+declare class IonicToggleControlComponent implements FormCheckboxControl {
+    /** The checked state - required by FormCheckboxControl */
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    /** Tracks whether the field has been touched - used by Field directive */
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    /** Whether the field is disabled */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Whether the field is readonly */
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** Whether the field is invalid (from Field directive) */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** Whether the field is required (from Field directive) */
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly labelPlacement: _angular_core.InputSignal<"start" | "end" | "fixed" | "stacked">;
+    readonly justify: _angular_core.InputSignal<"start" | "end" | "space-between" | undefined>;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly enableOnOffLabels: _angular_core.InputSignal<boolean>;
+    readonly tabIndex: _angular_core.InputSignal<number | undefined>;
+    protected readonly ariaReadonly: _angular_core.Signal<true | null>;
+    /** Computed checked state - ensures proper boolean conversion for ion-toggle */
+    protected readonly isChecked: _angular_core.Signal<boolean>;
+    /**
+     * ion-toggle doesn't have a native readonly attribute.
+     * When readonly, we disable the toggle to prevent changes while maintaining the visual state.
+     */
+    protected readonly isEffectivelyDisabled: _angular_core.Signal<boolean>;
+    /** Handle toggle change - sync ion-toggle's checked state to our checked model */
+    onToggleChange(event: CustomEvent<{
+        checked: boolean;
+        value: string;
+    }>): void;
+    /** Marks the field as touched when toggle loses focus */
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IonicToggleControlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IonicToggleControlComponent, "df-ion-toggle-control", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "labelPlacement": { "alias": "labelPlacement"; "required": false; "isSignal": true; }; "justify": { "alias": "justify"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "enableOnOffLabels": { "alias": "enableOnOffLabels"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "touched": "touchedChange"; }, never, ["*"], true, never>;
+}
+
+export { IonicToggleControlComponent, IonicToggleFieldComponent };
+export type { IonicToggleField, IonicToggleProps };

package/types/ng-forge-dynamic-forms-ionic-shared.d.ts

@@ -0,0 +1,116 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, WritableSignal, Signal } from '@angular/core';
+import * as _ng_forge_dynamic_forms_integration from '@ng-forge/dynamic-forms/integration';
+import { AddonActionHandler, PresetCollaborators } from '@ng-forge/dynamic-forms/integration';
+export { PresetCollaborators } from '@ng-forge/dynamic-forms/integration';
+import { BaseAddon, DynamicText, DynamicValue, AddonActionPreset, RegisteredActionRef, AddonActionContext } from '@ng-forge/dynamic-forms';
+
+/** Configuration options for Ionic form fields. */
+interface IonicConfig {
+    /** Default fill style for form inputs. */
+    fill?: 'solid' | 'outline';
+    /** Default shape for form controls. */
+    shape?: 'round';
+    /** Default label placement for form inputs. */
+    labelPlacement?: 'start' | 'end' | 'fixed' | 'stacked' | 'floating';
+    /** Default color theme for form controls. */
+    color?: 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger' | 'light' | 'medium' | 'dark';
+    /** Default size for buttons. */
+    size?: 'small' | 'default' | 'large';
+    /** Default expand behavior for buttons. */
+    expand?: 'full' | 'block';
+    /** Default fill style for buttons, overriding the general fill. */
+    buttonFill?: 'clear' | 'outline' | 'solid' | 'default';
+    /** Whether buttons should use strong text by default. */
+    strong?: boolean;
+}
+
+/** Global configuration for Ionic form fields. */
+declare const IONIC_CONFIG: InjectionToken<IonicConfig>;
+
+/** Per-field writable signal that overrides the input's `type` attribute. */
+declare const IONIC_INPUT_TYPE_OVERRIDE: InjectionToken<WritableSignal<string | undefined>>;
+
+/** Decorative icon addon for Ionic fields. */
+interface IonicIconAddon extends BaseAddon {
+    readonly type: 'ion-icon';
+    /** Ionons name (e.g., `'search-outline'`, `'close-outline'`). */
+    readonly icon: string;
+    /** Accessible label for icons that convey meaning. */
+    readonly ariaLabel?: DynamicText;
+}
+interface IonicButtonBase extends BaseAddon {
+    readonly type: 'ion-button';
+    readonly color?: 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger' | 'light' | 'medium' | 'dark';
+    readonly fill?: 'clear' | 'outline' | 'solid' | 'default';
+    readonly loading?: DynamicValue<boolean>;
+}
+type IonicButtonActionRef = [RegisteredActionRef] extends [never] ? string : RegisteredActionRef;
+type IonicButtonClick = {
+    readonly preset: AddonActionPreset;
+    readonly actionRef?: never;
+    readonly action?: never;
+} | {
+    readonly preset?: never;
+    readonly actionRef: IonicButtonActionRef;
+    readonly action?: never;
+} | {
+    readonly preset?: never;
+    readonly actionRef?: never;
+    readonly action: AddonActionHandler;
+} | {
+    readonly preset?: never;
+    readonly actionRef?: never;
+    readonly action?: never;
+};
+type IonicButtonContent = {
+    readonly icon: string;
+    readonly label?: never;
+    readonly ariaLabel: DynamicText;
+} | {
+    readonly icon?: string;
+    readonly label: DynamicText;
+    readonly ariaLabel?: DynamicText;
+} | {
+    readonly icon?: never;
+    readonly label?: never;
+    readonly ariaLabel?: DynamicText;
+};
+/** Interactive button addon for Ionic fields. */
+type IonicButtonAddon = IonicButtonBase & IonicButtonContent & IonicButtonClick;
+/** Union of all Ionic-shipped addon types. */
+type IonicAddon = IonicIconAddon | IonicButtonAddon;
+declare module '@ng-forge/dynamic-forms' {
+    interface DynamicFormAddonRegistry {
+        'ion-icon': IonicIconAddon;
+        'ion-button': IonicButtonAddon;
+    }
+}
+
+/**
+ * Inline `ion-button` addon whose host is the slotted Ionic button itself.
+ * It lives in the shared entry because the lazily loaded input component
+ * consumes it while the primary package must not pull in field renderers.
+ */
+declare class IonicInlineButtonAddonComponent {
+    private readonly injector;
+    protected readonly action: _ng_forge_dynamic_forms_integration.TypedNgForgeAddonAction<IonicButtonAddon>;
+    protected readonly addon: Signal<IonicButtonAddon>;
+    protected readonly label: Signal<DynamicText | undefined>;
+    protected readonly ariaLabel: Signal<DynamicText | undefined>;
+    protected readonly icon: Signal<string | undefined>;
+    protected readonly color: Signal<"primary" | "secondary" | "tertiary" | "success" | "warning" | "danger" | "light" | "medium" | "dark" | undefined>;
+    protected readonly fill: Signal<"solid" | "outline" | "default" | "clear">;
+    protected readonly iconOnly: Signal<boolean>;
+    private readonly ariaLabelSignal;
+    protected readonly resolvedAriaLabel: Signal<string | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<IonicInlineButtonAddonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IonicInlineButtonAddonComponent, "ion-button[df-ion-button-addon]", never, {}, {}, never, never, true, [{ directive: typeof _ng_forge_dynamic_forms_integration.NgForgeAddonAction; inputs: {}; outputs: {}; }]>;
+}
+
+/** Ionic adapter binding for the shared preset runner. */
+declare function runIonicPresetAction(preset: AddonActionPreset, context: AddonActionContext, collaborators: PresetCollaborators): Promise<void>;
+
+export { IONIC_CONFIG, IONIC_INPUT_TYPE_OVERRIDE, IonicInlineButtonAddonComponent, runIonicPresetAction };
+export type { IonicAddon, IonicButtonAddon, IonicConfig, IonicIconAddon };