@sapphire-ion/framework 1.2.43 → 1.2.45

package/lib/components/inputs/input-color/input-color.component.d.ts

@@ -0,0 +1,77 @@
+import { ElementRef } from '@angular/core';
+import { CustomInput } from '../custom-input';
+import { GenericService } from '../../../services/generic.service';
+import { SIonPopoverComponent } from '../../popover/sion-popover/sion-popover.component';
+import { MaskitoOptions } from '@maskito/core';
+import * as i0 from "@angular/core";
+type RGB = {
+    r: number;
+    g: number;
+    b: number;
+};
+type HSL = {
+    h: number;
+    l: number;
+    s: number;
+};
+export declare class InputColorComponent extends CustomInput<string> {
+    private genericService;
+    input: ElementRef<HTMLInputElement>;
+    inputContainer: ElementRef<HTMLDivElement>;
+    setFocus(event: MouseEvent | null): void;
+    constructor(genericService: GenericService);
+    popover: SIonPopoverComponent;
+    rgbColor: RGB;
+    hslColor: HSL;
+    alpha: number;
+    writeValue(obj: string): void | Promise<void>;
+    SetValue(value: string): void;
+    rendering: boolean;
+    Present(event: MouseEvent): Promise<void>;
+    indicatorX: number;
+    indicatorY: number;
+    gradient: ElementRef<HTMLCanvasElement>;
+    private isGradientDragging;
+    private gradientCtx;
+    private gradientWidth;
+    private gradientHeight;
+    InitializeGradient(): void;
+    StartGradientDrag(e: MouseEvent): void;
+    GradientDrag(e: MouseEvent): void;
+    EndGradientDrag(): void;
+    HandleGradientTouch(e: TouchEvent): void;
+    HandleColorSelection(x: number, y: number): void;
+    UpdateSelectedColor(saturation?: number | null, lightness?: number | null, emitChanges?: boolean): void;
+    hueSlider: ElementRef<HTMLCanvasElement>;
+    private isHueDragging;
+    private hueCtx;
+    private hueSliderWidth;
+    private hueSliderHeight;
+    InitializeHueSlider(): void;
+    StartHueDrag(e: MouseEvent): void;
+    HueDrag(e: MouseEvent): void;
+    EndHueDrag(): void;
+    HandleHueTouch(e: TouchEvent): void;
+    HandleHueSelection(x: number): void;
+    alphaSlider: ElementRef<HTMLCanvasElement>;
+    private isAlphaDragging;
+    private alphaCtx;
+    private alphaSliderWidth;
+    private alphaSliderHeight;
+    InitializeAlphaSlider(): void;
+    StartAlphaDrag(e: MouseEvent): void;
+    AlphaDrag(e: MouseEvent): void;
+    EndAlphaDrag(): void;
+    HandleAlphaTouch(e: TouchEvent): void;
+    HandleAlphaSelection(x: number): void;
+    SetColorFromHex(hexColor: string, updateCanvas?: boolean, emitChanges?: boolean): void;
+    DrawColorGradient(): void;
+    DrawHueSlider(): void;
+    DrawAlphaSlider(): void;
+    CopyToClipboard(): Promise<void>;
+    UpdateIndicatorPositions(): void;
+    HEXMask: MaskitoOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputColorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputColorComponent, "input-color", never, {}, {}, never, never, false, never>;
+}
+export {};

package/{src/lib/components/inputs/input-configuration.ts → lib/components/inputs/input-configuration.d.ts}

