@ngx-formly/material 8.0.0 → 10.0.0

package/package.json

@@ -1,70 +1,71 @@
 {
   "name": "@ngx-formly/material",
-  "version": "8.0.0",
+  "version": "10.0.0",
   "license": "MIT",
   "dependencies": {
     "tslib": "^2.0.0"
   },
   "peerDependencies": {
-    "@ngx-formly/core": "8.0.0",
-    "@angular/material": ">=19.0.0"
+    "@ngx-formly/core": "10.0.0",
+    "@angular/material": ">=21.0.0"
   },
   "module": "fesm2022/ngx-formly-material.mjs",
-  "typings": "index.d.ts",
+  "typings": "types/ngx-formly-material.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./index.d.ts",
+      "types": "./types/ngx-formly-material.d.ts",
       "default": "./fesm2022/ngx-formly-material.mjs"
     },
     "./checkbox": {
-      "types": "./checkbox/index.d.ts",
+      "types": "./types/ngx-formly-material-checkbox.d.ts",
       "default": "./fesm2022/ngx-formly-material-checkbox.mjs"
     },
     "./datepicker": {
-      "types": "./datepicker/index.d.ts",
+      "types": "./types/ngx-formly-material-datepicker.d.ts",
       "default": "./fesm2022/ngx-formly-material-datepicker.mjs"
     },
     "./form-field": {
-      "types": "./form-field/index.d.ts",
+      "types": "./types/ngx-formly-material-form-field.d.ts",
       "default": "./fesm2022/ngx-formly-material-form-field.mjs"
     },
     "./input": {
-      "types": "./input/index.d.ts",
+      "types": "./types/ngx-formly-material-input.d.ts",
       "default": "./fesm2022/ngx-formly-material-input.mjs"
     },
     "./multicheckbox": {
-      "types": "./multicheckbox/index.d.ts",
+      "types": "./types/ngx-formly-material-multicheckbox.d.ts",
       "default": "./fesm2022/ngx-formly-material-multicheckbox.mjs"
     },
-    "./radio": {
-      "types": "./radio/index.d.ts",
-      "default": "./fesm2022/ngx-formly-material-radio.mjs"
-    },
     "./native-select": {
-      "types": "./native-select/index.d.ts",
+      "types": "./types/ngx-formly-material-native-select.d.ts",
       "default": "./fesm2022/ngx-formly-material-native-select.mjs"
     },
+    "./radio": {
+      "types": "./types/ngx-formly-material-radio.d.ts",
+      "default": "./fesm2022/ngx-formly-material-radio.mjs"
+    },
     "./select": {
-      "types": "./select/index.d.ts",
+      "types": "./types/ngx-formly-material-select.d.ts",
       "default": "./fesm2022/ngx-formly-material-select.mjs"
     },
     "./slider": {
-      "types": "./slider/index.d.ts",
+      "types": "./types/ngx-formly-material-slider.d.ts",
       "default": "./fesm2022/ngx-formly-material-slider.mjs"
     },
     "./textarea": {
-      "types": "./textarea/index.d.ts",
+      "types": "./types/ngx-formly-material-textarea.d.ts",
       "default": "./fesm2022/ngx-formly-material-textarea.mjs"
     },
     "./toggle": {
-      "types": "./toggle/index.d.ts",
+      "types": "./types/ngx-formly-material-toggle.d.ts",
       "default": "./fesm2022/ngx-formly-material-toggle.mjs"
     }
   },
   "sideEffects": false,
