@sapphire-ion/framework 0.30.0

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

@@ -0,0 +1,80 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { IonPopover } from '@ionic/angular';
+import { CustomSignalInput } from '../custom-signal-input';
+import { GenericService } from '../../../services/generics.service';
+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 CustomSignalInput<string> implements OnInit {
+    private genericService;
+    constructor(genericService: GenericService);
+    canvas: ElementRef<HTMLCanvasElement>;
+    hueSlider: ElementRef<HTMLCanvasElement>;
+    alphaSlider: ElementRef<HTMLCanvasElement>;
+    writeValue(value: string): void;
+    get model(): string;
+    set model(value: string);
+    setModel(value: string, redraw?: boolean): void;
+    Popover: IonPopover;
+    rendering: boolean;
+    Present($event: any): Promise<void>;
+    private canvasCtx;
+    private canvasWidth;
+    private canvasHeight;
+    private hueCtx;
+    private hueSliderWidth;
+    private hueSliderHeight;
+    private alphaCtx;
+    private alphaSliderWidth;
+    private alphaSliderHeight;
+    private isDragging;
+    private isHueDragging;
+    private isAlphaDragging;
+    rgbColor: RGB;
+    hslColor: HSL;
+    alpha: number;
+    indicatorX: number;
+    indicatorY: number;
+    initCanvas(): void;
+    initHueSlider(): void;
+    initAlphaSlider(): void;
+    drawColorGradient(): void;
+    drawHueSlider(): void;
+    drawAlphaSlider(): void;
+    startDrag(e: MouseEvent): void;
+    drag(e: MouseEvent): void;
+    endDrag(): void;
+    handleTouch(e: TouchEvent): void;
+    startHueDrag(e: MouseEvent): void;
+    hueDrag(e: MouseEvent): void;
+    endHueDrag(): void;
+    startAlphaDrag(e: MouseEvent): void;
+    alphaDrag(e: MouseEvent): void;
+    endAlphaDrag(): void;
+    handleAlphaTouch(e: TouchEvent): void;
+    handleHueTouch(e: TouchEvent): void;
+    handleHueSelection(x: number): void;
+    handleAlphaSelection(x: number): void;
+    handleColorSelection(x: number, y: number): void;
+    updateSelectedColor(saturation?: number | null, lightness?: number | null, emitChanges?: boolean): void;
+    updateIndicatorPositions(): void;
+    hslToRgb(hsl: HSL): RGB;
+    setColorFromHex(hexColor: string, updateCanvas?: boolean, emitChanges?: boolean): void;
+    updateIndicatorPosition(): void;
+    rgbToHsl(rgb: RGB): HSL;
+    rgbToHex(rgb: RGB, a?: number): string;
+    getRgbaString(): string;
+    getHslaString(): string;
+    CopyToClipboard(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputColorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputColorComponent, "input-color", never, {}, {}, never, never, false, never>;
+}
+export {};

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

@@ -0,0 +1,8 @@
+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";
+export type InputConfiguration = InputFileConfiguration | InputSelectConfiguration | InputBoolConfiguration | InputDateConfiguration | InputDecimalConfiguration | InputNumberConfiguration | InputCurrencyConfiguration | InputCpfCnpjConfiguration | InputStringConfiguration | any;

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

@@ -0,0 +1,24 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { ControlContainer } from '@angular/forms';
+import { MaskitoOptions, MaskitoElementPredicate } from '@maskito/core';
+import { MaskitoMaskExpression } from '@maskito/core/src/lib/types';
+import { InputCpfCnpjConfiguration } from './input-cpf-cnpj.configuration';
+import { CustomInput } from '../custom-input';
+import * as i0 from "@angular/core";
+export declare class InputCpfCnpjComponent extends CustomInput<string> implements OnInit {
+    controlContainer: ControlContainer;
+    elementRef: ElementRef;
+    configuration: InputCpfCnpjConfiguration;
+    constructor(controlContainer: ControlContainer, elementRef: ElementRef);
+    ngOnInit(): Promise<void>;
+    writeValue(value: string): void;
+    get model(): string;
+    set model(value: string);
+    setModel(value: any): void;
+    readonly cpfMask: MaskitoMaskExpression;
+    readonly cnpjMask: MaskitoMaskExpression;
+    readonly mask: MaskitoOptions;
+    readonly maskPredicate: MaskitoElementPredicate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputCpfCnpjComponent, [{ optional: true; host: true; skipSelf: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputCpfCnpjComponent, "input-cpf-cnpj, input-cpf, input-cnpj", never, { "configuration": { "alias": "configuration"; "required": false; }; }, {}, never, never, false, never>;
+}

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

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

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

@@ -0,0 +1,30 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { ControlContainer } from '@angular/forms';
+import { IonModal } from '@ionic/angular';
+import { InputDateConfiguration } from './input-date.configuration';
+import { CustomInput } from '../custom-input';
+import * as i0 from "@angular/core";
+export declare class InputDateComponent extends CustomInput<string> implements OnInit {
+    controlContainer: ControlContainer;
+    elementRef: ElementRef;
+    configuration: InputDateConfiguration;
+    constructor(controlContainer: ControlContainer, elementRef: ElementRef);
+    presentation: "date-time" | "date" | "time" | string;
+    private transform;
+    HandleSelector(): void;
+    id_modal: string;
+    ngOnInit(): Promise<void>;
+    dateModel: string | null;
+    writeValue(value: string | null): void;
+    get model(): string;
+    set model(value: string);
+    setModel(value: string): void;
+    get _val(): string;
+    set _val(v: string);
+    get modal(): IonModal;
+    Open(): void;
+    Clear(): void;
+    DateTimeChange(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDateComponent, [{ optional: true; host: true; skipSelf: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputDateComponent, "input-date, input-date-time, input-time", never, { "configuration": { "alias": "configuration"; "required": false; }; }, {}, never, never, false, never>;
+}

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,41 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { ControlContainer } from '@angular/forms';
+import { InputCurrencyConfiguration, InputDecimalConfiguration, InputNumberConfiguration } from './input-decimal.configuration';
+import { CustomInput } from '../custom-input';
+import * as i0 from "@angular/core";
+export declare class InputDecimalComponent extends CustomInput<number> implements OnInit {
+    controlContainer: ControlContainer;
+    elementRef: ElementRef;
+    configuration: InputDecimalConfiguration | InputNumberConfiguration | InputCurrencyConfiguration;
+    constructor(controlContainer: ControlContainer, elementRef: ElementRef);
+    ngOnInit(): Promise<void>;
+    digitsInfo: string;
+    setDigitsInfo(): void;
+    HandleSelector(): void;
+    writeValue(value: number): void;
+    get model(): string;
+    set model(value: number);
+    onKeyDown(event: any): void;
+    onPaste(event: any): void;
+    key: string | null | undefined;
+    altKey: boolean;
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    startPosition: number;
+    endPosition: number;
+    value: string;
+    event: any;
+    eventType: number;
+    atLeft: string;
+    atRight: string;
+    HandleBrowser(): Promise<void> | Promise<boolean>;
+    divider: number;
+    setDivider(): void;
+    HandleNumber(): Promise<boolean>;
+    HandleNegative(): Promise<boolean>;
+    HandleEspecial(): Promise<boolean>;
+    HandleCopy(): Promise<void>;
+    SanitizeValue(f: string): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDecimalComponent, [{ optional: true; host: true; skipSelf: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputDecimalComponent, "input-decimal, input-number, input-currency, inout-percentage", never, { "configuration": { "alias": "configuration"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,25 @@
+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);
+}

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,36 @@
+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;
+    params: any;
+    disabled: boolean;
+    post: boolean;
+    configuration: InputFileConfiguration;
+    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; }; "params": { "alias": "params"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "post": { "alias": "post"; "required": false; }; "configuration": { "alias": "configuration"; "required": false; }; }, { "value": "valueChange"; }, never, never, false, never>;
+}

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

@@ -0,0 +1,39 @@
+import { ElementRef } from '@angular/core';
+import { ControlContainer } from '@angular/forms';
+import { InputFileConfiguration } from './input-file.configuration';
+import { ApiUrlProviderService } from '../../../services/web/api-url-provider.service';
+import { UtilsService } from '../../../services/utils.service';
+import { CustomInput } from '../custom-input';
+import { StorageService } from '../../../services/web/storage.service';
+import * as i0 from "@angular/core";
+export declare class InputFileComponent extends CustomInput<File[] | string> {
+    controlContainer: ControlContainer;
+    elementRef: ElementRef;
+    private utilsService;
+    private apiUrlProviderService;
+    storageService: StorageService;
+    configuration: InputFileConfiguration;
+    constructor(controlContainer: ControlContainer, elementRef: ElementRef, utilsService: UtilsService, apiUrlProviderService: ApiUrlProviderService, storageService: StorageService);
+    guid: string;
+    apiUrl: string;
+    ngOnInit(): Promise<void>;
+    writeValue(value: File[] | string): void;
+    get model(): File[] | string;
+    set model(value: File[] | string);
+    setModel(value: File[] | string): void;
+    lstFiles: any[];
+    Upload(): void;
+    Download(value: string): void;
+    PopoverImg(): boolean;
+    ExtensionIsImage(v: any): boolean;
+    get src(): string;
+    get isCloud(): boolean;
+    Sanitize(v: any): string;
+    lstLoading: string[];
+    SetLoading(path: string): void;
+    SetNotLoading(path: string): void;
+    isLoading(path: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputFileComponent, [{ optional: true; host: true; skipSelf: true; }, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputFileComponent, "input-file", never, { "configuration": { "alias": "configuration"; "required": false; }; }, {}, never, never, false, never>;
+}
+export declare const imageTypes: string[];

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

@@ -0,0 +1,11 @@
+export declare class InputFileConfiguration {
+    /** Tipos de arquivos que podem ser selecionados */
+    types: any | [];
+    /** Declara se mais do que um arquivo pode ser selecionado */
+    multiple: boolean;
+    constructor(
+    /** Tipos de arquivos que podem ser selecionados */
+    types?: any | [], 
+    /** Declara se mais do que um arquivo pode ser selecionado */
+    multiple?: boolean);
+}

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

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class InputLoadingComponent {
+    loading: boolean;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputLoadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputLoadingComponent, "input-loading", never, { "loading": { "alias": "loading"; "required": false; }; }, {}, never, never, false, never>;
+}

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

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

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

@@ -0,0 +1,21 @@
+import { ModelSignal } from "@angular/core";
+import { InputSelectConfiguration } from "./input.select.configuration";
+export declare abstract class ISelect {
+    items: ModelSignal<any[]>;
+    configuration: ModelSignal<InputSelectConfiguration>;
+    loadingFromLoader: boolean;
+    Clear: (() => void);
+    Select: ((item: any, UseDefaultModelOptions?: any) => void);
+    PresentPopover: (($event: MouseEvent) => Promise<void>);
+    UpdateUseDefaultModelOptions: (() => void);
+    Update: (() => void);
+}
+export declare abstract class ISelectOption {
+    hidden: boolean;
+    disabled: boolean;
+    label: ModelSignal<string>;
+    model: any;
+    GetNativeElement: (() => HTMLElement);
+    isSelected: boolean;
+    onFocus: boolean;
+}

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

@@ -0,0 +1,18 @@
+import { ElementRef, ModelSignal } from '@angular/core';
+import { ISelectOption, ISelect } from '../ISelect';
+import * as i0 from "@angular/core";
+export declare class InputSelectInternalOptionComponent implements ISelectOption {
+    protected parentComponent: ISelect;
+    private elementRef;
+    hidden: boolean;
+    disabled: boolean;
+    constructor(parentComponent: ISelect, elementRef: ElementRef<HTMLElement>);
+    GetNativeElement(): HTMLElement;
+    label: ModelSignal<string>;
+    model: any;
+    protected HandleClick(): void;
+    isSelected: boolean;
+    onFocus: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputSelectInternalOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputSelectInternalOptionComponent, "input-select-internal-option", never, { "hidden": { "alias": "hidden"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "model": { "alias": "model"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; }, { "label": "labelChange"; }, never, ["[slot=start]", "*", "[slot=end]"], false, never>;
+}

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

@@ -0,0 +1,24 @@
+import { ElementRef, ModelSignal } from '@angular/core';
+import { DefaultModelOptions } from '../input.select.configuration';
+import { ISelectOption, ISelect } from '../ISelect';
+import * as i0 from "@angular/core";
+export declare class InputSelectOptionComponent implements ISelectOption {
+    protected parentComponent: ISelect;
+    private elementRef;
+    /** Atributo indicando que o navegador não deve renderizar o conteúdo do elemento. */
+    hidden: boolean;
+    /** Se ativo desabilita o Input */
+    disabled: boolean;
+    /** Valor da opção em questão */
+    value: any;
+    constructor(parentComponent: ISelect, elementRef: ElementRef<HTMLElement>);
+    GetNativeElement(): HTMLElement;
+    /** Representa uma legenda para um item */
+    label: ModelSignal<string>;
+    model: import("@angular/core").Signal<DefaultModelOptions>;
+    protected HandleClick(): void;
+    isSelected: boolean;
+    onFocus: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputSelectOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputSelectOptionComponent, "input-select-option", never, { "hidden": { "alias": "hidden"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "label": "labelChange"; }, never, ["[slot=start]", "*", "[slot=end]"], false, never>;
+}

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

@@ -0,0 +1,8 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class InputSelectTemplateDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputSelectTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputSelectTemplateDirective, "[input-select-template]", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,66 @@
+import { ElementRef, ModelSignal, OnDestroy, OnInit, QueryList, Signal } from '@angular/core';
+import { IonInput, IonPopover, IonSearchbar } from '@ionic/angular';
+import { ControlContainer, ControlValueAccessor } from '@angular/forms';
+import { Observable, Subscription } from 'rxjs';
+import { InputSelectConfiguration } from './input.select.configuration';
+import { InputSelectInternalOptionComponent } from './input-select-internal-option/input-select-internal-option.component';
+import { InputSelectOptionComponent } from './input-select-option/input-select-option.component';
+import { ISelect } from './ISelect';
+import { CustomSignalInput } from '../custom-signal-input';
+import * as i0 from "@angular/core";
+export declare class InputSelectComponent extends CustomSignalInput<any> implements OnInit, OnDestroy, ControlValueAccessor, ISelect {
+    controlContainer: ControlContainer;
+    elementRef: ElementRef;
+    /** Items disponíveis no select */
+    items: ModelSignal<any[]>;
+    /** Configuração do select */
+    configuration: ModelSignal<InputSelectConfiguration>;
+    loadingFromLoader: boolean;
+    lstOptions: QueryList<InputSelectOptionComponent>;
+    lstInternalOptions: QueryList<InputSelectInternalOptionComponent>;
+    cdkVirtualScrollViewport: ElementRef<any>;
+    private useDefaultModelOptions;
+    protected bindValue: Signal<((args: any) => any)>;
+    protected bindLabel: Signal<((args: any) => string)>;
+    constructor(controlContainer: ControlContainer, elementRef: ElementRef);
+    ngOnDestroy(): void;
+    updateInterval: Observable<number> | null;
+    updateSubscription: Subscription;
+    lastItemsQtd: number | null;
+    ngOnInit(): void;
+    Clear(): void;
+    protected CurrentLabel: string;
+    protected CurrentlyNoValue: boolean;
+    Update(): void;
+    private UpdateCurrentLabel;
+    private UpdateSelected;
+    IsSelected(item: any): boolean;
+    /** Applies only on multiple */
+    protected GetSelectedItens(): any[];
+    _model: any;
+    get model(): any;
+    set model(value: any);
+    protected SetModel(value: any): void;
+    protected SearchChanged(): void;
+    protected GetUseDefaultModelOptions(): boolean;
+    UpdateUseDefaultModelOptions(): void;
+    writeValue(obj: any): void;
+    Select(item: any): void;
+    protected interfaceOptions: {
+        cssClass: string;
+    };
+    inputContainer: ElementRef<HTMLElement>;
+    ionPopoverComponent: IonPopover;
+    ionPopoverElement: ElementRef<HTMLElement>;
+    searchbarComponent: IonSearchbar;
+    PresentPopover($event: MouseEvent): Promise<void>;
+    protected Search: ModelSignal<string>;
+    protected lstSearchItens: Signal<any[]>;
+    inputComponent: IonInput;
+    itemComponent: ElementRef<HTMLElement>;
+    HandleKeyboardEvent(event: KeyboardEvent): Promise<void>;
+    SetFocusedElement(focusedModel: any, scroll?: boolean): void;
+    focusedModel: any | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputSelectComponent, [{ optional: true; host: true; skipSelf: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputSelectComponent, "input-select", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "configuration": { "alias": "configuration"; "required": false; "isSignal": true; }; "Search": { "alias": "Search"; "required": false; "isSignal": true; }; }, { "items": "itemsChange"; "configuration": "configurationChange"; "Search": "SearchChange"; }, ["lstOptions"], ["input-select-option"], false, never>;
+}

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

@@ -0,0 +1,87 @@
+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 { ISelect } from "./ISelect";
+import { Comparison } from "../../../classes/comparison/comparison";
+export type DefaultModelOptions = {
+    value: string;
+    label: string;
+};
+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 HttpServiceAtivo -> Os dados serão carregados do ListAtivo()
+     * 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 | HttpServiceAtivo | 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;
+    placeholder: string;
+    noItensFoundText: string;
+    loader: InputSelectDataLoader;
+    loadFromArray: any[];
+    loadFromService: HttpService | HttpServiceAtivo;
+    loadFromFunction: Observable<any>;
+    vFiltros: ViewFiltros | null;
+    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 HttpServiceAtivo -> Os dados serão carregados do ListAtivo()
+     * 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 | HttpServiceAtivo | 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 {
+    lstComponents: ISelect[];
+    configuration: InputSelectConfiguration;
+    /** Valor que será setado no formControl */
+    bindValue: ((obj: any) => any) | null;
+    /** Valor que será exibido */
+    bindLabel: ((obj: any) => string) | null;
+    constructor(configuration: InputSelectConfiguration);
+    GetLabel(value: any): string;
+    AddComponent(component: ISelect): void;
+    private _isLoaded;
+    Refresh(items?: any[]): Promise<void>;
+    private SetLstComponentsThisItens;
+    items: any[];
+    Load(): Promise<void>;
+}
+export declare function BindValueFactory(configuration: InputSelectConfiguration): ((obj: any) => any);
+export declare function BindLabelFactory(configuration: InputSelectConfiguration): ((obj: any) => string);

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

@@ -0,0 +1,19 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { ControlContainer } from '@angular/forms';
+import { InputStringConfiguration } from './input-string.configuration';
+import { CustomInput } from '../custom-input';
+import * as i0 from "@angular/core";
+export declare class InputStringComponent extends CustomInput<string> implements OnInit {
+    controlContainer: ControlContainer;
+    elementRef: ElementRef;
+    configuration: InputStringConfiguration;
+    type: 'text' | 'password';
+    constructor(controlContainer: ControlContainer, elementRef: ElementRef);
+    ngOnInit(): Promise<void>;
+    writeValue(value: string): void;
+    get model(): string;
+    set model(value: string);
+    setModel(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputStringComponent, [{ optional: true; host: true; skipSelf: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputStringComponent, "input-string", never, { "configuration": { "alias": "configuration"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,14 @@
+export declare enum InputStringType {
+    Text = "text",
+    Password = "password",
+    Email = "email",
+    Number = "number",
+    Search = "search",
+    Tel = "tel",
+    Url = "url"
+}
+export declare class InputStringConfiguration {
+    maxlength: number;
+    type: InputStringType;
+    constructor(type?: InputStringType, maxlength?: number);
+}

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

@@ -0,0 +1,18 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { ControlContainer } from '@angular/forms';
+import { InputStringConfiguration } from '../input-string/input-string.configuration';
+import { CustomInput } from '../custom-input';
+import * as i0 from "@angular/core";
+export declare class InputTextareaComponent extends CustomInput<string> implements OnInit {
+    controlContainer: ControlContainer;
+    elementRef: ElementRef;
+    configuration: InputStringConfiguration;
+    constructor(controlContainer: ControlContainer, elementRef: ElementRef);
+    ngOnInit(): Promise<void>;
+    writeValue(value: string): void;
+    get model(): string;
+    set model(value: string);
+    setModel(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputTextareaComponent, [{ optional: true; host: true; skipSelf: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputTextareaComponent, "input-textarea", never, { "configuration": { "alias": "configuration"; "required": false; }; }, {}, never, never, false, never>;
+}