@@ -1,23 +1,10 @@
-import { InputCurrencyConfiguration, InputDecimalConfiguration, InputNumberConfiguration } from "./input-decimal/input-decimal.configuration";
-import { InputCpfCnpjConfiguration } from "./input-cpf-cnpj/input-cpf-cnpj.configuration";
-import { InputSelectConfiguration } from "./input-select/input.select.configuration";
-import { InputStringConfiguration } from "./input-string/input-string.configuration";
-import { InputBoolConfiguration } from "./input-bool/input-bool.configuration";
-import { InputDateConfiguration } from "./input-date/input-date.configuration";
-import { InputFileConfiguration } from "./input-file/input-file.configuration";
-import { InputTelefoneCelularConfiguration } from "./input-telefone/input-telefone.configuration";
-import { InputCepConfiguration } from "./input-cep/input-cep.configuration";
-
-export type InputConfiguration = 
-  InputBoolConfiguration     |
-  InputCpfCnpjConfiguration  |
-  InputDateConfiguration     |
-  InputDecimalConfiguration  |
-  InputCurrencyConfiguration |
-  InputNumberConfiguration   |
-  InputFileConfiguration     |
-  InputSelectConfiguration   |
-  InputStringConfiguration   | 
-  InputTelefoneCelularConfiguration |
-  InputCepConfiguration |
-  any;
+import { InputCurrencyConfiguration, InputDecimalConfiguration, InputNumberConfiguration } from "./input-decimal/input-decimal.configuration";
+import { InputCpfCnpjConfiguration } from "./input-cpf-cnpj/input-cpf-cnpj.configuration";
+import { InputSelectConfiguration } from "./input-select/input.select.configuration";
+import { InputStringConfiguration } from "./input-string/input-string.configuration";
+import { InputBoolConfiguration } from "./input-bool/input-bool.configuration";
+import { InputDateConfiguration } from "./input-date/input-date.configuration";
+import { InputFileConfiguration } from "./input-file/input-file.configuration";
+import { InputTelefoneCelularConfiguration } from "./input-telefone/input-telefone.configuration";
+import { InputCepConfiguration } from "./input-cep/input-cep.configuration";
+export type InputConfiguration = InputBoolConfiguration | InputCpfCnpjConfiguration | InputDateConfiguration | InputDecimalConfiguration | InputCurrencyConfiguration | InputNumberConfiguration | InputFileConfiguration | InputSelectConfiguration | InputStringConfiguration | InputTelefoneCelularConfiguration | InputCepConfiguration | any;

package/lib/components/inputs/input-cpf-cnpj/input-cpf-cnpj.component.d.ts

@@ -0,0 +1,19 @@
+import { ElementRef, ModelSignal } from '@angular/core';
+import { MaskitoOptions } from '@maskito/core';
+import { CustomInput } from '../custom-input';
+import { InputCpfCnpjConfiguration } from './input-cpf-cnpj.configuration';
+import * as i0 from "@angular/core";
+export declare class InputCpfCnpjComponent extends CustomInput<string> {
+    protected elementRef: ElementRef<HTMLInputElement>;
+    configuration: ModelSignal<InputCpfCnpjConfiguration>;
+    input: ElementRef<HTMLInputElement>;
+    inputContainer: ElementRef<HTMLDivElement>;
+    setFocus(event: MouseEvent | null): void;
+    constructor(elementRef: ElementRef<HTMLInputElement>);
+    writeValue(obj: string): void | Promise<void>;
+    SetValue(obj: string): void;
+    readonly mask: MaskitoOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputCpfCnpjComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputCpfCnpjComponent, "input-cpf-cnpj, input-cpf, input-cnpj", never, { "configuration": { "alias": "configuration"; "required": false; "isSignal": true; }; }, { "configuration": "configurationChange"; }, never, never, false, never>;
+}
+export declare function FormatCpfCnpj(value: string): string;

package/lib/components/inputs/input-cpf-cnpj/input-cpf-cnpj.configuration.d.ts

@@ -0,0 +1,5 @@
+export type CPFCnpj = 'CPF' | 'CNPJ' | 'CPFCNPJ';
+export declare class InputCpfCnpjConfiguration {
+    type: CPFCnpj;
+    constructor(type?: CPFCnpj);
+}

package/lib/components/inputs/input-date/input-date.component.d.ts