+  "type": "module",
   "homepage": "https://github.com/ngx-formly/ngx-formly#readme",
   "description": "Formly is a dynamic (JSON powered) form library for Angular that bring unmatched maintainability to your application's forms.",
   "repository": {

package/types/ngx-formly-material-checkbox.d.ts

@@ -0,0 +1,52 @@
+import * as i6 from '@ngx-formly/core';
+import { ConfigOption, FormlyFieldConfig, FieldTypeConfig } from '@ngx-formly/core';
+import * as i0 from '@angular/core';
+import { Type, AfterViewInit, AfterViewChecked, OnDestroy, Renderer2 } from '@angular/core';
+import * as i5 from '@ngx-formly/material/form-field';
+import { FormlyFieldProps, FieldType } from '@ngx-formly/material/form-field';
+import * as i4 from '@angular/material/checkbox';
+import { MatCheckbox } from '@angular/material/checkbox';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/forms';
+
+declare function withFormlyFieldCheckbox(): ConfigOption;
+
+interface CheckboxProps extends FormlyFieldProps {
+    indeterminate?: boolean;
+    labelPosition?: 'before' | 'after';
+}
+interface FormlyCheckboxFieldConfig extends FormlyFieldConfig<CheckboxProps> {
+    type: 'checkbox' | Type<FormlyFieldCheckbox>;
+}
+declare class FormlyFieldCheckbox extends FieldType<FieldTypeConfig<CheckboxProps>> implements AfterViewInit, AfterViewChecked, OnDestroy {
+    private renderer;
+    private focusMonitor;
+    checkbox: MatCheckbox;
+    defaultOptions: {
+        props: {
+            hideFieldUnderline: boolean;
+            indeterminate: boolean;
+            floatLabel: "always";
+            hideLabel: boolean;
+            color: "accent";
+        };
+    };
+    private _required;
+    constructor(renderer: Renderer2, focusMonitor: FocusMonitor);
+    onContainerClick(event: MouseEvent): void;
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyFieldCheckbox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyFieldCheckbox, "formly-field-mat-checkbox", never, {}, {}, never, never, false, never>;
+}
+
+declare class FormlyMatCheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyMatCheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyMatCheckboxModule, [typeof FormlyFieldCheckbox], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4.MatCheckboxModule, typeof i5.FormlyMatFormFieldModule, typeof i6.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyMatCheckboxModule>;
+}
+
+export { FormlyFieldCheckbox, FormlyMatCheckboxModule, withFormlyFieldCheckbox };
+export type { FormlyCheckboxFieldConfig };

package/{datepicker/datepicker.type.d.ts → types/ngx-formly-material-datepicker.d.ts}

@@ -1,9 +1,18 @@
-import { AfterViewInit, OnDestroy, TemplateRef, ChangeDetectorRef, Type } from '@angular/core';
-import { FieldTypeConfig, FormlyConfig, FormlyFieldConfig } from '@ngx-formly/core';
-import { FieldType, FormlyFieldProps } from '@ngx-formly/material/form-field';
+import * as i7 from '@ngx-formly/core';
+import { ConfigOption, FormlyFieldConfig, FieldTypeConfig, FormlyConfig } from '@ngx-formly/core';
+import * as i0 from '@angular/core';
+import { Type, AfterViewInit, OnDestroy, TemplateRef, ChangeDetectorRef } from '@angular/core';
+import * as i6 from '@ngx-formly/material/form-field';
+import { FormlyFieldProps, FieldType } from '@ngx-formly/material/form-field';
 import { ComponentType } from '@angular/cdk/portal';
