@testgorilla/tgo-ui 2.31.1 → 2.31.3-beta.0

package/components/table/table.component.d.ts

@@ -0,0 +1,117 @@
+import { AfterViewInit, DestroyRef, ElementRef, EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { ColumnEllipse, ColumnType, ComponentRenderer, DataSource, ScrollSettings, TableColumn, TableConfigWithPagination, TableData, TableDetailColumn } from './table.model';
+import { PageEvent } from '@angular/material/paginator';
+import { ApplicationTheme } from '../../models/application-theme.model';
+import { MatTableDataSource } from '@angular/material/table';
+import { Sort } from '@angular/material/sort';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class TableComponent<T extends DataSource, TDetail extends DataSource> implements OnChanges, AfterViewInit {
+    private readonly defaultAppTheme;
+    private destroyRef;
+    protected readonly isMobile$: Observable<boolean>;
+    /**
+     * Table configuration
+     *
+     * @type {TableConfig}
+     * @memberof TableComponent
+     */
+    config: TableConfigWithPagination<T>;
+    /**
+     * Input property for providing the table data.
+     *
+     * @type {TableData}
+     * @memberof TableComponent
+     */
+    data: TableData;
+    /**
+     * Input property indicating whether the table is in a loading state.
+     *
+     * @type {boolean}
+     * @memberof TableComponent
+     * @default false
+     */
+    loading: boolean;
+    /**
+     *
+     * Defines the application theme
+     * @type {ApplicationTheme}
+     * @memberof TableComponent
+     */
+    applicationTheme: ApplicationTheme;
+    /**
+     * Data structure to select which columns should be rendered and their capabilities
+     *
+     * @type {TableDetailColumn}
+     * @memberof TableComponent
+     */
+    tableDetailColumns: TableDetailColumn<T, TDetail>;
+    tableDetails: boolean;
+    /**
+     * Disable border radius for table
+     *
+     * @type {boolean}
+     * @memberof TableComponent
+     */
+    disableBorderRadius: boolean;
+    /**
+     * Condensed table
+     *
+     * @type {boolean}
+     * @memberof TableComponent
+     */
+    isCondensed: boolean;
+    /**
+     * Sticky header
+     *
+     * @type {boolean}
+     * @memberof TableComponent
+     */
+    stickyHeader: boolean;
+    /**
+     * Max height
+     *
+     * @type {string}
+     * @memberof TableComponent
+     */
+    maxHeight: string;
+    onRowClickEvent: EventEmitter<any>;
+    onDetailRowClickEvent: EventEmitter<any>;
+    paginatorChange: EventEmitter<PageEvent>;
+    sortChange: EventEmitter<Sort>;
+    table: ElementRef;
+    protected tableData: TableData;
+    protected sourceData: TableData;
+    protected columnsTooltipState: ColumnEllipse[];
+    protected tableConfig: TableConfigWithPagination<T>;
+    protected displayedColumns: string[];
+    protected columnsDetailToDisplay: string[];
+    protected skeletonStyleConfig: {
+        background: string;
+        'border-radius': string;
+        height: string;
+    };
+    protected dataSourceDetail: MatTableDataSource<any, import("@angular/material/table").MatTableDataSourcePaginator>;
+    protected elementDetail: any;
+    protected readonly DataType: typeof ColumnType;
+    protected scrollSettings$: BehaviorSubject<ScrollSettings>;
+    constructor(defaultAppTheme: ApplicationTheme, destroyRef: DestroyRef, isMobile$: Observable<boolean>);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    hasTableScroll(): void;
+    callRenderer([rendererFn, element]: [(v: T) => ComponentRenderer | string, T]): any;
+    protected onPaginatorChange(event: PageEvent): void;
+    protected onChangeColumnSize(columnIndex: number, showTooltip: boolean): void;
+    protected onSortChange(sortState: Sort, emitEvent?: boolean): void;
+    protected onRowClick(rowParams: any): void;
+    protected onDetailRowClick(rowParams: any): void;
+    protected toggleRow(element: T): void;
+    private setTableDetailDataSource;
+    private setTableConfig;
+    private setTableData;
+    private defaultPaginationConfig;
+    trackColumnUniqueId: (index: number, column: TableColumn<T>) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any, any>, [{ optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any, any>, "ui-table", never, { "config": { "alias": "config"; "required": true; }; "data": { "alias": "data"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "applicationTheme": { "alias": "applicationTheme"; "required": false; }; "tableDetailColumns": { "alias": "tableDetailColumns"; "required": false; }; "tableDetails": { "alias": "tableDetails"; "required": false; }; "disableBorderRadius": { "alias": "disableBorderRadius"; "required": false; }; "isCondensed": { "alias": "isCondensed"; "required": false; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; }, { "onRowClickEvent": "onRowClickEvent"; "onDetailRowClickEvent": "onDetailRowClickEvent"; "paginatorChange": "paginatorChange"; "sortChange": "sortChange"; }, never, ["[title-actions]"], false, never>;
+}

package/components/table/table.component.module.d.ts

@@ -0,0 +1,20 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./table.component";
+import * as i2 from "./sentence-case.pipe";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/table";
+import * as i5 from "@angular/material/tooltip";
+import * as i6 from "../skeleton/skeleton.component";
+import * as i7 from "../paginator/paginator.component.module";
+import * as i8 from "../button/button.component.module";
+import * as i9 from "@angular/material/sort";
+import * as i10 from "../icon/icon.component.module";
+import * as i11 from "../../directives/ellipse-text.directive";
+import * as i12 from "../../directives/dynamic-component.directive";
+import * as i13 from "../../pipes/data-property-getter";
+import * as i14 from "../../pipes/memoize-func.pipe";
+export declare class TableComponentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TableComponentModule, [typeof i1.TableComponent, typeof i2.SentenceCasePipe], [typeof i3.CommonModule, typeof i4.MatTableModule, typeof i5.MatTooltipModule, typeof i6.SkeletonComponent, typeof i7.PaginatorComponentModule, typeof i8.ButtonComponentModule, typeof i9.MatSortModule, typeof i10.IconComponentModule, typeof i11.EllipseTextDirective, typeof i12.DynamicComponentDirective, typeof i13.DataPropertyGetterPipe, typeof i14.MemoizeFuncPipe], [typeof i1.TableComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TableComponentModule>;
+}

package/components/table/table.model.d.ts

@@ -0,0 +1,104 @@
+import { TemplateRef, Type } from '@angular/core';
+export interface TableConfig<T = any> {
+    columns: TableColumn<T>[];
+    pagination?: Pagination;
+    title?: string;
+    width?: number;
+    sort?: Sort;
+    hidePagination?: boolean;
+    noDataRowTpl?: TemplateRef<any>;
+    sortable?: boolean;
+}
+export interface TableConfigWithPagination<T> extends TableConfig<T> {
+    pagination?: Pagination;
+}
+export interface TableColumn<T = any> {
+    title?: string;
+    key: string;
+    allowMultiline?: boolean;
+    bold?: boolean;
+    showTooltip?: boolean;
+    tooltip?: string;
+    allowSort?: boolean;
+    isSticky?: boolean;
+    headerCellTemplate?: TemplateRef<any>;
+    rowCellTemplate?: TemplateRef<any>;
+    rowCellTemplateClick?: () => any;
+    sortHeader?: string;
+    hidden?: boolean;
+    order?: number;
+    fontSize?: '12px' | '14px';
+    field?: string;
+    type?: ColumnType;
+    function?: (v: T) => string;
+    renderer?: (v: T) => ComponentRenderer | string;
+    styles?: ColumnStyles;
+    sortStart?: SortDirection;
+    uniqueId?: string;
+}
+export interface Pagination {
+    itemsPerPageOptions: number[];
+    itemsPerPage: number;
+    currentPage: number;
+    totalItems: number;
+}
+export type TableData = Record<string, any>[];
+export interface ColumnEllipse {
+    index: number;
+    showTooltip: boolean;
+}
+export interface Sort {
+    active: string;
+    direction: SortDirection;
+    defaultSortStart?: SortDirection;
+}
+export type SortDirection = 'asc' | 'desc' | '';
+export interface TableDetailColumn<T, TDetail> {
+    columnDefs: TableColumn<TDetail>[];
+    setDetailRowData: (params: DetailRowDataParams<T, TDetail>) => void;
+}
+export interface DetailRowDataParams<T, TDetail> {
+    data: T;
+    setDetailDataSource(rowData: TDetail[]): void;
+}
+export declare enum ColumnType {
+    FIELD = "field",
+    FUNCTION = "function",
+    RENDERER = "renderer"
+}
+export interface ComponentRenderer {
+    component: Type<any>;
+    inputs?: any;
+    outputs?: {
+        [key: string]: any;
+    };
+}
+export interface ColumnStyles {
+    alignment?: ColumnAlignment;
+    width?: string;
+    'min-width'?: string;
+    padding?: string;
+}
+export declare enum ColumnAlignment {
+    LEFT = "left",
+    RIGHT = "right",
+    CENTER = "center"
+}
+export declare enum ColumnTypeEnum {
+    FIELD = "field",
+    FUNCTION = "function",
+    RENDERER = "renderer"
+}
+export declare enum ColumnAlignmentEnum {
+    LEFT = "left",
+    RIGHT = "right",
+    CENTER = "center"
+}
+export type DataSource = {
+    [key: string]: any;
+};
+export type ScrollSettings = {
+    scrollEnd: boolean;
+    horizontalScroll: boolean;
+    scrollStart: boolean;
+};

package/components/tabs/tab.directive.d.ts

@@ -0,0 +1,24 @@
+import { OnInit } from '@angular/core';
+import { IconName } from '../icon/icon.model';
+import { Tab } from './tabs.model';
+import * as i0 from "@angular/core";
+export declare class TabDirective implements OnInit {
+    tabLabel: import("@angular/core").InputSignal<string>;
+    tabName: import("@angular/core").InputSignal<string>;
+    iconLeft: import("@angular/core").InputSignal<IconName | undefined>;
+    iconRight: import("@angular/core").InputSignal<IconName | undefined>;
+    disabled: import("@angular/core").InputSignalWithTransform<boolean, string>;
+    canLeave: import("@angular/core").InputSignal<((ctx?: {
+        currentTab: Tab;
+        nextTab: Tab;
+    }) => boolean | Promise<boolean>) | undefined>;
+    linkUrl: import("@angular/core").InputSignal<string | undefined>;
+    private tabsComponent;
+    private template;
+    private syncProps;
+    private cleanup;
+    ngOnInit(): void;
+    private addTab;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TabDirective, "ng-template[uiTab]", never, { "tabLabel": { "alias": "tabLabel"; "required": true; "isSignal": true; }; "tabName": { "alias": "tabName"; "required": true; "isSignal": true; }; "iconLeft": { "alias": "iconLeft"; "required": false; "isSignal": true; }; "iconRight": { "alias": "iconRight"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "canLeave": { "alias": "canLeave"; "required": false; "isSignal": true; }; "linkUrl": { "alias": "linkUrl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/components/tabs/tabs.component.d.ts

@@ -0,0 +1,73 @@
+import { EventEmitter } from '@angular/core';
+import { Tab, TabsType } from './tabs.model';
+import { ApplicationTheme } from '../../models/application-theme.model';
+import { Observable } from 'rxjs';
+import { MatTabChangeEvent, MatTabGroup } from '@angular/material/tabs';
+import * as i0 from "@angular/core";
+export declare class TabsComponent {
+    private readonly defaultAppTheme;
+    protected readonly isMobile$: Observable<boolean>;
+    /**
+     * Color of the Tabs.
+     * Defaults to Test Gorilla primary color.
+     *
+     * @type {string}
+     * @memberof TabsComponent
+     */
+    companyColor: string | null;
+    /**
+     * Type the Tabs.
+     * Defaults underlined.
+     *
+     * @type {TabsType}
+     * @memberof TabsComponent
+     */
+    type: TabsType;
+    /**
+     * Animation duration when switching tabs
+     *
+     * @type {number}
+     * @memberof TabsComponent
+     */
+    animationDuration: number;
+    /**
+     * Sets the padding for content and header
+     *
+     * @type {number}
+     * @memberof TabsComponent
+     */
+    headerContentPadding: string;
+    /**
+     * Sets the dynamic height of the tab
+     * @type {boolean}
+     * @memberof TabsComponent
+     */
+    dynamicHeight: boolean;
+    /**
+     *
+     * Defines the application theme
+     *
+     * @type {ApplicationTheme}
+     * @memberof TabsComponent
+     */
+    applicationTheme: ApplicationTheme;
+    selectedTabIndex: EventEmitter<number>;
+    selectedTab: EventEmitter<Tab>;
+    tabGroup: MatTabGroup;
+    protected tabs: Tab[];
+    readonly tabIndex: import("@angular/core").WritableSignal<number>;
+    protected tabIndexMap: Record<string, number>;
+    constructor(defaultAppTheme: ApplicationTheme, isMobile$: Observable<boolean>);
+    ngAfterViewInit(): void;
+    addTab(tab: Tab): void;
+    onTabChange(ev: MatTabChangeEvent): void;
+    selectTab(tabName: string): void;
+    indexOf(tabName: string): number;
+    trackByTabName(index: number, tab: Tab): string;
+    removeTab(tabName: string): void;
+    updateTab(tabName: string, tab: Partial<Omit<Tab, 'tabName'>>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsComponent, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabsComponent, "ui-tabs", never, { "companyColor": { "alias": "companyColor"; "required": false; }; "type": { "alias": "type"; "required": false; }; "animationDuration": { "alias": "animationDuration"; "required": false; }; "headerContentPadding": { "alias": "headerContentPadding"; "required": false; }; "dynamicHeight": { "alias": "dynamicHeight"; "required": false; }; "applicationTheme": { "alias": "applicationTheme"; "required": false; }; }, { "selectedTabIndex": "selectedTabIndex"; "selectedTab": "selectedTab"; }, never, never, false, never>;
+    static ngAcceptInputType_headerContentPadding: number;
+    static ngAcceptInputType_dynamicHeight: unknown;
+}

package/components/tabs/tabs.component.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tabs.component";
+import * as i2 from "./tab.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/tabs";
+import * as i5 from "../icon/icon.component.module";
+import * as i6 from "../../pipes/ui-translate.pipe";
+export declare class TabsComponentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsComponentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TabsComponentModule, [typeof i1.TabsComponent], [typeof i2.TabDirective, typeof i3.CommonModule, typeof i4.MatTabsModule, typeof i5.IconComponentModule, typeof i6.UiTranslatePipe], [typeof i1.TabsComponent, typeof i2.TabDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TabsComponentModule>;
+}

package/components/tabs/tabs.model.d.ts

@@ -0,0 +1,16 @@
+import { IconName } from '../icon/icon.model';
+export interface Tab {
+    tabName: string;
+    tabLabel: string;
+    contentTemplateRef: any;
+    iconLeft?: IconName;
+    iconRight?: IconName;
+    disabled?: boolean;
+    canLeave?: (ctx?: {
+        currentTab: Tab;
+        nextTab: Tab;
+    }) => boolean | Promise<boolean>;
+    linkUrl?: string;
+    ariaLabel?: string;
+}
+export type TabsType = 'underlined' | 'filled';

package/components/tag/tag.component.d.ts

@@ -0,0 +1,131 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { IconColor, IconName } from '../icon/icon.model';
+import { ApplicationTheme } from '../../models/application-theme.model';
+import * as i0 from "@angular/core";
+export declare class TagComponent implements AfterViewInit, OnInit {
+    private readonly defaultAppTheme;
+    /**
+     * Tag's label
+     *
+     * @memberof TagComponent
+     */
+    set label(value: string);
+    /**
+     * Icon
+     *
+     * @type {string}
+     * @memberof TagComponent
+     */
+    icon: IconName;
+    /**
+     * Whether to allow the tag to be closed.
+     *
+     * @type {boolean}
+     * @default false
+     * @memberof TagComponent
+     */
+    allowClose: boolean;
+    /**
+     * Whether the tag is in read-only mode.
+     *
+     * @type {boolean}
+     * @default false
+     * @memberof TagComponent
+     */
+    readOnly: boolean;
+    /**
+     * Whether the tag is selected.
+     *
+     * @type {boolean}
+     * @default false
+     * @memberof TagComponent
+     */
+    isSelected: boolean;
+    /**
+     * Display icon when is selected
+     *
+     * @type {boolean}
+     * @default false
+     * @memberof TagComponent
+     */
+    showIconWhenSelected: boolean;
+    /**
+     * Specifies whether the element is disabled.
+     *
+     * @type {boolean}
+     * @default false
+     * @memberof TagComponent
+     */
+    isDisabled: boolean;
+    /**
+     *
+     * Defines the application theme
+     *
+     * @type {ApplicationTheme}
+     * @memberof TagComponent
+     */
+    applicationTheme: ApplicationTheme;
+    /**
+     * A string representing the ARIA label for accessibility.
+     * This label is used to provide an accessible name for the input element.
+     * @type {string}
+     * @memberof TagComponent
+     */
+    ariaLabel: string;
+    /**
+     * A string representing the ARIA requirement for accessibility.
+     * This attribute is used to indicate whether an input field is required for form submission.
+     * @type {boolean}
+     * @memberof TagComponent
+     */
+    ariaRequired: boolean;
+    /**
+     * Event triggered when the tag should be closed.
+     *
+     * @event
+     * @memberof TagComponent
+     */
+    close: EventEmitter<void>;
+    /**
+     * Event triggered when a press action occurs.
+     *
+     * @event
+     * @memberof TagComponent
+     */
+    press: EventEmitter<boolean>;
+    /**
+     * Subject that needs to be triggered when Label input changes, to check if it's truncated
+     * @private
+     * @type {void}
+     * @memberof TagComponent
+     */
+    private checkLabelEllipsis$;
+    /**
+     * Observable that indicates if the Label is truncated
+     * debounceTime is used to wait for view to be initialized after receiving a new Label input
+     * @protected
+     * @type {boolean}
+     * @memberof TagComponent
+     */
+    protected isEllipseActiveObs$: import("rxjs").Observable<boolean>;
+    protected labelText: string;
+    protected isHovered: boolean;
+    protected shrink: boolean;
+    protected iconToPass: IconName;
+    protected iconColor: IconColor;
+    protected closeBtnFocused: import("@angular/core").WritableSignal<boolean>;
+    labelElement: ElementRef<HTMLElement>;
+    constructor(defaultAppTheme: ApplicationTheme);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    onPress(): void;
+    setHoverState(state: boolean): void;
+    setShrinkState(state: boolean): void;
+    onClose(): void;
+    private isLabelEllipseActive;
+    get tabIndex(): number;
+    get filled(): boolean;
+    onKeydown($event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TagComponent, "ui-tag", never, { "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "allowClose": { "alias": "allowClose"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "showIconWhenSelected": { "alias": "showIconWhenSelected"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "applicationTheme": { "alias": "applicationTheme"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaRequired": { "alias": "ariaRequired"; "required": false; }; }, { "close": "close"; "press": "press"; }, never, never, false, never>;
+}

package/components/tag/tag.component.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tag.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../icon/icon.component.module";
+import * as i4 from "../tooltip/tooltip.component.module";
+import * as i5 from "@angular/material/tooltip";
+import * as i6 from "@angular/material/input";
+import * as i7 from "../../pipes/ui-translate.pipe";
+export declare class TagComponentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagComponentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TagComponentModule, [typeof i1.TagComponent], [typeof i2.CommonModule, typeof i3.IconComponentModule, typeof i4.TooltipComponentModule, typeof i5.MatTooltipModule, typeof i6.MatInputModule, typeof i7.UiTranslatePipe], [typeof i1.TagComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TagComponentModule>;
+}

package/components/toggle/toggle.component.d.ts

@@ -0,0 +1,113 @@
+import { EventEmitter, OnChanges, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { RegisterFn } from './toggle.model';
+import { ApplicationTheme } from '../../models/application-theme.model';
+import * as i0 from "@angular/core";
+export declare class ToggleComponent implements ControlValueAccessor, OnChanges, OnInit {
+    private readonly defaultAppTheme;
+    /**
+     * The `selected` property determines the current state of the toggle switch.
+     *
+     * @type {boolean}
+     * @default false
+     * @memberof ToggleComponent
+     */
+    selected: boolean;
+    /**
+     * The `disabled` property determines whether the toggle switch is disabled.
+     *
+     * @type {boolean}
+     * @default false
+     * @memberof ToggleComponent
+     */
+    disabled: boolean;
+    /**
+     * Toggle label
+     *
+     * @type {string}
+     * @default ''
+     * @memberof ToggleComponent
+     */
+    label: string;
+    /**
+     * Message
+     *
+     * @type {string}
+     * @default ''
+     * @memberof ToggleComponent
+     */
+    message: string;
+    /**
+     * Max width of the toggle container
+     *
+     * @type {number}
+     * @memberof ToggleComponent
+     */
+    maxWidth: number | undefined;
+    /**
+     *
+     * Defines the application theme
+     *
+     * @type {ApplicationTheme}
+     * @memberof ToggleComponent
+     */
+    applicationTheme: ApplicationTheme;
+    /**
+     * The `toggle` event is triggered when the state of the toggle switch changes. It returns the new state.
+     *
+     * @type {event}
+     * @memberof ToggleComponent
+     */
+    toggle: EventEmitter<boolean>;
+    /**
+     * A string representing the ARIA label for accessibility.
+     * This label is used to provide an accessible name for the input element.
+     * @type {string}
+     * @memberof ToggleComponent
+     */
+    ariaLabel: string;
+    /**
+     * A string representing the ARIA requirement for accessibility.
+     * This attribute is used to indicate whether an input field is required for form submission.
+     * @type {boolean}
+     * @memberof ToggleComponent
+     */
+    ariaRequired: boolean;
+    /**
+     * disable/enable click on toggle
+     * @type {boolean}
+     * @memberof ToggleComponent
+     */
+    preventClick: boolean;
+    /**
+     * The loading state
+     *
+     * @type {boolean}
+     * @memberof ToggleComponent
+     */
+    loading: boolean;
+    /**
+     * A string representing the ARIA requirement for accessibility.
+     * This attribute is used to indicate whether an input field is required for form submission.
+     * @type {string}
+     * @memberof ToggleComponent
+     */
+    ariaDescribedby: string;
+    protected showLabelTooltip: boolean;
+    protected classes: string;
+    constructor(defaultAppTheme: ApplicationTheme);
+    ngOnChanges(): void;
+    ngOnInit(): void;
+    onToggle(): void;
+    writeValue(state: boolean): void;
+    registerOnChange(fn: RegisterFn): void;
+    registerOnTouched(fn: RegisterFn): void;
+    setDisabledState(isDisabled: boolean): void;
+    changeTextState(state: boolean): void;
+    onKeydown($event: KeyboardEvent): void;
+    private onChange;
+    private onTouched;
+    private setClasses;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleComponent, "ui-toggle", never, { "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "label": { "alias": "label"; "required": false; }; "message": { "alias": "message"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "applicationTheme": { "alias": "applicationTheme"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaRequired": { "alias": "ariaRequired"; "required": false; }; "preventClick": { "alias": "preventClick"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "ariaDescribedby": { "alias": "ariaDescribedby"; "required": false; }; }, { "toggle": "toggle"; }, never, never, false, never>;
+}

package/components/toggle/toggle.component.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./toggle.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/tooltip";
+import * as i4 from "../../directives/ellipse-text.directive";
+import * as i5 from "@angular/material/input";
+import * as i6 from "../../pipes/ui-translate.pipe";
+import * as i7 from "../icon/icon.component.module";
+import * as i8 from "../spinner/spinner.module";
+export declare class ToggleComponentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleComponentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ToggleComponentModule, [typeof i1.ToggleComponent], [typeof i2.CommonModule, typeof i3.MatTooltipModule, typeof i4.EllipseTextDirective, typeof i5.MatInputModule, typeof i6.UiTranslatePipe, typeof i7.IconComponentModule, typeof i8.SpinnerComponentModule], [typeof i1.ToggleComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ToggleComponentModule>;
+}

package/components/tooltip/tooltip-template.directive.d.ts

@@ -0,0 +1,27 @@
+import { ElementRef, Injector, NgZone, OnChanges, OnDestroy, TemplateRef } from '@angular/core';
+import { Overlay, OverlayPositionBuilder } from "@angular/cdk/overlay";
+import { TooltipPositionType } from "./tooltip.model";
+import { FocusMonitor } from "@angular/cdk/a11y";
+import * as i0 from "@angular/core";
+export declare class TooltipTemplateDirective implements OnChanges, OnDestroy {
+    private _overlay;
+    private _overlayPositionBuilder;
+    private _elementRef;
+    private focusMonitor;
+    private ngZone;
+    private injector;
+    private tooltipComponentToken;
+    tooltipPosition: TooltipPositionType;
+    showTooltip: boolean;
+    templateRef: TemplateRef<any>;
+    private _overlayRef;
+    constructor(_overlay: Overlay, _overlayPositionBuilder: OverlayPositionBuilder, _elementRef: ElementRef, focusMonitor: FocusMonitor, ngZone: NgZone, injector: Injector, tooltipComponentToken: any);
+    ngOnChanges(): void;
+    show(): void;
+    hide(): void;
+    ngOnDestroy(): void;
+    private closeToolTip;
+    private setPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipTemplateDirective, "[uiTooltipTemplate]", never, { "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; "showTooltip": { "alias": "showTooltip"; "required": false; }; "templateRef": { "alias": "uiTooltipTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}