@@ -0,0 +1,60 @@
+import { ElementRef, InputSignal, Signal, WritableSignal } from '@angular/core';
+import { MaskitoOptions } from '@maskito/core';
+import moment from 'moment';
+import { InputDateConfiguration } from './input-date.configuration';
+import { CustomInput } from '../custom-input';
+import { IonDatetime, IonModal } from '@ionic/angular';
+import { SIonPopoverComponent } from '../../popover/sion-popover/sion-popover.component';
+import { MatCalendar } from '@angular/material/datepicker';
+import * as i0 from "@angular/core";
+export declare class InputDateComponent extends CustomInput<string> {
+    elementRef: ElementRef;
+    static FormatISO: string;
+    configuration: InputSignal<InputDateConfiguration>;
+    input: ElementRef<HTMLInputElement>;
+    inputContainer: ElementRef<HTMLDivElement>;
+    setFocus(event: MouseEvent | null): void;
+    options: MaskitoOptions;
+    momentFormat: 'DD/MM/YYYY HH:mm' | 'DD/MM/YYYY' | 'HH:mm';
+    windowSize: WritableSignal<number>;
+    onResize(event: any): void;
+    interface: Signal<DateInterfaces>;
+    DateInterfaces: typeof DateInterfaces;
+    constructor(elementRef: ElementRef);
+    ClearValue(event?: MouseEvent): void;
+    presentation: DatePresentation;
+    readableValue: string;
+    SetValueFromReadable(value: string): void;
+    SetValueFromMoment(value: moment.Moment | null): void;
+    calendar: MatCalendar<moment.Moment>;
+    /**
+     * @param obj String in ISO format (YYYY-MM-DDThh:mm:ss)
+     */
+    SetValue(obj: string): void;
+    momentValue?: moment.Moment;
+    datetime: IonDatetime;
+    writeValue(obj?: string): void | Promise<void>;
+    popover: SIonPopoverComponent;
+    modal: IonModal;
+    Present(event: MouseEvent): Promise<void>;
+    Dismiss(): Promise<void>;
+    DatePresentation: typeof DatePresentation;
+    lstHours: string[];
+    lstMinutes: string[];
+    hour: string;
+    minute: string;
+    OnChangeHour(event: string): void;
+    OnChangeMinute(event: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputDateComponent, "input-date, input-date-time, input-time", never, { "configuration": { "alias": "configuration"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+declare enum DatePresentation {
+    DateTime = 1,
+    Date = 2,
+    Time = 3
+}
+declare enum DateInterfaces {
+    Popover = 1,
+    Modal = 2
+}
+export {};

package/lib/components/inputs/input-date/input-date.configuration.d.ts

@@ -0,0 +1,7 @@
+export declare class InputDateConfiguration {
+    /** Habilita o botão de limpar os dados  */
+    clearable: boolean;
+    constructor(
+    /** Habilita o botão de limpar os dados  */
+    clearable?: boolean);
+}

package/lib/components/inputs/input-decimal/input-decimal.component.d.ts

@@ -0,0 +1,26 @@
+import { ElementRef, ModelSignal, Signal } from '@angular/core';
+import { InputDecimalConfiguration } from './input-decimal.configuration';
+import { CustomInput } from '../custom-input';
+import * as i0 from "@angular/core";
+export declare class InputDecimalComponent extends CustomInput<number> {
+    elementRef: ElementRef;
+    configuration: ModelSignal<InputDecimalConfiguration>;
+    digitsInfo: Signal<string>;
+    divider: Signal<number>;
+    input: ElementRef<HTMLInputElement>;
+    inputContainer: ElementRef<HTMLDivElement>;
+    setFocus(event: MouseEvent | null): void;
+    constructor(elementRef: ElementRef);
+    writeValue(obj: number): void | Promise<void>;
+    SetValue(obj: number): void;
+    SetValueString(): void;
+    valueString: string;
+    onPaste(event: ClipboardEvent): void;
+    onKeyDown(event: KeyboardEvent): Promise<void>;
+    HandleNegative(event: KeyboardEvent, selectionStart: number, selectionEnd: number, value: string, atLeft: string, atRight: string): Promise<void>;
+    HandleNumber(event: KeyboardEvent, selectionStart: number, selectionEnd: number, value: string, atLeft: string, atRight: string): Promise<void>;
+    SanitizeValue(f: string): number;
+    HandleEspecial(event: KeyboardEvent, selectionStart: number, selectionEnd: number, value: string, atLeft: string, atRight: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDecimalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputDecimalComponent, "input-decimal, input-number, input-currency, input-percentage", never, { "configuration": { "alias": "configuration"; "required": false; "isSignal": true; }; }, { "configuration": "configurationChange"; }, never, never, false, never>;
+}

package/lib/components/inputs/input-decimal/input-decimal.configuration.d.ts

@@ -0,0 +1,28 @@
+export declare class InputDecimalConfiguration {
+    /** Declara a quantidade de numeros apos o ponto  */
+    precision: number;
+    /** Se = false não aplica virgulas no lugar do separador a cada 3 unidades */
+    thousandSeparator: string;
+    decimalSeparator: string;
+    prefix: string;
+    sufix: string;
+    placeholder: string;
+    constructor(
+    /** Declara a quantidade de numeros apos o ponto  */
+    precision?: number, 
+    /** Texto no inicio do input */
+    prefix?: string | null, 
+    /** Texto no fim do input */
+    sufix?: string | null, 
+    /** Se = false não aplica virgulas no lugar do separador a cada 3 unidades */
+    thousandSeparator?: string, decimalSeparator?: string);
+}
+export declare class InputNumberConfiguration extends InputDecimalConfiguration {
+    constructor(prefix?: string, sufix?: string, thousandSeparator?: string);
+}
+export declare class InputCurrencyConfiguration extends InputDecimalConfiguration {
+    constructor(prefix?: string, sufix?: string, thousandSeparator?: string);
+}
+export declare class InputPercentageConfiguration extends InputDecimalConfiguration {
+    constructor(prefix?: string, sufix?: string, thousandSeparator?: string);
+}

package/lib/components/inputs/input-default-configurations.d.ts

@@ -0,0 +1,13 @@
+import { InputDecimalConfiguration, InputNumberConfiguration } from "./input-decimal/input-decimal.configuration";
+export declare class InputsDefaultConfigurations {
+    static readonly configurationDecimalPercentage: InputDecimalConfiguration;
+    static readonly configurationDecimalDegree: InputDecimalConfiguration;
+    static readonly configurationDecimalM3H: InputDecimalConfiguration;
+    static readonly configurationDecimalMeters: InputDecimalConfiguration;
+    static readonly configurationDecimalMilimeters: InputDecimalConfiguration;
+    static readonly configurationNumberPercentage: InputNumberConfiguration;
+    static readonly configurationNumberDegree: InputNumberConfiguration;
+    static readonly configurationNumberM3H: InputNumberConfiguration;
+    static readonly configurationNumberMeters: InputNumberConfiguration;
+    static readonly configurationNumberMilimeters: InputNumberConfiguration;
+}

package/lib/components/inputs/input-file/download-button/download-button.component.d.ts

@@ -0,0 +1,39 @@
+import { ElementRef, ModelSignal, Signal } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { InputFileConfiguration } from '../input-file.configuration';
+import { ApiUrlProviderService } from '../../../../services/web/api-url-provider.service';
+import { StorageService } from '../../../../services/web/storage.service';
+import * as i0 from "@angular/core";
+export declare class DownloadButtonComponent implements ControlValueAccessor {
+    storageService: StorageService;
+    private elementRef;
+    private apiUrlProviderService;
+    expand: string;
+    value: ModelSignal<string>;
+    size: string;
+    color: string;
+    params: any;
+    disabled: boolean;
+    post: boolean;
+    configuration: InputFileConfiguration;
+    customLabel: boolean;
+    label: string;
+    constructor(storageService: StorageService, elementRef: ElementRef, apiUrlProviderService: ApiUrlProviderService);
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    guid: string;
+    apiUrl: string;
+    ngOnInit(): void;
+    lstFiles: Signal<string[]>;
+    writeValue(value: string): void;
+    Download(value: string): void;
+    Sanitize(v: any): string;
+    ExtensionIsImage(v: any): boolean;
+    lstLoading: string[];
+    SetLoading(path: string): void;
+    SetNotLoading(path: string): void;
+    isLoading(path: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DownloadButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DownloadButtonComponent, "download-button", never, { "expand": { "alias": "expand"; "required": false; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; "params": { "alias": "params"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "post": { "alias": "post"; "required": false; }; "configuration": { "alias": "configuration"; "required": false; }; "customLabel": { "alias": "customLabel"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, { "value": "valueChange"; }, never, never, false, never>;
+}

package/lib/components/inputs/input-file/input-file.component.d.ts

@@ -0,0 +1,27 @@
+import { ElementRef, InputSignal } from '@angular/core';
+import { CustomInput } from '../custom-input';
+import { InputFileConfiguration } from './input-file.configuration';
+import { UtilsService } from '../../../services/utils.service';
+import { StorageService } from '../../../services/web/storage.service';
+import * as i0 from "@angular/core";
+export declare class InputFileComponent extends CustomInput<File | string> {
+    private utilsService;
+    storageService: StorageService;
+    configuration: InputSignal<InputFileConfiguration>;
+    inputContainer: ElementRef<HTMLDivElement>;
+    setFocus(event: MouseEvent | null): void;
+    constructor(utilsService: UtilsService, storageService: StorageService);
+    valueString: string;
+    isString: boolean;
+    isImage: boolean;
+    objectURL: string | null;
+    writeValue(obj: File | string): void | Promise<void>;
+    SetValue(value: File | string): void;
+    SetValueString(): void;
+    Upload(): Promise<void>;
+    Clear(event: MouseEvent): void;
+    Download(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputFileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputFileComponent, "input-file", never, { "configuration": { "alias": "configuration"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+export declare const lstImage: string[];

package/lib/components/inputs/input-file/input-file.configuration.d.ts

@@ -0,0 +1,8 @@
+export declare class InputFileConfiguration {
+    /** Tipos de arquivos que podem ser selecionados */
+    types: any | [];
+    constructor(
+    /** Tipos de arquivos que podem ser selecionados */
+    types?: any | []);
+}
+export declare const lstImageTypes: string[];

package/lib/components/inputs/input-icon/fluenticons.d.ts

@@ -0,0 +1 @@
+export declare const lstFluenticons: string[];

package/lib/components/inputs/input-icon/input-icon.component.d.ts

@@ -0,0 +1,20 @@
+import { ElementRef } from '@angular/core';
+import { CustomInput } from '../custom-input';
+import { EnvironmentService } from '../../../services/environment.service';
+import { InputSelectConfiguration } from '../input-select/input.select.configuration';
+import * as i0 from "@angular/core";
+export declare class InputIconComponent extends CustomInput<string> {
+    private environmentService;
+    lstIcons: {
+        name: string;
+    }[];
+    input: ElementRef<HTMLInputElement>;
+    inputContainer: ElementRef<HTMLDivElement>;
+    setFocus(event: MouseEvent | null): void;
+    config: InputSelectConfiguration;
+    constructor(environmentService: EnvironmentService);
+    writeValue(obj: string): void | Promise<void>;
+    SetValue(obj: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputIconComponent, "input-icon", never, {}, {}, never, never, false, never>;
+}

package/lib/components/inputs/input-icon/ionicons.d.ts

@@ -0,0 +1 @@
+export declare const lstIconsIonicons: string[];

package/lib/components/inputs/input-provider-factory.d.ts

@@ -0,0 +1,4 @@
+import { Provider } from "@angular/core";
+export declare class InputProviderFactory {
+    static GetProviders(component: unknown): Provider[];
+}

package/lib/components/inputs/input-select/directives/sion-label-template.directive.d.ts

@@ -0,0 +1,18 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SIonLabelTemplateDirective<T> {
+    template: TemplateRef<LabelTemplateContext<T>>;
+    constructor(template: TemplateRef<LabelTemplateContext<T>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SIonLabelTemplateDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SIonLabelTemplateDirective<any>, "[sionLabelTemplate]", never, {}, {}, never, never, false, never>;
+}
+export interface LabelTemplateContext<T> {
+    /**
+     * O valor do item via bindLabel que está sendo renderizado.
+     */
+    $implicit: string;
+    /**
+     * O item selecionado no componente de input select.
+     */
+    item: T;
+}

package/lib/components/inputs/input-select/directives/sion-option-template.directive.d.ts

@@ -0,0 +1,14 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SIonOptionTemplateDirective<T> {
+    template: TemplateRef<OptionTemplateContext<T>>;
+    constructor(template: TemplateRef<OptionTemplateContext<T>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SIonOptionTemplateDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SIonOptionTemplateDirective<any>, "[sionOptionTemplate]", never, {}, {}, never, never, false, never>;
+}
+export interface OptionTemplateContext<T> {
+    /**
+     * O item naquela opção
+     */
+    item: T;
+}

package/lib/components/inputs/input-select/directives/sion-placeholder-template.directive.d.ts

@@ -0,0 +1,18 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SIonPlaceholderTemplateDirective {
+    template: TemplateRef<PlaceholderTemplateContext>;
+    constructor(template: TemplateRef<PlaceholderTemplateContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SIonPlaceholderTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SIonPlaceholderTemplateDirective, "[sionPlaceholderTemplate]", never, {}, {}, never, never, false, never>;
+}
+export interface PlaceholderTemplateContext {
+    /**
+     * Placeholder na configuração do componente de input select.
+     */
+    $implicit: string;
+    /**
+     * Placeholder na configuração do componente de input select.
+     */
+    placeholder: string;
+}

package/lib/components/inputs/input-select/input-select.component.d.ts

@@ -0,0 +1,83 @@
+import { AfterViewInit, ChangeDetectorRef, ElementRef, InputSignal, ModelSignal, Signal, TemplateRef, WritableSignal } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { ActionSheetButton, AlertButton, AlertInput, InfiniteScrollCustomEvent, IonActionSheet, IonAlert, IonContent, IonModal } from '@ionic/angular';
+import { InputSelectConfiguration, SelectInterfaces } from './input.select.configuration';
+import { SIonPopoverComponent } from '../../popover/sion-popover/sion-popover.component';
+import { CustomInput } from '../custom-input';
+import { PlaceholderTemplateContext } from './directives/sion-placeholder-template.directive';
+import { OptionTemplateContext } from './directives/sion-option-template.directive';
+import { LabelTemplateContext } from './directives/sion-label-template.directive';
+import * as i0 from "@angular/core";
+export declare class InputSelectComponent<T = any> extends CustomInput<T | T[]> implements AfterViewInit {
+    private cdr;
+    SelectInterfaces: typeof SelectInterfaces;
+    /** Items disponíveis no select */
+    items: ModelSignal<any[]>;
+    /** Configuração do select */
+    configuration: InputSignal<InputSelectConfiguration>;
+    loadingFromLoader: boolean;
+    currentLabel: string | undefined;
+    currentItems: any | ItemValue<any>[] | undefined;
+    SetCurrentItemLabel(): void;
+    lstOptionsItemValue: Signal<ItemValue<any>[]>;
+    windowSize: WritableSignal<number>;
+    onResize(event: any): void;
+    SetInterface(): void;
+    interface: WritableSignal<SelectInterfaces>;
+    lstOptions: ItemValue<any>[];
+    lstOptionsAlert: AlertInput[];
+    lstButtonsAlert: AlertButton[];
+    lstOptionsActionSheet: ActionSheetButton[];
+    infiniteScrollPage: WritableSignal<number>;
+    AddPage(event: InfiniteScrollCustomEvent): void;
+    UpdateLstOptions(search: string): void;
+    UpdateSelected(): void;
+    labelTemplate: TemplateRef<LabelTemplateContext<T>>;
+    optionTemplate: TemplateRef<OptionTemplateContext<T>>;
+    placeholderTemplate: TemplateRef<PlaceholderTemplateContext>;
+    inputContainer: ElementRef<HTMLDivElement>;
+    inputSelectLabel: ElementRef<HTMLDivElement>;
+    setFocus(event: MouseEvent | null): void;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnInit(): Promise<void>;
+    isServiceAtivo: Signal<boolean>;
+    somenteAtivos: WritableSignal<boolean>;
+    HandleKeyboardEvent(event: KeyboardEvent): void;
+    selectedIndex: number | undefined;
+    inputSearchBar: ElementRef<HTMLInputElement>;
+    searchBarControl: FormControl;
+    searchValue: WritableSignal<string>;
+    private searchBarSubscription;
+    private destroy$;
+    destroyed: boolean;
+    ngAfterViewInit(): void;
+    ClearSearchBar(): void;
+    ngOnDestroy(): void;
+    writeValue(obj: T | T[]): void | Promise<void>;
+    SetValue(obj: T | T[]): void;
+    Clear(event: MouseEvent): void;
+    Select(itemValue: ItemValue<T>): void;
+    selectContent: ElementRef<HTMLDivElement>;
+    popover: SIonPopoverComponent;
+    modal: IonModal;
+    alert: IonAlert;
+    actionSheet: IonActionSheet;
+    floatingVisible: boolean;
+    renderInterface: boolean;
+    ionContent: IonContent;
+    Present(event: Event): Promise<void>;
+    Dismiss(): Promise<void>;
+    OnDismiss(): void;
+    OnPresent(): void;
+    isArray(obj: any): obj is any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputSelectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputSelectComponent<any>, "input-select", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "configuration": { "alias": "configuration"; "required": false; "isSignal": true; }; }, { "items": "itemsChange"; }, ["labelTemplate", "optionTemplate", "placeholderTemplate"], never, false, never>;
+}
+declare class ItemValue<T> {
+    label: string;
+    value: T;
+    selected: boolean;
+    item: any;
+    disabled: boolean;
+}
+export {};

package/lib/components/inputs/input-select/input.select.configuration.d.ts

@@ -0,0 +1,122 @@
+import { Observable } from "rxjs";
+import { HttpService, ViewRetorno } from "../../../services/web/http.service";
+import { HttpServiceAtivo } from "../../../services/web/http.ativo.service";
+import { ViewFiltros } from "../../../classes/filters/view-filtros";
+import { Comparison } from "../../../classes/comparison/comparison";
+import { InputSelectComponent } from "./input-select.component";
+import { Placement } from "@floating-ui/dom";
+export type DefaultModelOptions = {
+    value: string;
+    label: string;
+};
+export declare enum SelectInterfaces {
+    /** Interface padrão do select
+     * Popover quando web, Modal quando mobile
+     */
+    Dynamic = 0,
+    Popover = 0,
+    Modal = 1,
+    ActionSheet = 2
+}
+export declare class InputSelectConfiguration {
+    /** Valor que será setado no formControl */
+    bindValue: string | ((obj: any) => any);
+    /** Valor que será exibido */
+    bindLabel: string | ((obj: any) => string);
+    /** Indica se o select pode ser nulo e limpavel */
+    clearable: boolean;
+    /** Indica se o select pode ser pesquisado */
+    searcheable: boolean;
+    /**
+     * Se LoadFrom instanceof HttpService      -> Os dados serão carregados do List()
+     * Se LoadFrom instanceof Observable       -> Os dados serão carregados da função indicada
+     * Se LoadFrom instanceof Array            -> Os dados serão o array
+     */
+    loadFrom?: HttpService | Observable<ViewRetorno> | any[];
+    /** Se = true Os valores no form control seráo um array dos items selecionados */
+    multiple: boolean;
+    /** Desativa os items que estão de acordo com a função */
+    disableConditional: ((obj: any) => boolean) | null;
+    static Create(options: {
+        bindLabel: string | ((obj: any) => string);
+        bindValue: string | ((obj: any) => any);
+        clearable?: boolean;
+        searcheable?: boolean;
+        loadFrom?: HttpService | Observable<ViewRetorno> | any[];
+        multiple?: boolean;
+        vFiltros?: Partial<{
+            search: string;
+            orderByProperty: string;
+            ascending: boolean;
+            filter: Comparison[];
+        }>;
+        disableConditional?: ((obj: any) => boolean);
+        useInfiniteScroll?: boolean | undefined;
+        placeholder?: string;
+        noItensFoundText?: string;
+        interface?: SelectInterfaces;
+    }): InputSelectConfiguration;
+    placeholder: string;
+    noItensFoundText: string;
+    loader: InputSelectDataLoader;
+    loadFromArray: any[];
+    loadFromService: HttpService | HttpServiceAtivo;
+    loadFromFunction: Observable<any>;
+    popoverConfiguration: {
+        flip: boolean;
+        placement: Placement;
+    };
+    vFiltros: ViewFiltros | null;
+    useInfiniteScroll?: boolean | undefined;
+    /** Interface do select */
+    interface: SelectInterfaces;
+    constructor(
+    /** Valor que será setado no formControl */
+    bindValue?: string | ((obj: any) => any), 
+    /** Valor que será exibido */
+    bindLabel?: string | ((obj: any) => string), 
+    /** Indica se o select pode ser nulo e limpavel */
+    clearable?: boolean, 
+    /** Indica se o select pode ser pesquisado */
+    searcheable?: boolean, 
+    /**
+     * Se LoadFrom instanceof HttpService      -> Os dados serão carregados do List()
+     * Se LoadFrom instanceof Observable       -> Os dados serão carregados da função indicada
+     * Se LoadFrom instanceof Array            -> Os dados serão o array
+     */
+    loadFrom?: HttpService | Observable<ViewRetorno> | any[], 
+    /** Se = true Os valores no form control seráo um array dos items selecionados */
+    multiple?: boolean, 
+    /** Aplica os filtros na pesquisa */
+    vFiltros?: Partial<{
+        /** Aplica uma pesquisa em texto  */
+        search: string;
+        /** Propriedade de ordenação */
+        orderByProperty: string;
+        /** Orientação de ordenação */
+        ascending: boolean;
+        /** Filtro  */
+        filter: Comparison[];
+    }> | null, 
+    /** Desativa os items que estão de acordo com a função */
+    disableConditional?: ((obj: any) => boolean) | null);
+}
+export declare class InputSelectDataLoader {
+    private lstComponents;
+    private configuration;
+    /** Valor que será setado no formControl */
+    bindValue: ((obj: any) => any) | null;
+    /** Valor que será exibido */
+    bindLabel: ((obj: any) => string) | null;
+    constructor(configuration: InputSelectConfiguration);
+    AddComponent(component: InputSelectComponent): void;
+    GetLabel(value: any): string;
+    isLoaded: boolean;
+    error: boolean;
+    Refresh(items?: any[]): Promise<void>;
+    CheckForInfiniteScroll(): void;
+    items: any[];
+    Load(): Promise<void>;
+}
+export declare function BindValueFactory(configuration: InputSelectConfiguration): ((obj: any) => any);
+export declare function BindLabelFactory(configuration: InputSelectConfiguration): ((obj: any) => string);