-import { MatCalendarCellClassFunction, MatDatepicker } from '@angular/material/datepicker';
-import * as i0 from "@angular/core";
+import * as i5 from '@angular/material/datepicker';
+import { MatDatepicker, MatCalendarCellClassFunction } from '@angular/material/datepicker';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/forms';
+import * as i4 from '@angular/material/input';
+
+declare function withFormlyFieldDatepicker(): ConfigOption;
+
 interface DatepickerProps extends FormlyFieldProps {
     datepickerOptions?: Partial<{
         touchUi: boolean;
@@ -24,10 +33,10 @@ interface DatepickerProps extends FormlyFieldProps {
         startAt: any | null;
     }>;
 }
-export interface FormlyDatepickerFieldConfig extends FormlyFieldConfig<DatepickerProps> {
+interface FormlyDatepickerFieldConfig extends FormlyFieldConfig<DatepickerProps> {
     type: 'datepicker' | Type<FormlyFieldDatepicker>;
 }
-export declare class FormlyFieldDatepicker extends FieldType<FieldTypeConfig<DatepickerProps>> implements AfterViewInit, OnDestroy {
+declare class FormlyFieldDatepicker extends FieldType<FieldTypeConfig<DatepickerProps>> implements AfterViewInit, OnDestroy {
     private config;
     private cdRef;
     datepickerToggle: TemplateRef<any>;
@@ -53,4 +62,12 @@ export declare class FormlyFieldDatepicker extends FieldType<FieldTypeConfig<Dat
     static ɵfac: i0.ɵɵFactoryDeclaration<FormlyFieldDatepicker, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FormlyFieldDatepicker, "formly-field-mat-datepicker", never, {}, {}, never, never, false, never>;
 }
-export {};
+
+declare class FormlyMatDatepickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyMatDatepickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyMatDatepickerModule, [typeof FormlyFieldDatepicker], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4.MatInputModule, typeof i5.MatDatepickerModule, typeof i6.FormlyMatFormFieldModule, typeof i7.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyMatDatepickerModule>;
+}
+
+export { FormlyFieldDatepicker, FormlyMatDatepickerModule, withFormlyFieldDatepicker };
+export type { FormlyDatepickerFieldConfig };

package/types/ngx-formly-material-form-field.d.ts

@@ -0,0 +1,84 @@
+import * as i5 from '@ngx-formly/core';
+import { ConfigOption, FormlyFieldProps as FormlyFieldProps$1, FieldWrapper, FormlyFieldConfig, FieldType as FieldType$1 } from '@ngx-formly/core';
+import * as i0 from '@angular/core';
+import { TemplateRef, OnInit, OnDestroy, AfterViewInit, Renderer2, ElementRef, QueryList } from '@angular/core';
+import * as i4 from '@angular/material/form-field';
+import { FloatLabelType, MatFormFieldAppearance, MatFormField, MatFormFieldControl } from '@angular/material/form-field';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { ThemePalette, ErrorStateMatcher } from '@angular/material/core';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/forms';
+import { Subject } from 'rxjs';
+
+declare function withFormlyFormField(): ConfigOption;
+
+interface MatFormlyFieldConfig extends FormlyFieldConfig<FormlyFieldProps> {
+    _formField?: FormlyWrapperFormField;
+}
+interface FormlyFieldProps extends FormlyFieldProps$1 {
+    prefix?: TemplateRef<any>;
+    suffix?: TemplateRef<any>;
+    textPrefix?: TemplateRef<any>;
+    textSuffix?: TemplateRef<any>;
+    hideLabel?: boolean;
+    hideRequiredMarker?: boolean;
+    hideFieldUnderline?: boolean;
+    floatLabel?: FloatLabelType;
+    appearance?: MatFormFieldAppearance;
+    subscriptSizing?: 'fixed' | 'dynamic';
+    color?: ThemePalette;
+    hintStart?: TemplateRef<any> | string;
+    hintEnd?: TemplateRef<any> | string;
+}
+declare class FormlyWrapperFormField extends FieldWrapper<MatFormlyFieldConfig> implements OnInit, OnDestroy, AfterViewInit {
+    private renderer;
+    private elementRef;
+    private focusMonitor;
+    formField: MatFormField;
+    constructor(renderer: Renderer2, elementRef: ElementRef, focusMonitor: FocusMonitor);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyWrapperFormField, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyWrapperFormField, "formly-wrapper-mat-form-field", never, {}, {}, never, never, false, never>;
+}
+
+declare class FormlyMatFormFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyMatFormFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyMatFormFieldModule, [typeof FormlyWrapperFormField], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4.MatFormFieldModule, typeof i5.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyMatFormFieldModule>;
+}
+
+declare abstract class FieldType<F extends FormlyFieldConfig<FormlyFieldProps>> extends FieldType$1<F> implements OnDestroy, MatFormFieldControl<any> {
+    set matPrefix(prefix: TemplateRef<any>);
+    set matTextPrefix(textPrefix: TemplateRef<any>);
+    set matSuffix(suffix: TemplateRef<any>);
+    set matTextSuffix(textSuffix: TemplateRef<any>);
+    set _controls(controls: QueryList<MatFormFieldControl<any>>);
+    errorStateMatcher: ErrorStateMatcher;
+    stateChanges: Subject<void>;
+    _errorState: boolean;
+    _focused: boolean;
+    ngOnDestroy(): void;
+    setDescribedByIds(_ids: string[]): void;
+    onContainerClick(_event: MouseEvent): void;
+    get errorState(): boolean;
+    get controlType(): any;
+    get focused(): boolean;
+    get disabled(): boolean;
+    get required(): boolean;
+    get placeholder(): string;
+    get shouldPlaceholderFloat(): boolean;
+    get value(): any;
+    set value(value: any);
+    get ngControl(): any;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    get formField(): MatFormField;
+    private attachControl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldType<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FieldType<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+export { FieldType, FormlyMatFormFieldModule, withFormlyFormField };
+export type { FormlyFieldProps };

package/types/ngx-formly-material-input.d.ts

@@ -0,0 +1,31 @@
+import * as i6 from '@ngx-formly/core';
+import { ConfigOption, FieldTypeConfig, FormlyFieldConfig } from '@ngx-formly/core';
+import * as i0 from '@angular/core';
+import { Type } from '@angular/core';
+import * as i5 from '@ngx-formly/material/form-field';
+import { FieldType, FormlyFieldProps } from '@ngx-formly/material/form-field';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/forms';
+import * as i4 from '@angular/material/input';
+
+declare function withFormlyFieldInput(): ConfigOption;
+
+interface InputProps extends FormlyFieldProps {
+}
+interface FormlyInputFieldConfig extends FormlyFieldConfig<InputProps> {
+    type: 'input' | Type<FormlyFieldInput>;
+}
+declare class FormlyFieldInput extends FieldType<FieldTypeConfig<InputProps>> {
+    get type(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyFieldInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyFieldInput, "formly-field-mat-input", never, {}, {}, never, never, false, never>;
+}
+
+declare class FormlyMatInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyMatInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyMatInputModule, [typeof FormlyFieldInput], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4.MatInputModule, typeof i5.FormlyMatFormFieldModule, typeof i6.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyMatInputModule>;
+}
+
+export { FormlyFieldInput, FormlyMatInputModule, withFormlyFieldInput };
+export type { FormlyInputFieldConfig };

package/types/ngx-formly-material-multicheckbox.d.ts

@@ -0,0 +1,44 @@
+import * as i7 from '@ngx-formly/core';
+import { ConfigOption, FieldTypeConfig, FormlyFieldConfig } from '@ngx-formly/core';
+import * as i0 from '@angular/core';
+import { QueryList, Type } from '@angular/core';
+import * as i4 from '@angular/material/checkbox';
+import { MatCheckbox } from '@angular/material/checkbox';
+import * as i5 from '@ngx-formly/material/form-field';
+import { FieldType, FormlyFieldProps } from '@ngx-formly/material/form-field';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/forms';
+import * as i6 from '@ngx-formly/core/select';
+
+declare function withFormlyFieldMultiCheckbox(): ConfigOption;
+
+interface MultiCheckboxProps extends FormlyFieldProps {
+    labelPosition?: 'before' | 'after';
+}
+interface FormlyMultiCheckboxFieldConfig extends FormlyFieldConfig<MultiCheckboxProps> {
+    type: 'multicheckbox' | Type<FormlyFieldMultiCheckbox>;
+}
+declare class FormlyFieldMultiCheckbox extends FieldType<FieldTypeConfig<MultiCheckboxProps>> {
+    checkboxes: QueryList<MatCheckbox>;
+    defaultOptions: {
+        props: {
+            hideFieldUnderline: boolean;
+            floatLabel: "always";
+            color: "accent";
+        };
+    };
+    onChange(value: any, checked: boolean): void;
+    onContainerClick(): void;
+    isChecked(option: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyFieldMultiCheckbox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyFieldMultiCheckbox, "formly-field-mat-multicheckbox", never, {}, {}, never, never, false, never>;
+}
+
+declare class FormlyMatMultiCheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyMatMultiCheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyMatMultiCheckboxModule, [typeof FormlyFieldMultiCheckbox], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4.MatCheckboxModule, typeof i5.FormlyMatFormFieldModule, typeof i6.FormlySelectModule, typeof i7.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyMatMultiCheckboxModule>;
+}
+
+export { FormlyFieldMultiCheckbox, FormlyMatMultiCheckboxModule, withFormlyFieldMultiCheckbox };
+export type { FormlyMultiCheckboxFieldConfig };

package/types/ngx-formly-material-native-select.d.ts

@@ -0,0 +1,32 @@
+import * as i7 from '@ngx-formly/core';
+import { ConfigOption, FieldTypeConfig, FormlyFieldConfig } from '@ngx-formly/core';
+import * as i0 from '@angular/core';
+import { Type } from '@angular/core';
+import * as i6 from '@ngx-formly/core/select';
+import { FormlyFieldSelectProps } from '@ngx-formly/core/select';
+import * as i5 from '@ngx-formly/material/form-field';
+import { FieldType, FormlyFieldProps } from '@ngx-formly/material/form-field';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/forms';
+import * as i4 from '@angular/material/input';
+
+declare function withFormlyFieldNativeSelect(): ConfigOption;
+
+interface NativeSelectProps extends FormlyFieldProps, FormlyFieldSelectProps {
+}
+interface FormlyNativeSelectFieldConfig extends FormlyFieldConfig<NativeSelectProps> {
+    type: 'native-select' | Type<FormlyFieldNativeSelect>;
+}
+declare class FormlyFieldNativeSelect extends FieldType<FieldTypeConfig<NativeSelectProps>> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyFieldNativeSelect, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyFieldNativeSelect, "formly-field-mat-native-select", never, {}, {}, never, never, false, never>;
+}
+
+declare class FormlyMatNativeSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyMatNativeSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyMatNativeSelectModule, [typeof FormlyFieldNativeSelect], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4.MatInputModule, typeof i5.FormlyMatFormFieldModule, typeof i6.FormlySelectModule, typeof i7.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyMatNativeSelectModule>;
+}
+
+export { FormlyFieldNativeSelect, FormlyMatNativeSelectModule, withFormlyFieldNativeSelect };
+export type { FormlyNativeSelectFieldConfig };

