@ngrdt/forms 0.0.18

package/index.d.ts

@@ -0,0 +1,460 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy, Injector, Signal, InjectionToken } from '@angular/core';
+import * as _angular_forms from '@angular/forms';
+import { ControlValueAccessor, AbstractControl, ValidationErrors, NgControl, FormControl, ValidatorFn } from '@angular/forms';
+import { RdtInteractiveElementComponent } from '@ngrdt/core';
+import { Nullable, RdtFile, RdtMimeType, RdtCombinedMimeType, AllEncodingAliases } from '@ngrdt/utils';
+import * as _ngrdt_forms from '@ngrdt/forms';
+import * as rxjs from 'rxjs';
+import { Observable, Subscription } from 'rxjs';
+import * as _ngrx_signals from '@ngrx/signals';
+import { Highlightable } from '@angular/cdk/a11y';
+
+declare abstract class RdtBaseFormInputComponent<TExt, TInt = TExt> extends RdtInteractiveElementComponent implements ControlValueAccessor, OnInit, OnDestroy {
+    readonly injector: Injector;
+    protected readonly _control: _angular_core.WritableSignal<AbstractControl<TExt, TExt, any> | null>;
+    readonly control: Signal<AbstractControl<TExt, TExt, any> | null>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly externalValue: _angular_core.ModelSignal<TExt | null>;
+    readonly internalValue: _angular_core.WritableSignal<TInt | null>;
+    readonly dataTestIdInput: _angular_core.InputSignal<undefined>;
+    readonly dataTestId: _angular_core.WritableSignal<string>;
+    protected readonly readonlyInput: _angular_core.InputSignalWithTransform<boolean | null, Nullable<string | number | boolean>>;
+    readonly requiredInput: _angular_core.InputSignalWithTransform<Nullable<boolean>, Nullable<string | number | boolean>>;
+    protected readonly requiredFromControl: _angular_core.WritableSignal<boolean>;
+    readonly required: _angular_core.WritableSignal<boolean>;
+    protected readonly touchedInternal: _angular_core.WritableSignal<boolean>;
+    readonly touched: Signal<any>;
+    readonly invalid: Signal<boolean>;
+    protected readonly requiredEffect: _angular_core.EffectRef;
+    private readonly requiredError;
+    private readonly controlErrors;
+    readonly errors: Signal<{
+        required: boolean;
+    } | ValidationErrors | null>;
+    readonly visibleErrors: Signal<ValidationErrors | null>;
+    get ngControl(): NgControl | null;
+    private _ngControl;
+    private _onChange;
+    private _onTouch;
+    private _onValidatorChange;
+    get onChange(): (value: any) => void;
+    get onTouch(): () => void;
+    get onValidatorChange(): () => void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: () => void): void;
+    writeValue(value: any): void;
+    validate(control: AbstractControl<TExt>): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    protected abstract isEmpty(value: TExt | null): boolean;
+    onInternalValueChange(value: TInt | null): void;
+    protected toExternalValue(internalValue: TInt | null): TExt | null;
+    protected toInternalValue(externalValue: TExt | null): TInt | null;
+    onBlur(): void;
+    private getRequiredError;
+    private static readonly REQUIRED_ERROR;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdtBaseFormInputComponent<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdtBaseFormInputComponent<any, any>, never, never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "externalValue": { "alias": "value"; "required": false; "isSignal": true; }; "dataTestIdInput": { "alias": "dataTestId"; "required": false; "isSignal": true; }; "readonlyInput": { "alias": "readonly"; "required": false; "isSignal": true; }; "requiredInput": { "alias": "required"; "required": false; "isSignal": true; }; }, { "externalValue": "valueChange"; }, never, never, true, never>;
+}
+
+declare abstract class RdtCheckboxComponent<TTrue = true, TFalse = false> extends RdtBaseFormInputComponent<TTrue | TFalse, boolean> {
+    protected readonly trueValueInput: _angular_core.InputSignal<TTrue>;
+    readonly trueValue: _angular_core.WritableSignal<TTrue>;
+    readonly falseValueInput: _angular_core.InputSignal<TFalse>;
+    readonly falseValue: _angular_core.WritableSignal<TFalse>;
+    readonly indeterminate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected toExternalValue(internalValue: boolean | null): TTrue | TFalse | null;
+    protected toInternalValue(externalValue: TTrue | TFalse | null): boolean | null;
+    protected isEmpty(value: TTrue | TFalse | null): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdtCheckboxComponent<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdtCheckboxComponent<any, any>, never, never, { "trueValueInput": { "alias": "trueValue"; "required": false; "isSignal": true; }; "falseValueInput": { "alias": "falseValue"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type RdtDateType = 'date' | 'month' | 'week' | 'datetime-local' | 'time';
+
+declare abstract class RdtDateComponent<TExt = string, TInt = TExt> extends RdtBaseFormInputComponent<TExt, TInt> {
+    readonly type: _angular_core.InputSignal<RdtDateType>;
+    protected readonly minInput: _angular_core.InputSignalWithTransform<Nullable<TExt>, TExt | null>;
+    readonly min: _angular_core.WritableSignal<TInt | null>;
+    protected readonly maxInput: _angular_core.InputSignalWithTransform<Nullable<TExt>, TExt | null>;
+    readonly max: _angular_core.WritableSignal<TInt | null>;
+    protected isEmpty(value: TExt | null): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdtDateComponent<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdtDateComponent<any, any>, never, never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "minInput": { "alias": "minInput"; "required": false; "isSignal": true; }; "maxInput": { "alias": "maxInput"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class RdtFileReader<T> {
+    abstract extractData(files: File): Observable<T>;
+    read(file: File): Observable<RdtFile<T>>;
+    readAll(files: File[]): Observable<RdtFile<T>[]>;
+}
+
+type AcceptType = (RdtMimeType | RdtCombinedMimeType)[] | RdtMimeType | RdtCombinedMimeType;
+declare abstract class RdtFileInputComponent<TExt = string> extends RdtBaseFormInputComponent<TExt> {
+    protected readonly defaultFileReader: RdtFileReader<unknown>;
+    protected readonly defaultMaxFileSize: `${number} B` | `${number} KB` | `${number} MB` | `${number} GB` | `${number} TB` | `${number} PB` | `${number} EB` | `${number} ZB` | `${number} YB`;
+    protected readonly defaultLabelFn: _ngrdt_forms.RdtFileLabelFn;
+    protected readonly readerInput: _angular_core.InputSignal<RdtFileReader<TExt>>;
+    readonly reader: _angular_core.WritableSignal<RdtFileReader<TExt>>;
+    protected readonly acceptInput: _angular_core.InputSignalWithTransform<AcceptType | undefined, Nullable<AcceptType>>;
+    readonly accept: _angular_core.WritableSignal<(RdtMimeType | RdtCombinedMimeType)[] | undefined>;
+    readonly jointAccept: _angular_core.Signal<string | undefined>;
+    protected readonly maxFileSizeInput: _angular_core.InputSignalWithTransform<Nullable<`${number} B` | `${number} KB` | `${number} MB` | `${number} GB` | `${number} TB` | `${number} PB` | `${number} EB` | `${number} ZB` | `${number} YB`>, `${number} B` | `${number} KB` | `${number} MB` | `${number} GB` | `${number} TB` | `${number} PB` | `${number} EB` | `${number} ZB` | `${number} YB` | undefined>;
+    readonly maxFileSize: _angular_core.WritableSignal<Nullable<`${number} B` | `${number} KB` | `${number} MB` | `${number} GB` | `${number} TB` | `${number} PB` | `${number} EB` | `${number} ZB` | `${number} YB`>>;
+    readonly maxFileSizeInBytes: _angular_core.Signal<number | null>;
+    readonly labelFn: _angular_core.InputSignal<_ngrdt_forms.RdtFileLabelFn>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected labelCtrl: FormControl<string | null>;
+    readonly labelDataTestId: _angular_core.Signal<string>;
+    protected readonly touchedEffect: _angular_core.EffectRef;
+    protected readonly errorEffect: _angular_core.EffectRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected onFileSelected(event: Event): void;
+    writeValue(value: any): void;
+    private setInnerValue;
+    protected clear(): void;
+    private _maxFileSizeValidator;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdtFileInputComponent<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdtFileInputComponent<any>, never, never, { "readerInput": { "alias": "reader"; "required": false; "isSignal": true; }; "acceptInput": { "alias": "accept"; "required": false; "isSignal": true; }; "maxFileSizeInput": { "alias": "maxFileSize"; "required": false; "isSignal": true; }; "labelFn": { "alias": "labelFn"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdtFileReaderArrayBuffer extends RdtFileReader<ArrayBuffer> {
+    extractData(file: File): rxjs.Observable<ArrayBuffer>;
+}
+
+declare class RdtFileReaderBase64 extends RdtFileReader<string> {
+    private removeDataPrefix;
+    constructor(removeDataPrefix?: boolean);
+    extractData(file: File): rxjs.Observable<string>;
+}
+
+declare class NoOpFileReader extends RdtFileReader<void> {
+    extractData(): rxjs.Observable<undefined>;
+}
+declare const NO_OP_FILE_READER: NoOpFileReader;
+
+declare class VnshFileReaderText extends RdtFileReader<string> {
+    encoding?: AllEncodingAliases | undefined;
+    constructor(encoding?: AllEncodingAliases | undefined);
+    extractData(file: File): rxjs.Observable<string>;
+}
+
+declare const RDT_DEFAULT_FILE_READER: InjectionToken<RdtFileReader<unknown>>;
+
+declare function czechFileLabelFn(files: RdtFile[]): string;
+type RdtFileLabelFn = (files: RdtFile[]) => string;
+declare const RDT_DEFAULT_FILE_LABEL_FN: InjectionToken<RdtFileLabelFn>;
+
+declare const RDT_DEFAULT_MAX_FILE_SIZE: InjectionToken<`${number} B` | `${number} KB` | `${number} MB` | `${number} GB` | `${number} TB` | `${number} PB` | `${number} EB` | `${number} ZB` | `${number} YB`>;
+
+type RdtAutocompleteGroup = 'shipping' | 'billing';
+type RdtAutocompleteRecipientType = 'home' | 'work' | 'mobile' | 'fax' | 'page';
+type RdtAutocompleteContactToken = 'tel' | 'tel-country-code' | 'tel-national' | 'tel-area-code' | 'tel-local' | 'tel-extension' | 'email' | 'impp';
+type RdtAutocompleteDigitalContactWhole = `${RdtAutocompleteRecipientType} ${RdtAutocompleteContactToken}`;
+type RdtAutocompleteNameToken = 'given-name' | 'additional-name' | 'family-name' | 'honorific-prefix' | 'honorific-suffix' | 'nickname';
+type RdtAutocompleteLoginToken = 'username' | 'new-password' | 'current-password' | 'one-time-code';
+type RdtAutocompleteAddressToken = 'organization-title' | 'organization' | 'street-address' | 'address-line1' | 'address-line2' | 'address-line3' | 'address-level1' | 'address-level2' | 'address-level3' | 'address-level4' | 'postal-code' | 'country' | 'region' | 'locality' | 'country-name' | 'postal-code';
+type RdtAutocompleteCCToken = 'cc-name' | 'cc-given-name' | 'cc-additional-name' | 'cc-family-name' | 'cc-number' | 'cc-exp' | 'cc-exp-month' | 'cc-exp-year' | 'cc-csc' | 'cc-type' | 'transaction-currency' | 'transaction-amount';
+type RdtAutocompleteOtherToken = 'language' | 'bday' | 'bday-day' | 'bday-month' | 'bday-year' | 'sex' | 'url' | 'photo' | 'webauthn';
+type RdtAutocompleteDetailToken = RdtAutocompleteDigitalContactWhole | RdtAutocompleteNameToken | RdtAutocompleteLoginToken | RdtAutocompleteAddressToken | RdtAutocompleteCCToken | RdtAutocompleteOtherToken;
+type RdtAutocompleteOptions = `${RdtAutocompleteGroup} ${RdtAutocompleteDetailToken}` | RdtAutocompleteDetailToken | 'off' | 'on';
+
+declare abstract class RdtNumericInputComponent extends RdtBaseFormInputComponent<number | null> {
+    readonly min: _angular_core.InputSignalWithTransform<number | null | undefined, Nullable<string | number>>;
+    readonly max: _angular_core.InputSignalWithTransform<number | null | undefined, Nullable<string | number>>;
+    readonly step: _angular_core.InputSignalWithTransform<number | null | undefined, Nullable<string | number>>;
+    readonly autocomplete: _angular_core.InputSignalWithTransform<RdtAutocompleteOptions | undefined, Nullable<RdtAutocompleteOptions>>;
+    protected isEmpty(value: number | null): boolean;
+    protected toExternalValue(internalValue: number | null): number | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdtNumericInputComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdtNumericInputComponent, never, never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface RdtLabelValue<T> {
+    label: string;
+    value: T;
+}
+interface RdtLabelValueId<T, TId> {
+    label: string;
+    value: T;
+    id: TId;
+}
+interface RdtRenderedSelectOption<T, TId> {
+    id: TId;
+    label: string;
+    value: T | null;
+    selected: boolean;
+}
+
+interface RdtSelectRequestParams {
+    query: string | null;
+    pageIndex: number;
+    pageSize: number;
+}
+interface RdtSelectFetchRequest {
+    params: RdtSelectRequestParams;
+    subscription: Subscription;
+}
+interface RdtSelectFetchMissingRequest<TId> {
+    ids: TId[];
+    subscription: Subscription;
+}
+
+interface RdtSelectPage<T> {
+    data: T[];
+    totalCount: number | null;
+    pageIndex: number;
+}
+
+declare abstract class RdtSelectDatasource<TItem, TId> {
+    abstract getData(params: RdtSelectRequestParams): Observable<RdtSelectPage<TItem>>;
+    abstract getLabel(item: TItem): string;
+    abstract getId(item: TItem): TId;
+    abstract getItemsByIds(ids: TId[]): Observable<Map<TId, TItem>>;
+    abstract readonly totalCountKnown: boolean;
+    abstract readonly queryRequired: boolean;
+}
+
+declare class RdtOfflineSelectDatasource<TValue extends string | number> extends RdtSelectDatasource<RdtLabelValue<TValue>, TValue> {
+    readonly data: RdtLabelValue<TValue>[];
+    readonly totalCountKnown = true;
+    readonly queryRequired = true;
+    protected readonly preprocessedData: RdtLabelValue<TValue>[];
+    constructor(data: RdtLabelValue<TValue>[]);
+    getData(params: RdtSelectRequestParams): Observable<RdtSelectPage<RdtLabelValue<TValue>>>;
+    getLabel(item: RdtLabelValue<TValue>): string;
+    getId(item: RdtLabelValue<TValue>): TValue;
+    getItemsByIds(ids: TValue[]): Observable<Map<TValue, RdtLabelValue<TValue>>>;
+    protected preprocessLabel(label: string): string;
+    protected preprocessData(data: RdtLabelValue<TValue>[]): RdtLabelValue<TValue>[];
+    protected filterData(query: string | null): RdtLabelValue<TValue>[];
+    protected getPage(data: RdtLabelValue<TValue>[], pageIndex: number, pageSize: number): RdtSelectPage<RdtLabelValue<TValue>>;
+}
+
+declare abstract class RdtSelectOfflineDatasourceProviderDirective<TValue extends string | number> {
+    readonly store: {
+        query: _angular_core.Signal<string | null>;
+        nextPageIndex: _angular_core.Signal<number | null>;
+        pageSize: _angular_core.Signal<number>;
+        totalCount: _angular_core.Signal<number>;
+        totalCountKnown: _angular_core.Signal<boolean>;
+        options: _angular_core.Signal<RdtLabelValueId<any, any>[]>;
+        datasource: _angular_core.Signal<_ngrdt_forms.RdtSelectDatasource<any, any> | null>;
+        selectedMap: _angular_core.Signal<Map<any, RdtLabelValueId<any, any>>>;
+        fetchError: _angular_core.Signal<any>;
+        missingValuePlaceholder: _angular_core.Signal<string>;
+        hasMore: _angular_core.Signal<boolean>;
+        selectedItems: _angular_core.Signal<RdtLabelValueId<any, any>[]>;
+        loadingOptions: _angular_core.Signal<boolean>;
+        loadingMissing: _angular_core.Signal<boolean>;
+        loading: _angular_core.Signal<boolean>;
+        visibleOptions: _angular_core.Signal<RdtRenderedSelectOption<any, any>[]>;
+        fetch: () => void;
+        setDatasource: (datasource: _ngrdt_forms.RdtSelectDatasource<any, any>) => void;
+        setQuery: (query: string | null) => void;
+        reset: () => void;
+        resetTotalCountKnown: () => void;
+        setSelected: (ids: any[]) => void;
+        select: (ids: any[]) => void;
+        unselectAll: () => void;
+        selectSingle: (id: any) => void;
+        toggle: (id: any) => void;
+        cancelFetch: () => void;
+        isSelected: (item: any) => boolean;
+        setPageSize: (size: number) => void;
+    } & _ngrx_signals.StateSource<{
+        query: string | null;
+        nextPageIndex: number | null;
+        pageSize: number;
+        totalCount: number;
+        totalCountKnown: boolean;
+        options: RdtLabelValueId<any, any>[];
+        datasource: _ngrdt_forms.RdtSelectDatasource<any, any> | null;
+        selectedMap: Map<any, RdtLabelValueId<any, any>>;
+        fetchError: any | null;
+        missingValuePlaceholder: string;
+    }>;
+    readonly optionsInput: _angular_core.InputSignal<RdtLabelValue<TValue>[] | TValue[] | undefined>;
+    readonly options: _angular_core.Signal<RdtLabelValue<TValue>[]>;
+    private parseOptions;
+    private readonly optionsEffect;
+    private setDatasource;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdtSelectOfflineDatasourceProviderDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdtSelectOfflineDatasourceProviderDirective<any>, never, never, { "optionsInput": { "alias": "options"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdtSelectOptionDirective<TValue> implements Highlightable {
+    private readonly elementRef;
+    readonly value: _angular_core.InputSignal<TValue>;
+    protected readonly _selected: _angular_core.WritableSignal<boolean>;
+    set selected(value: boolean);
+    get selected(): boolean;
+    protected readonly _disabled: _angular_core.WritableSignal<boolean>;
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    setActiveStyles(): void;
+    setInactiveStyles(): void;
+    scrollIntoElement(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdtSelectOptionDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdtSelectOptionDirective<any>, "[rdtSelectOption]", never, { "value": { "alias": "rdtSelectOption"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface RdtSelectState<TItem, TId> {
+    query: string | null;
+    nextPageIndex: number | null;
+    pageSize: number;
+    totalCount: number;
+    totalCountKnown: boolean;
+    options: RdtLabelValueId<TItem, TId>[];
+    datasource: RdtSelectDatasource<TItem, TId> | null;
+    selectedMap: Map<TId, RdtLabelValueId<TItem, TId>>;
+    fetchError: any | null;
+    missingValuePlaceholder: string;
+    _fetchRequest: RdtSelectFetchRequest | null;
+    _fetchMissingRequest: RdtSelectFetchMissingRequest<TId> | null;
+    _missingSelected: TId[];
+}
+declare const rdtSelectInitialState: RdtSelectState<any, any>;
+
+declare function getRdtSelectStore<T, TId>(initialState?: RdtSelectState<any, any>): _angular_core.Type<{
+    query: _angular_core.Signal<string | null>;
+    nextPageIndex: _angular_core.Signal<number | null>;
+    pageSize: _angular_core.Signal<number>;
+    totalCount: _angular_core.Signal<number>;
+    totalCountKnown: _angular_core.Signal<boolean>;
+    options: _angular_core.Signal<RdtLabelValueId<T, TId>[]>;
+    datasource: _angular_core.Signal<RdtSelectDatasource<T, TId> | null>;
+    selectedMap: _angular_core.Signal<Map<TId, RdtLabelValueId<T, TId>>>;
+    fetchError: _angular_core.Signal<any>;
+    missingValuePlaceholder: _angular_core.Signal<string>;
+    hasMore: _angular_core.Signal<boolean>;
+    selectedItems: _angular_core.Signal<RdtLabelValueId<T, TId>[]>;
+    loadingOptions: _angular_core.Signal<boolean>;
+    loadingMissing: _angular_core.Signal<boolean>;
+    loading: _angular_core.Signal<boolean>;
+    visibleOptions: _angular_core.Signal<RdtRenderedSelectOption<T, TId>[]>;
+    fetch: () => void;
+    setDatasource: (datasource: RdtSelectDatasource<T, TId>) => void;
+    setQuery: (query: string | null) => void;
+    reset: () => void;
+    resetTotalCountKnown: () => void;
+    setSelected: (ids: TId[]) => void;
+    select: (ids: TId[]) => void;
+    unselectAll: () => void;
+    selectSingle: (id: TId) => void;
+    toggle: (id: TId) => void;
+    cancelFetch: () => void;
+    isSelected: (item: T) => boolean;
+    setPageSize: (size: number) => void;
+} & _ngrx_signals.StateSource<{
+    query: string | null;
+    nextPageIndex: number | null;
+    pageSize: number;
+    totalCount: number;
+    totalCountKnown: boolean;
+    options: RdtLabelValueId<T, TId>[];
+    datasource: RdtSelectDatasource<T, TId> | null;
+    selectedMap: Map<TId, RdtLabelValueId<T, TId>>;
+    fetchError: any | null;
+    missingValuePlaceholder: string;
+}>>;
+declare const RdtSelectStore: _angular_core.Type<{
+    query: _angular_core.Signal<string | null>;
+    nextPageIndex: _angular_core.Signal<number | null>;
+    pageSize: _angular_core.Signal<number>;
+    totalCount: _angular_core.Signal<number>;
+    totalCountKnown: _angular_core.Signal<boolean>;
+    options: _angular_core.Signal<RdtLabelValueId<any, any>[]>;
+    datasource: _angular_core.Signal<RdtSelectDatasource<any, any> | null>;
+    selectedMap: _angular_core.Signal<Map<any, RdtLabelValueId<any, any>>>;
+    fetchError: _angular_core.Signal<any>;
+    missingValuePlaceholder: _angular_core.Signal<string>;
+    hasMore: _angular_core.Signal<boolean>;
+    selectedItems: _angular_core.Signal<RdtLabelValueId<any, any>[]>;
+    loadingOptions: _angular_core.Signal<boolean>;
+    loadingMissing: _angular_core.Signal<boolean>;
+    loading: _angular_core.Signal<boolean>;
+    visibleOptions: _angular_core.Signal<RdtRenderedSelectOption<any, any>[]>;
+    fetch: () => void;
+    setDatasource: (datasource: RdtSelectDatasource<any, any>) => void;
+    setQuery: (query: string | null) => void;
+    reset: () => void;
+    resetTotalCountKnown: () => void;
+    setSelected: (ids: any[]) => void;
+    select: (ids: any[]) => void;
+    unselectAll: () => void;
+    selectSingle: (id: any) => void;
+    toggle: (id: any) => void;
+    cancelFetch: () => void;
+    isSelected: (item: any) => boolean;
+    setPageSize: (size: number) => void;
+} & _ngrx_signals.StateSource<{
+    query: string | null;
+    nextPageIndex: number | null;
+    pageSize: number;
+    totalCount: number;
+    totalCountKnown: boolean;
+    options: RdtLabelValueId<any, any>[];
+    datasource: RdtSelectDatasource<any, any> | null;
+    selectedMap: Map<any, RdtLabelValueId<any, any>>;
+    fetchError: any | null;
+    missingValuePlaceholder: string;
+}>>;
+type RdtSelectStore<T = any, TId = number> = InstanceType<ReturnType<typeof getRdtSelectStore<T, TId>>>;
+
+declare abstract class RdtBaseSelectCommonComponent<TItem, TId, TOut> extends RdtBaseFormInputComponent<TOut> {
+    readonly datasourceInput: _angular_core.InputSignal<RdtSelectDatasource<TItem, TId> | null>;
+    readonly store: RdtSelectStore<TItem, TId>;
+    readonly visibleOptions: _angular_core.Signal<RdtRenderedSelectOption<TItem, TId>[]>;
+    readonly queryValidatorFnInput: _angular_core.InputSignal<Nullable<ValidatorFn | ValidatorFn[]>>;
+    readonly queryValidatorFn: _angular_core.WritableSignal<Nullable<ValidatorFn | ValidatorFn[]>>;
+    private readonly queryValidatorEffect;
+    readonly inputCtrl: FormControl<string | null>;
+    private readonly inputCtrlEvents;
+    readonly inputErrors: _angular_core.Signal<_angular_forms.ValidationErrors | null>;
+    readonly debounceTimeInput: _angular_core.InputSignal<number>;
+    readonly debounceTime: _angular_core.WritableSignal<number>;
+    private readonly debouncedInput$;
+    readonly debouncedInput: _angular_core.Signal<string | null>;
+    readonly pageSizeInput: _angular_core.InputSignal<number>;
+    private readonly pageSizeEffect;
+    readonly loading: _angular_core.Signal<boolean>;
+    ngOnInit(): void;
+    protected handleInput(value: string | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdtBaseSelectCommonComponent<any, any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdtBaseSelectCommonComponent<any, any, any>, never, never, { "datasourceInput": { "alias": "datasourceInput"; "required": false; "isSignal": true; }; "queryValidatorFnInput": { "alias": "inputValidator"; "required": false; "isSignal": true; }; "debounceTimeInput": { "alias": "debounce"; "required": false; "isSignal": true; }; "pageSizeInput": { "alias": "pageSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class RdtMultiSelectComponent<TItem, TId> extends RdtBaseSelectCommonComponent<TItem, TId, TId[]> {
+    readonly selected: _angular_core.Signal<RdtLabelValueId<TItem, TId>[] | null>;
+    protected isEmpty(value: TId[]): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdtMultiSelectComponent<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdtMultiSelectComponent<any, any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class RdtSingleSelectComponent<TItem, TId> extends RdtBaseSelectCommonComponent<TItem, TId, TId> {
+    readonly selected: _angular_core.Signal<RdtLabelValueId<TItem, TId> | null>;
+    protected isEmpty(value: TId): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdtSingleSelectComponent<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdtSingleSelectComponent<any, any>, never, never, {}, {}, never, never, true, never>;
+}
+
+type RdtInputType = 'text' | 'number' | 'email' | 'password';
+
+declare abstract class RdtTextInputComponent extends RdtBaseFormInputComponent<string, string> {
+    readonly type: _angular_core.InputSignal<RdtInputType>;
+    readonly autocomplete: _angular_core.InputSignalWithTransform<RdtAutocompleteOptions | undefined, Nullable<RdtAutocompleteOptions>>;
+    readonly maxlength: _angular_core.InputSignalWithTransform<Nullable<number>, Nullable<string | number>>;
+    readonly minlength: _angular_core.InputSignalWithTransform<Nullable<number>, Nullable<string | number>>;
+    readonly pattern: _angular_core.InputSignalWithTransform<Nullable<string>, Nullable<string>>;
+    protected isEmpty(value: string | null): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdtTextInputComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdtTextInputComponent, never, never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "minlength": { "alias": "minlength"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NO_OP_FILE_READER, NoOpFileReader, RDT_DEFAULT_FILE_LABEL_FN, RDT_DEFAULT_FILE_READER, RDT_DEFAULT_MAX_FILE_SIZE, RdtCheckboxComponent, RdtDateComponent, RdtFileInputComponent, RdtFileReader, RdtFileReaderArrayBuffer, RdtFileReaderBase64, RdtMultiSelectComponent, RdtNumericInputComponent, RdtOfflineSelectDatasource, RdtSelectDatasource, RdtSelectOfflineDatasourceProviderDirective, RdtSelectOptionDirective, RdtSelectStore, RdtSingleSelectComponent, RdtTextInputComponent, VnshFileReaderText, czechFileLabelFn, rdtSelectInitialState };
+export type { RdtDateType, RdtFileLabelFn, RdtSelectPage, RdtSelectState };

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@ngrdt/forms",
+  "version": "v0.0.18",
+  "peerDependencies": {
+    "@ngrdt/core": "v0.0.18",
+    "@ngrdt/utils": "v0.0.18",
+    "@angular/core": "^20.1.0",
+    "@angular/forms": "^20.1.0",
+    "rxjs": "^7.5.0",
+    "@ngrx/signals": "^20.0.0",
+    "@angular/cdk": "^20.2.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/ngrdt-forms.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/ngrdt-forms.mjs"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}