@ngstarter-ui/components 1.0.21

package/types/ngstarter-ui-components-expansion.d.ts

@@ -0,0 +1,68 @@
+import * as i0 from '@angular/core';
+import { AfterContentInit, OnDestroy, ChangeDetectorRef } from '@angular/core';
+
+declare class ExpansionPanel {
+    private _cdr;
+    readonly accordion: Accordion | null;
+    disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    expanded: i0.ModelSignal<boolean>;
+    hideToggle: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly opened: i0.OutputEmitterRef<void>;
+    readonly closed: i0.OutputEmitterRef<void>;
+    readonly expandedChange: i0.OutputEmitterRef<boolean>;
+    readonly id: string;
+    readonly headerId: string;
+    toggle(): void;
+    open(): void;
+    close(): void;
+    private _emitExpansionChange;
+    _getHideToggle(): boolean;
+    _getExpandedState(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpansionPanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExpansionPanel, "ngs-expansion-panel", ["ngsExpansionPanel"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "hideToggle": { "alias": "hideToggle"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; "opened": "opened"; "closed": "closed"; "expandedChange": "expandedChange"; }, never, ["ngs-expansion-panel-header", "*", "ngs-action-row"], true, never>;
+}
+
+declare class Accordion implements AfterContentInit, OnDestroy {
+    private readonly _destroyed;
+    readonly _cdr: ChangeDetectorRef;
+    /** Whether the accordion should allow multiple expanded panels at a time. */
+    multi: i0.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the expansion indicator should be hidden. */
+    hideToggle: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly _panels: i0.Signal<readonly ExpansionPanel[]>;
+    private readonly _panels$;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    openAll(): void;
+    closeAll(): void;
+    private _closeAllExcept;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Accordion, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Accordion, "ngs-accordion", ["ngsAccordion"], { "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "hideToggle": { "alias": "hideToggle"; "required": false; "isSignal": true; }; }, {}, ["_panels"], ["*"], true, never>;
+}
+
+declare class ExpansionPanelHeader {
+    readonly panel: ExpansionPanel;
+    private _cdr;
+    hideToggle: i0.InputSignalWithTransform<boolean, unknown>;
+    _toggle(): void;
+    _getExpandedState(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpansionPanelHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExpansionPanelHeader, "ngs-expansion-panel-header", never, { "hideToggle": { "alias": "hideToggle"; "required": false; "isSignal": true; }; }, {}, never, ["ngs-panel-title", "ngs-panel-description", "*"], true, never>;
+}
+
+declare class ExpansionPanelTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpansionPanelTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExpansionPanelTitle, "ngs-expansion-panel-title", ["ngsExpansionPanelTitle"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class ExpansionPanelDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpansionPanelDescription, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExpansionPanelDescription, "ngs-expansion-panel-description", ["ngsExpansionPanelDescription"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class ActionRow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionRow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionRow, "ngs-action-row", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { Accordion, ActionRow, ExpansionPanel, ExpansionPanelDescription, ExpansionPanelHeader, ExpansionPanelTitle };

package/types/ngstarter-ui-components-filter-builder.d.ts

@@ -0,0 +1,106 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, OnInit, AfterViewInit, ChangeDetectorRef } from '@angular/core';
+
+declare class FilterBuilderOperationNameDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterBuilderOperationNameDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FilterBuilderOperationNameDirective, "[ngsFilterBuilderOperationName]", never, {}, {}, never, never, true, never>;
+}
+
+declare class FilterBuilderOperationIconDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterBuilderOperationIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FilterBuilderOperationIconDirective, "[ngsFilterBuilderOperationIcon]", never, {}, {}, never, never, true, never>;
+}
+
+declare class FilterBuilderOperationDefDirective {
+    id: _angular_core.InputSignal<string>;
+    allowedDataTypes: _angular_core.InputSignal<string[]>;
+    readonly operationName: _angular_core.Signal<FilterBuilderOperationNameDirective | undefined>;
+    readonly operationIcon: _angular_core.Signal<FilterBuilderOperationIconDirective | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterBuilderOperationDefDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FilterBuilderOperationDefDirective, "[ngsFilterBuilderOperationDef]", never, { "id": { "alias": "ngsFilterBuilderOperationDef"; "required": false; "isSignal": true; }; "allowedDataTypes": { "alias": "allowedDataTypes"; "required": false; "isSignal": true; }; }, {}, ["operationName", "operationIcon"], never, true, never>;
+}
+
+interface FilterBuilderFieldDataSourceItem {
+    id: string;
+    name: string;
+}
+interface FilterBuilderFieldDef {
+    name: string;
+    dataType: string;
+    dataField: string;
+    format?: string;
+    filterOperations?: string[];
+    lookup?: {
+        dataSource: FilterBuilderFieldDataSourceItem[];
+    };
+}
+interface FilterBuilderCondition {
+    value: [string, string, any];
+}
+interface FilterBuilderGroup {
+    logicalOperator?: string;
+    value: FilterBuilderItemType[];
+}
+type FilterBuilderItemType = FilterBuilderCondition | FilterBuilderGroup;
+
+declare class FilterBuilder implements OnInit, AfterViewInit {
+    protected _cdr: ChangeDetectorRef;
+    protected _isServer: boolean;
+    protected _operationAllowedTypesMap: Map<string, string[]>;
+    private _resetMethodMap;
+    value: _angular_core.InputSignal<FilterBuilderGroup[]>;
+    fieldDefs: _angular_core.InputSignal<FilterBuilderFieldDef[]>;
+    categories: _angular_core.InputSignal<never[]>;
+    groupOperations: _angular_core.InputSignal<{
+        id: string;
+        name: string;
+    }[]>;
+    customOperations: _angular_core.InputSignal<never[]>;
+    protected _logicalOperator: string;
+    readonly _prebuiltOperationDefs: _angular_core.Signal<readonly FilterBuilderOperationDefDirective[]>;
+    readonly _customOperationDefs: _angular_core.Signal<readonly FilterBuilderOperationDefDirective[]>;
+    protected _operationDefs: FilterBuilderOperationDefDirective[];
+    readonly valueChanged: _angular_core.OutputEmitterRef<FilterBuilderGroup[]>;
+    protected _value: FilterBuilderGroup[];
+    protected _operations: any[];
+    protected editItem: FilterBuilderCondition | undefined;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    addCondition(targetGroup?: FilterBuilderGroup): void;
+    addGroup(targetGroup?: FilterBuilderGroup): void;
+    getConditionField(dataField: string): FilterBuilderFieldDef | undefined;
+    getConditionOperation(id: string): any;
+    getSelectedGroupOperationName(targetGroup?: FilterBuilderGroup): string;
+    selectConditionField(item: FilterBuilderCondition, field: FilterBuilderFieldDef): void;
+    operationChanged(item: FilterBuilderCondition, operation: string): void;
+    removeCondition(index: number, items: FilterBuilderItemType[]): void;
+    isOperationAllowedForCondition(dataField: string, operationId: string): boolean;
+    modifyValue(item: FilterBuilderCondition): void;
+    getFieldType(item: FilterBuilderCondition): string;
+    isValueNotEmpty(item: FilterBuilderCondition): boolean;
+    cancelEdit(delay?: number): void;
+    getOptions(item: FilterBuilderCondition): FilterBuilderFieldDataSourceItem[];
+    getDataSourceItemNameById(item: FilterBuilderCondition, dataSourceItemId: string): string;
+    selectBlur(event: FocusEvent): void;
+    selectClosed(): void;
+    protected operationIconTemplateRef(operation: FilterBuilderOperationDefDirective): TemplateRef<any>;
+    protected operationNameTemplateRef(operation: FilterBuilderOperationDefDirective): TemplateRef<any>;
+    protected _isGroup(item: FilterBuilderItemType): item is FilterBuilderGroup;
+    protected _isCondition(item: FilterBuilderItemType): item is FilterBuilderCondition;
+    protected _emitChangeEvent(): void;
+    private _getFieldDef;
+    private _resetValue;
+    private _resetStringValue;
+    private _resetNumberValue;
+    private _resetArrayValue;
+    private _resetBooleanValue;
+    private _capitalizeFirstLetter;
+    private _normalizeValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterBuilder, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FilterBuilder, "ngs-filter-builder", ["ngsFilterBuilder"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "fieldDefs": { "alias": "fieldDefs"; "required": false; "isSignal": true; }; "categories": { "alias": "categories"; "required": false; "isSignal": true; }; "groupOperations": { "alias": "groupOperations"; "required": false; "isSignal": true; }; "customOperations": { "alias": "customOperations"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; }, ["_customOperationDefs"], ["*"], true, never>;
+}
+
+export { FilterBuilder, FilterBuilderOperationDefDirective, FilterBuilderOperationIconDirective, FilterBuilderOperationNameDirective };
+export type { FilterBuilderCondition, FilterBuilderFieldDataSourceItem, FilterBuilderFieldDef, FilterBuilderGroup, FilterBuilderItemType };

package/types/ngstarter-ui-components-form-field.d.ts

@@ -0,0 +1,107 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, ElementRef } from '@angular/core';
+
+declare class Label {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Label, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Label, "ngs-label", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare abstract class FormFieldControl<T> {
+    abstract value: T | null;
+    abstract readonly stateChanges: any;
+    abstract readonly id: string;
+    abstract readonly placeholder: string | undefined;
+    abstract readonly ngControl: any;
+    abstract readonly focused: boolean;
+    abstract readonly empty: boolean;
+    abstract readonly shouldLabelFloat: boolean;
+    abstract readonly required: boolean;
+    abstract readonly disabled: boolean;
+    abstract readonly errorState: boolean;
+    abstract focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldControl<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormFieldControl<any>>;
+}
+
+declare class Hint {
+    align: i0.InputSignal<"start" | "end">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Hint, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Hint, "ngs-hint", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class Error {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Error, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Error, "ngs-error", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class Prefix {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Prefix, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Prefix, "[ngsPrefix]", never, {}, {}, never, never, true, never>;
+}
+declare class TextPrefix {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextPrefix, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextPrefix, "[ngsTextPrefix]", never, {}, {}, never, never, true, never>;
+}
+declare class IconPrefix {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconPrefix, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IconPrefix, "[ngsIconPrefix]", never, {}, {}, never, never, true, never>;
+}
+declare class IconButtonPrefix {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconButtonPrefix, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IconButtonPrefix, "[ngsIconButtonPrefix]", never, {}, {}, never, never, true, never>;
+}
+declare class Suffix {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Suffix, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Suffix, "[ngsSuffix]", never, {}, {}, never, never, true, never>;
+}
+declare class TextSuffix {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextSuffix, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextSuffix, "[ngsTextSuffix]", never, {}, {}, never, never, true, never>;
+}
+declare class IconSuffix {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconSuffix, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IconSuffix, "[ngsIconSuffix]", never, {}, {}, never, never, true, never>;
+}
+declare class IconButtonSuffix {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconButtonSuffix, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IconButtonSuffix, "[ngsIconButtonSuffix]", never, {}, {}, never, never, true, never>;
+}
+
+declare const FORM_FIELD: InjectionToken<any>;
+
+declare class FormField {
+    subscriptHiddenIfEmpty: i0.InputSignalWithTransform<boolean, unknown>;
+    elementRef: ElementRef<any>;
+    wrapper: i0.Signal<ElementRef<any>>;
+    container: i0.Signal<ElementRef<any>>;
+    control: i0.Signal<FormFieldControl<any> | undefined>;
+    labelChild: i0.Signal<Label | undefined>;
+    prefixChildren: i0.Signal<readonly Prefix[]>;
+    iconPrefixChildren: i0.Signal<readonly IconPrefix[]>;
+    iconButtonPrefixChildren: i0.Signal<readonly IconButtonPrefix[]>;
+    textPrefixChildren: i0.Signal<readonly TextPrefix[]>;
+    suffixChildren: i0.Signal<readonly Suffix[]>;
+    iconSuffixChildren: i0.Signal<readonly IconSuffix[]>;
+    iconButtonSuffixChildren: i0.Signal<readonly IconButtonSuffix[]>;
+    textSuffixChildren: i0.Signal<readonly TextSuffix[]>;
+    hintChildren: i0.Signal<readonly Hint[]>;
+    errorChildren: i0.Signal<readonly Error[]>;
+    isRequired: i0.Signal<boolean>;
+    shouldLabelFloat(): boolean;
+    protected _onClick(event: MouseEvent): void;
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormField, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormField, "ngs-form-field", ["ngsFormField"], { "subscriptHiddenIfEmpty": { "alias": "subscriptHiddenIfEmpty"; "required": false; "isSignal": true; }; }, {}, ["control", "labelChild", "prefixChildren", "iconPrefixChildren", "iconButtonPrefixChildren", "textPrefixChildren", "suffixChildren", "iconSuffixChildren", "iconButtonSuffixChildren", "textSuffixChildren", "hintChildren", "errorChildren"], ["[ngsPrefix]", "[ngsIconPrefix]", "[ngsIconButtonPrefix]", "[ngsTextPrefix]", "ngs-label", "*", "[ngsTextSuffix]", "[ngsIconButtonSuffix]", "[ngsIconSuffix]", "[ngsSuffix]", "ngs-error", "ngs-hint"], true, never>;
+}
+
+interface FormFieldDefaultOptions {
+    appearance?: 'fill' | 'outline';
+    color?: string;
+    hideRequiredMarker?: boolean;
+    floatLabel?: 'always' | 'auto';
+    subscriptHiddenIfEmpty?: boolean;
+}
+declare const FORM_FIELD_DEFAULT_OPTIONS: InjectionToken<FormFieldDefaultOptions>;
+
+export { Error, FORM_FIELD, FORM_FIELD_DEFAULT_OPTIONS, FormField, FormFieldControl, Hint, IconButtonPrefix, IconButtonSuffix, IconPrefix, IconSuffix, Label, Prefix, Suffix, TextPrefix, TextSuffix };
+export type { FormFieldDefaultOptions };

package/types/ngstarter-ui-components-form-renderer.d.ts

@@ -0,0 +1,121 @@
+import * as i0 from '@angular/core';
+import { Type, InjectionToken, OnInit, OnDestroy, Signal } from '@angular/core';
+import { FormGroup, ValidationErrors, ValidatorFn, FormBuilder, FormControl } from '@angular/forms';
+
+type ComponentImporter = () => Promise<Type<any>>;
+declare class ComponentRegistryService {
+    private globalRegistry;
+    private componentMap;
+    constructor();
+    private registerDefaultComponents;
+    getImporter(typeName: string): ComponentImporter | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentRegistryService>;
+}
+
+declare const FORM_RENDERER_FIELD_REGISTRY: InjectionToken<{
+    [fieldName: string]: ComponentImporter;
+}>;
+interface ValidatorConfig {
+    type: string;
+    value?: any;
+    message: string;
+}
+interface BaseComponentConfig {
+    name: string;
+    type: string;
+}
+interface FormFieldConfig extends BaseComponentConfig {
+    kind: 'field';
+    value?: any;
+    validators?: ValidatorConfig[];
+    label?: string;
+    placeholder?: string;
+    inputType?: 'text' | 'number' | 'email' | 'password';
+    readonly?: boolean;
+    disabled?: boolean;
+    inline?: boolean;
+    visibleWhen?: (formGroup: FormGroup) => boolean;
+    payload?: {
+        [key: string]: any;
+    };
+    hint?: string;
+}
+interface ContentConfig extends BaseComponentConfig {
+    kind: 'content';
+    content?: {
+        [key: string]: any;
+    };
+}
+type ComponentConfig = FormFieldConfig | ContentConfig | any;
+interface ComponentNode {
+    name: string;
+    colspan?: number;
+}
+interface GridNode {
+    columns: number;
+    gap?: string;
+    children: LayoutNode[];
+}
+type LayoutNode = ComponentNode | GridNode;
+type CrossValidatorFn = (formGroup: FormGroup) => ValidationErrors | null;
+interface FormConfig {
+    elements: ComponentConfig[];
+    layout: LayoutNode;
+    crossValidators?: CrossValidatorFn[];
+}
+
+type ValidatorFactory = (config: ValidatorConfig) => ValidatorFn;
+declare class ValidatorRegistryService {
+    private validatorMap;
+    constructor();
+    private registerDefaultValidators;
+    registerValidator(name: string, factory: ValidatorFactory): void;
+    getValidator(config: ValidatorConfig): ValidatorFn;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidatorRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidatorRegistryService>;
+}
+
+declare class FormGeneratorService {
+    private fb;
+    private validatorRegistry;
+    constructor(fb: FormBuilder, validatorRegistry: ValidatorRegistryService);
+    createFormGroup(config: FormConfig, initialValue?: Record<string, any>): FormGroup;
+    private mapValidators;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormGeneratorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormGeneratorService>;
+}
+
+declare class FormRenderer implements OnInit, OnDestroy {
+    #private;
+    private formGenerator;
+    private validatorRegistry;
+    private destroyRef;
+    readonly config: i0.InputSignal<FormConfig>;
+    readonly initialValue: i0.InputSignal<Record<string, any> | undefined>;
+    readonly formSubmit: i0.OutputEmitterRef<any>;
+    readonly valueChanges: i0.OutputEmitterRef<any>;
+    readonly initialized: i0.OutputEmitterRef<void>;
+    private elementsMap;
+    protected formGroup: Signal<FormGroup>;
+    private valueChangesSub?;
+    constructor(formGenerator: FormGeneratorService, validatorRegistry: ValidatorRegistryService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    submit(): void;
+    get form(): FormGroup<any>;
+    get value(): any;
+    get isValid(): boolean;
+    get isInvalid(): boolean;
+    protected isFieldVisible(name: string): boolean;
+    protected getComponentConfig(name: string): ComponentConfig | undefined;
+    protected getControl(name: string): FormControl | null;
+    protected isGridNode(node: LayoutNode): node is GridNode;
+    protected onSubmit(): void;
+    private mapValidators;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormRenderer, "ngs-form-renderer", ["ngsFormRenderer"], { "config": { "alias": "config"; "required": true; "isSignal": true; }; "initialValue": { "alias": "initialValue"; "required": false; "isSignal": true; }; }, { "formSubmit": "formSubmit"; "valueChanges": "valueChanges"; "initialized": "initialized"; }, never, ["*"], true, never>;
+}
+
+export { ComponentRegistryService, FORM_RENDERER_FIELD_REGISTRY, FormRenderer, ValidatorRegistryService };
+export type { ComponentConfig, ComponentImporter, ComponentNode, ContentConfig, CrossValidatorFn, FormConfig, FormFieldConfig, GridNode, LayoutNode, ValidatorConfig };

package/types/ngstarter-ui-components-gauge.d.ts

@@ -0,0 +1,21 @@
+import * as i0 from '@angular/core';
+import { OnInit } from '@angular/core';
+
+declare class Gauge implements OnInit {
+    value: i0.InputSignalWithTransform<number, unknown>;
+    strokeWidth: i0.InputSignalWithTransform<number, unknown>;
+    radius: i0.InputSignalWithTransform<number, unknown>;
+    protected strokeDasharray: string;
+    protected initialOffset: number;
+    protected strokeDashoffset: number;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Gauge, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Gauge, "ngs-gauge", ["ngsGauge"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; }, {}, never, ["ngs-gauge-value"], true, never>;
+}
+
+declare class GaugeValue {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GaugeValue, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GaugeValue, "ngs-gauge-value", ["ngsGaugeValue"], {}, {}, never, ["*"], true, never>;
+}
+
+export { Gauge, GaugeValue };

package/types/ngstarter-ui-components-grid.d.ts

@@ -0,0 +1,45 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, InputSignal, OnInit } from '@angular/core';
+
+interface GridItemAware {
+    id: InputSignal<any>;
+    content?: InputSignal<any>;
+}
+interface GridItemConfig {
+    type: string;
+    skeleton?: any;
+    plain?: boolean;
+    component: () => Promise<any>;
+}
+interface GridItem {
+    id: any;
+    type?: string;
+    columns: number;
+    children?: GridItem[];
+    skeletonHeight?: string;
+    height?: string;
+    content?: any;
+}
+declare const GRID: InjectionToken<unknown>;
+
+declare class Grid implements OnInit {
+    protected _skeletonMap: Map<string, any>;
+    protected _componentsMap: Map<string, any>;
+    readonly configs: _angular_core.InputSignal<GridItemConfig[]>;
+    readonly items: _angular_core.InputSignal<GridItem[]>;
+    readonly plain: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly waitWhenAllItemsLoaded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected _allLoaded: _angular_core.WritableSignal<boolean>;
+    protected _loadedItemsCount: _angular_core.WritableSignal<number>;
+    ngOnInit(): void;
+    markItemAsLoaded(id: any): void;
+    protected getItemConfig(type: string): GridItemConfig;
+    protected getSkeletonComponent(type: string): any;
+    protected getItemComponent(type: string): any;
+    protected getItemInputs(gridItem: GridItem): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Grid, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Grid, "ngs-grid", ["ngsGrid"], { "configs": { "alias": "configs"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "plain": { "alias": "plain"; "required": false; "isSignal": true; }; "waitWhenAllItemsLoaded": { "alias": "waitWhenAllItemsLoaded"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { GRID, Grid };
+export type { GridItem, GridItemAware, GridItemConfig };