package/types/ngx-formly-material-radio.d.ts

@@ -0,0 +1,45 @@
+import * as i7 from '@ngx-formly/core';
+import { ConfigOption, FieldTypeConfig, FormlyFieldConfig } from '@ngx-formly/core';
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, Type } from '@angular/core';
+import * as i5 from '@ngx-formly/material/form-field';
+import { FieldType, FormlyFieldProps } from '@ngx-formly/material/form-field';
+import * as i4 from '@angular/material/radio';
+import { MatRadioGroup } from '@angular/material/radio';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/forms';
+import * as i6 from '@ngx-formly/core/select';
+
+declare function withFormlyFieldRadio(): ConfigOption;
+
+interface RadioProps extends FormlyFieldProps {
+    labelPosition?: 'before' | 'after';
+}
+interface FormlyRadioFieldConfig extends FormlyFieldConfig<RadioProps> {
+    type: 'radio' | Type<FormlyFieldRadio>;
+}
+declare class FormlyFieldRadio extends FieldType<FieldTypeConfig<RadioProps>> implements AfterViewInit, OnDestroy {
+    radioGroup: MatRadioGroup;
+    defaultOptions: {
+        props: {
+            hideFieldUnderline: boolean;
+            floatLabel: "always";
+            tabindex: number;
+        };
+    };
+    private focusObserver;
+    ngAfterViewInit(): void;
+    onContainerClick(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyFieldRadio, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyFieldRadio, "formly-field-mat-radio", never, {}, {}, never, never, false, never>;
+}
+
+declare class FormlyMatRadioModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyMatRadioModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyMatRadioModule, [typeof FormlyFieldRadio], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4.MatRadioModule, typeof i5.FormlyMatFormFieldModule, typeof i6.FormlySelectModule, typeof i7.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyMatRadioModule>;
+}
+
+export { FormlyFieldRadio, FormlyMatRadioModule, withFormlyFieldRadio };
+export type { FormlyRadioFieldConfig };

package/types/ngx-formly-material-select.d.ts

@@ -0,0 +1,54 @@
+import * as i8 from '@ngx-formly/core';
+import { ConfigOption, FieldTypeConfig, FormlyFieldConfig } from '@ngx-formly/core';
+import * as i0 from '@angular/core';
+import { Type } from '@angular/core';
+import * as i4 from '@angular/material/select';
+import { MatSelectChange } from '@angular/material/select';
+import * as i6 from '@ngx-formly/material/form-field';
+import { FieldType, FormlyFieldProps } from '@ngx-formly/material/form-field';
+import * as i7 from '@ngx-formly/core/select';
+import { FormlyFieldSelectProps } from '@ngx-formly/core/select';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/forms';
+import * as i5 from '@angular/material/core';
+
+declare function withFormlyFieldSelect(): ConfigOption;
+
+interface SelectProps extends FormlyFieldProps, FormlyFieldSelectProps {
+    multiple?: boolean;
+    selectAllOption?: string;
+    disableOptionCentering?: boolean;
+    typeaheadDebounceInterval?: number;
+    compareWith?: (o1: any, o2: any) => boolean;
+    panelClass?: string;
+    panelWidth?: string | number | null;
+}
+interface FormlySelectFieldConfig extends FormlyFieldConfig<SelectProps> {
+    type: 'select' | Type<FormlyFieldSelect>;
+}
+declare class FormlyFieldSelect extends FieldType<FieldTypeConfig<SelectProps>> {
+    set select(select: any);
+    defaultOptions: {
+        props: {
+            compareWith(o1: any, o2: any): boolean;
+        };
+    };
+    private selectAllValue;
+    getSelectAllState(options: any[]): "indeterminate" | "checked";
+    toggleSelectAll(options: any[]): void;
+    change($event: MatSelectChange): void;
+    _getAriaLabelledby(): string;
+    _getAriaLabel(): string;
+    private getSelectAllValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyFieldSelect, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyFieldSelect, "formly-field-mat-select", never, {}, {}, never, never, false, never>;
+}
+
+declare class FormlyMatSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyMatSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyMatSelectModule, [typeof FormlyFieldSelect], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4.MatSelectModule, typeof i5.MatPseudoCheckboxModule, typeof i6.FormlyMatFormFieldModule, typeof i7.FormlySelectModule, typeof i8.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyMatSelectModule>;
+}
+
+export { FormlyFieldSelect, FormlyMatSelectModule, withFormlyFieldSelect };
+export type { FormlySelectFieldConfig };

package/types/ngx-formly-material-slider.d.ts

@@ -0,0 +1,43 @@
+import * as i7 from '@ngx-formly/core';
+import { ConfigOption, FieldTypeConfig, FormlyFieldConfig } from '@ngx-formly/core';
+import * as i0 from '@angular/core';
+import { Type } from '@angular/core';
+import * as i6 from '@ngx-formly/material/form-field';
+import { FieldType, FormlyFieldProps } from '@ngx-formly/material/form-field';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/material/core';
+import * as i4 from '@angular/forms';
+import * as i5 from '@angular/material/slider';
+
+declare function withFormlyFieldSlider(): ConfigOption;
+
+interface SliderProps extends FormlyFieldProps {
+    displayWith?: (value: number) => string;
+    discrete?: boolean;
+    showTickMarks?: boolean;
+    input?: (field: FormlyFieldConfig<SliderProps>, $event: Event) => void;
+    change?: (field: FormlyFieldConfig<SliderProps>, $event: Event) => void;
+}
+interface FormlySliderFieldConfig extends FormlyFieldConfig<SliderProps> {
+    type: 'slider' | Type<FormlyFieldSlider>;
+}
+declare class FormlyFieldSlider extends FieldType<FieldTypeConfig<SliderProps>> {
+    defaultOptions: {
+        props: {
+            hideFieldUnderline: boolean;
+            floatLabel: "always";
+            displayWith: (value: number) => string;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyFieldSlider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyFieldSlider, "formly-field-mat-slider", never, {}, {}, never, never, false, never>;
+}
+
+declare class FormlyMatSliderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyMatSliderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyMatSliderModule, [typeof FormlyFieldSlider], [typeof i2.CommonModule, typeof i3.MatRippleModule, typeof i4.ReactiveFormsModule, typeof i5.MatSliderModule, typeof i6.FormlyMatFormFieldModule, typeof i7.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyMatSliderModule>;
+}
+
+export { FormlyFieldSlider, FormlyMatSliderModule, withFormlyFieldSlider };
+export type { FormlySliderFieldConfig };

package/types/ngx-formly-material-textarea.d.ts

@@ -0,0 +1,39 @@
+import * as i6 from '@ngx-formly/core';
+import { ConfigOption, FieldTypeConfig, FormlyFieldConfig } from '@ngx-formly/core';
+import * as i0 from '@angular/core';
+import { Type } from '@angular/core';
+import * as i5 from '@ngx-formly/material/form-field';
+import { FieldType, FormlyFieldProps } from '@ngx-formly/material/form-field';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/forms';
+import * as i4 from '@angular/material/input';
+
+declare function withFormlyFieldTextArea(): ConfigOption;
+
+interface TextAreaProps extends FormlyFieldProps {
+    autosize?: boolean;
+    autosizeMinRows?: number;
+    autosizeMaxRows?: number;
+}
+interface FormlyTextAreaFieldConfig extends FormlyFieldConfig<TextAreaProps> {
+    type: 'textarea' | Type<FormlyFieldTextArea>;
+}
+declare class FormlyFieldTextArea extends FieldType<FieldTypeConfig<TextAreaProps>> {
+    defaultOptions: {
+        props: {
+            cols: number;
+            rows: number;
+        };
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyFieldTextArea, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyFieldTextArea, "formly-field-mat-textarea", never, {}, {}, never, never, false, never>;
+}
+
+declare class FormlyMatTextAreaModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyMatTextAreaModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyMatTextAreaModule, [typeof FormlyFieldTextArea], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4.MatInputModule, typeof i5.FormlyMatFormFieldModule, typeof i6.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyMatTextAreaModule>;
+}
+
+export { FormlyFieldTextArea, FormlyMatTextAreaModule, withFormlyFieldTextArea };
+export type { FormlyTextAreaFieldConfig };

package/types/ngx-formly-material-toggle.d.ts

@@ -0,0 +1,41 @@
+import * as i6 from '@ngx-formly/core';
+import { ConfigOption, FieldTypeConfig, FormlyFieldConfig } from '@ngx-formly/core';
+import * as i0 from '@angular/core';
+import { Type } from '@angular/core';
+import * as i5 from '@ngx-formly/material/form-field';
+import { FieldType, FormlyFieldProps } from '@ngx-formly/material/form-field';
+import * as i4 from '@angular/material/slide-toggle';
+import { MatSlideToggle } from '@angular/material/slide-toggle';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/forms';
+
+declare function withFormlyFieldToggle(): ConfigOption;
+
+interface ToggleProps extends FormlyFieldProps {
+    labelPosition?: 'before' | 'after';
+}
+interface FormlyToggleFieldConfig extends FormlyFieldConfig<ToggleProps> {
+    type: 'toggle' | Type<FormlyFieldToggle>;
+}
+declare class FormlyFieldToggle extends FieldType<FieldTypeConfig<ToggleProps>> {
+    slideToggle: MatSlideToggle;
+    defaultOptions: {
+        props: {
+            hideFieldUnderline: boolean;
+            floatLabel: "always";
+            hideLabel: boolean;
+        };
+    };
+    onContainerClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyFieldToggle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyFieldToggle, "formly-field-mat-toggle", never, {}, {}, never, never, false, never>;
+}
+
+declare class FormlyMatToggleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyMatToggleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyMatToggleModule, [typeof FormlyFieldToggle], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4.MatSlideToggleModule, typeof i5.FormlyMatFormFieldModule, typeof i6.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyMatToggleModule>;
+}
+
+export { FormlyFieldToggle, FormlyMatToggleModule, withFormlyFieldToggle };
+export type { FormlyToggleFieldConfig };

package/types/ngx-formly-material.d.ts

@@ -0,0 +1,20 @@
+import * as _ngx_formly_core_types_ngx_formly_core from '@ngx-formly/core/types/ngx-formly-core';
+import * as i1 from '@ngx-formly/material/form-field';
+export { FieldType } from '@ngx-formly/material/form-field';
+import * as i0 from '@angular/core';
+import * as i2 from '@ngx-formly/material/input';
+import * as i3 from '@ngx-formly/material/textarea';
+import * as i4 from '@ngx-formly/material/radio';
+import * as i5 from '@ngx-formly/material/checkbox';
+import * as i6 from '@ngx-formly/material/multicheckbox';
+import * as i7 from '@ngx-formly/material/select';
+
+declare function withFormlyMaterial(): _ngx_formly_core_types_ngx_formly_core.ConfigOption[];
+
+declare class FormlyMaterialModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyMaterialModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyMaterialModule, never, [typeof i1.FormlyMatFormFieldModule, typeof i2.FormlyMatInputModule, typeof i3.FormlyMatTextAreaModule, typeof i4.FormlyMatRadioModule, typeof i5.FormlyMatCheckboxModule, typeof i6.FormlyMatMultiCheckboxModule, typeof i7.FormlyMatSelectModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyMaterialModule>;
+}
+
+export { FormlyMaterialModule, withFormlyMaterial };

package/checkbox/checkbox.config.d.ts

@@ -1,2 +0,0 @@
-import { ConfigOption } from '@ngx-formly/core';
-export declare function withFormlyFieldCheckbox(): ConfigOption;