@shival99/z-ui 2.6.8 → 2.6.9

package/types/shival99-z-ui-components-z-drawer.d.ts

@@ -0,0 +1,298 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Type, WritableSignal, EventEmitter, ViewContainerRef, OnDestroy, AfterViewChecked, Injector, ComponentRef, EmbeddedViewRef, InjectionToken } from '@angular/core';
+import { ClassValue } from 'clsx';
+import { NgScrollbar } from 'ngx-scrollbar';
+import { ZIcon } from '@shival99/z-ui/components/z-icon';
+import { Observable } from 'rxjs';
+import { ZOverlayRef } from '@shival99/z-ui/components/z-overlay';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+
+declare class ZDrawerContentDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZDrawerContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZDrawerContentDirective, "[z-drawer-content], [zDrawerContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ZDrawerFooterDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZDrawerFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZDrawerFooterDirective, "[z-drawer-footer], [zDrawerFooter]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ZDrawerHeaderDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZDrawerHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZDrawerHeaderDirective, "[z-drawer-header], [zDrawerHeader]", never, {}, {}, never, never, true, never>;
+}
+
+type ZDrawerContentType<T> = Type<T> | TemplateRef<T> | string;
+type ZDrawerPlacement = 'left' | 'right' | 'top' | 'bottom';
+type ZDrawerScrollMode = 'drawer' | 'inner';
+type ZDrawerOnClickCallBack<T> = (instance: T, drawerRef?: unknown) => false | void | object;
+
+/**
+ * Configuration options for z-drawer component.
+ *
+ * @template T - The type of the content component
+ * @template U - The type of the data passed to the drawer
+ */
+declare class ZDrawerOptions<T, U> {
+    /** Icon for the cancel button */
+    zCancelIcon?: ZIcon;
+    /** Text for the cancel button. Set to null to hide the button */
+    zCancelText?: string | null;
+    /** Whether the drawer is closable (shows close button) */
+    zClosable?: boolean;
+    /** Drawer content - can be a component, template, or string */
+    zContent?: string | TemplateRef<T> | Type<T>;
+    /** Custom CSS classes for the drawer */
+    class?: ClassValue;
+    /** Custom CSS classes for the drawer body */
+    zBodyClass?: ClassValue;
+    /** Data to be passed to the content component via Z_DRAWER_DATA token */
+    zData?: U;
+    /**
+     * Observable for deferred data loading before showing drawer content.
+     * Drawer will show a loading spinner until the Observable completes.
+     * The resolved data will be available via Z_DRAWER_DATA.
+     */
+    zDefer?: Observable<U>;
+    /** Description text shown below the title */
+    zDescription?: string;
+    /** Whether to disable the header and footer shadows */
+    zDisableShadow?: boolean;
+    /** Whether to show a border below the header */
+    zHeaderBorder?: boolean;
+    /** Whether to show a border above the footer */
+    zFooterBorder?: boolean;
+    /** Whether to hide the default footer */
+    zHideFooter?: boolean;
+    /** Whether to hide the default header */
+    zHideHeader?: boolean;
+    /**
+     * WritableSignal to control loading state of the OK button.
+     * Use this when submitting forms or calling APIs.
+     */
+    readonly zLoading?: WritableSignal<boolean>;
+    /** Whether clicking mask closes the drawer */
+    zMaskClosable?: boolean;
+    /** Whether OK button has destructive (red) style */
+    zOkDestructive?: boolean;
+    /** Whether OK button is disabled */
+    zOkDisabled?: boolean;
+    /** Overlay style: 'dark' (black overlay) or 'blur' (backdrop blur) */
+    zOverlay?: 'dark' | 'blur';
+    /** Icon for the OK button */
+    zOkIcon?: ZIcon;
+    /** Text for the OK button. Set to null to hide the button */
+    zOkText?: string | null;
+    /** Callback or EventEmitter when cancel is clicked */
+    zOnCancel?: EventEmitter<T> | ZDrawerOnClickCallBack<T>;
+    /** Callback or EventEmitter when OK is clicked */
+    zOnOk?: EventEmitter<T> | ZDrawerOnClickCallBack<T>;
+    /** Drawer title - supports string, HTML string, or TemplateRef */
+    zTitle?: string | TemplateRef<T>;
+    /** ViewContainerRef for the drawer portal */
+    zViewContainerRef?: ViewContainerRef;
+    /** Drawer width for left/right placement (e.g., '400px', '80%') */
+    zWidth?: string;
+    /** Drawer height for top/bottom placement (e.g., '400px', '50%') */
+    zHeight?: string;
+    /** Placement of the drawer: 'left', 'right', 'top', 'bottom' */
+    zPlacement?: ZDrawerPlacement;
+    /** Force shadow on header/footer regardless of scroll state */
+    zShadow?: boolean;
+    /** Shape of the drawer: 'rounded' (with border-radius) or 'square' (no border-radius) */
+    zShape?: 'rounded' | 'square';
+    /** WritableSignal to control content loading state (shows skeleton when true) */
+    readonly zContentLoading?: WritableSignal<boolean>;
+    /** Number of skeleton rows to show when content is loading (default: 5 for left/right, 3 for top/bottom) */
+    zSkeletonRows?: number;
+    /** Whether the drawer can be resized from its outer edge */
+    zExpand?: boolean;
+    /** Scroll ownership: the drawer viewport by default, or an inner content viewport */
+    zScrollMode?: ZDrawerScrollMode;
+}
+
+declare class ZDrawerRef<T = any, R = any, U = any> {
+    private readonly _overlayRef;
+    private readonly _config;
+    private readonly _containerInstance;
+    private readonly _platformId;
+    private readonly _destroy$;
+    private _isClosing;
+    private _result?;
+    componentInstance: T | null;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly zAfterClose: EventEmitter<R | undefined>;
+    constructor(_overlayRef: ZOverlayRef, _config: ZDrawerOptions<T, U>, _containerInstance: ZDrawerComponent<T, U>, _platformId: object);
+    setLoading(value: boolean): void;
+    close(result?: R): void;
+    private _trigger;
+    private _getContentComponent;
+    private _closeWithResult;
+}
+
+type ZDrawerShape = 'rounded' | 'square';
+declare const zDrawerVariants: (props?: ({
+    placement?: "left" | "right" | "top" | "bottom" | null | undefined;
+    shape?: "rounded" | "square" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+declare class ZDrawerComponent<T, U> implements OnDestroy, AfterViewChecked {
+    readonly zOnOk: _angular_core.OutputEmitterRef<void>;
+    readonly zOnCancel: _angular_core.OutputEmitterRef<void>;
+    readonly zAfterClose: _angular_core.OutputEmitterRef<void>;
+    readonly zScrollbar: _angular_core.OutputEmitterRef<NgScrollbar>;
+    readonly class: _angular_core.InputSignal<ClassValue>;
+    readonly zBodyClass: _angular_core.InputSignal<ClassValue>;
+    readonly zVisible: _angular_core.ModelSignal<boolean>;
+    readonly zTitle: _angular_core.InputSignal<string | TemplateRef<unknown> | undefined>;
+    readonly zDescription: _angular_core.InputSignal<string | TemplateRef<unknown> | undefined>;
+    readonly zWidth: _angular_core.InputSignal<string>;
+    readonly zHeight: _angular_core.InputSignal<string>;
+    readonly zPlacement: _angular_core.InputSignal<ZDrawerPlacement>;
+    readonly zClosable: _angular_core.InputSignal<boolean>;
+    readonly zMaskClosable: _angular_core.InputSignal<boolean>;
+    readonly zDisableShadow: _angular_core.InputSignal<boolean>;
+    readonly zHeaderBorder: _angular_core.InputSignal<boolean>;
+    readonly zFooterBorder: _angular_core.InputSignal<boolean>;
+    readonly zHideFooter: _angular_core.InputSignal<boolean>;
+    readonly zHideHeader: _angular_core.InputSignal<boolean>;
+    readonly zOkText: _angular_core.InputSignal<string | null>;
+    readonly zCancelText: _angular_core.InputSignal<string | null>;
+    readonly zOkDestructive: _angular_core.InputSignal<boolean>;
+    readonly zOkDisabled: _angular_core.InputSignal<boolean>;
+    readonly zLoading: _angular_core.InputSignal<boolean>;
+    readonly zOverlay: _angular_core.InputSignal<"dark" | "blur">;
+    readonly zShadow: _angular_core.InputSignal<boolean>;
+    readonly zShape: _angular_core.InputSignal<ZDrawerShape>;
+    readonly zContentLoading: _angular_core.InputSignal<boolean>;
+    readonly zSkeletonRows: _angular_core.InputSignal<number | null>;
+    readonly zExpand: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly zScrollMode: _angular_core.InputSignal<ZDrawerScrollMode>;
+    protected readonly customHeader: _angular_core.Signal<ZDrawerHeaderDirective | undefined>;
+    protected readonly customContent: _angular_core.Signal<ZDrawerContentDirective | undefined>;
+    protected readonly customFooter: _angular_core.Signal<ZDrawerFooterDirective | undefined>;
+    private readonly _drawerRef;
+    get drawerRef(): ZDrawerRef<T> | undefined;
+    set drawerRef(value: ZDrawerRef<T> | undefined);
+    protected readonly contentOutlet: _angular_core.Signal<ViewContainerRef | undefined>;
+    protected readonly mainContentRef: _angular_core.Signal<NgScrollbar | undefined>;
+    /**
+     * Content requested before `#contentOutlet` exists.
+     * `@defer` renders the outlet after its dependencies load, so the first open can arrive early.
+     */
+    private _pendingContent;
+    protected readonly config: ZDrawerOptions<T, U>;
+    private readonly _platformId;
+    private readonly _host;
+    private readonly _overlayService;
+    private readonly _cdr;
+    private readonly _destroyRef;
+    private readonly _zTranslate;
+    private readonly _overlayContainerService;
+    private readonly _zIndexService;
+    private readonly _indexDb;
+    private _templateOverlayRef;
+    private _originalParent;
+    private _originalNextSibling;
+    private _backdropSubscription;
+    private _closeTimeout;
+    private _resizeCleanup;
+    private _resizeStorageKey;
+    protected readonly isResizing: _angular_core.WritableSignal<boolean>;
+    protected readonly isLeaving: _angular_core.WritableSignal<boolean>;
+    protected readonly hasScrollableContent: _angular_core.WritableSignal<boolean>;
+    protected readonly isScrolledFromTop: _angular_core.WritableSignal<boolean>;
+    protected readonly isScrolledToBottom: _angular_core.WritableSignal<boolean>;
+    protected readonly isServiceMode: _angular_core.Signal<boolean>;
+    protected readonly isTemplateMode: _angular_core.Signal<boolean>;
+    protected readonly shouldRenderContent: _angular_core.Signal<boolean>;
+    protected readonly isStringContent: _angular_core.Signal<boolean>;
+    private _lastScrollHeight;
+    private readonly _resizedWidth;
+    private readonly _resizedHeight;
+    ngAfterViewChecked(): void;
+    private _checkScrollState;
+    onContentScroll(event: Event): void;
+    protected readonly effectiveTitle: _angular_core.Signal<string | TemplateRef<unknown> | undefined>;
+    protected readonly effectiveDescription: _angular_core.Signal<string | TemplateRef<unknown> | undefined>;
+    protected readonly hasEffectiveDescription: _angular_core.Signal<boolean>;
+    protected readonly headerContentClasses: _angular_core.Signal<string>;
+    protected readonly effectiveBodyClass: _angular_core.Signal<ClassValue>;
+    protected readonly bodyClasses: _angular_core.Signal<string>;
+    protected readonly effectiveClosable: _angular_core.Signal<boolean>;
+    protected readonly effectiveDisableShadow: _angular_core.Signal<boolean>;
+    protected readonly shouldShowShadow: _angular_core.Signal<boolean>;
+    protected readonly effectiveHeaderBorder: _angular_core.Signal<boolean>;
+    protected readonly effectiveFooterBorder: _angular_core.Signal<boolean>;
+    protected readonly effectiveHideFooter: _angular_core.Signal<boolean | undefined>;
+    protected readonly effectiveHideHeader: _angular_core.Signal<boolean>;
+    protected readonly effectiveOkText: _angular_core.Signal<string | null | undefined>;
+    protected readonly effectiveCancelText: _angular_core.Signal<string | null | undefined>;
+    protected readonly effectiveOkDestructive: _angular_core.Signal<boolean | undefined>;
+    protected readonly effectiveOkDisabled: _angular_core.Signal<boolean | undefined>;
+    protected readonly effectiveLoading: _angular_core.Signal<boolean>;
+    protected readonly effectiveContentLoading: _angular_core.Signal<boolean>;
+    protected readonly effectiveSkeletonRows: _angular_core.Signal<number>;
+    protected readonly effectivePlacement: _angular_core.Signal<ZDrawerPlacement>;
+    protected readonly effectiveExpand: _angular_core.Signal<boolean>;
+    protected readonly effectiveScrollMode: _angular_core.Signal<ZDrawerScrollMode>;
+    protected readonly isInnerScrollMode: _angular_core.Signal<boolean>;
+    protected readonly resizeIcon: _angular_core.Signal<"lucideGripVertical" | "lucideGripHorizontal">;
+    protected readonly effectiveShadow: _angular_core.Signal<boolean>;
+    protected readonly effectiveShape: _angular_core.Signal<ZDrawerShape>;
+    protected readonly effectiveWidth: _angular_core.Signal<string | null>;
+    protected readonly effectiveHeight: _angular_core.Signal<string | null>;
+    protected readonly isDeferLoading: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    constructor();
+    ngOnDestroy(): void;
+    startResize(event: PointerEvent): void;
+    onHostPointerDown(event: PointerEvent): void;
+    isDestroyed(): boolean;
+    getNativeElement(): HTMLElement;
+    attachComponentPortal<C>(component: Type<C>, injector?: Injector): ComponentRef<C>;
+    attachTemplatePortal<C>(templateRef: TemplateRef<C>, context: C): EmbeddedViewRef<C>;
+    /**
+     * Attach pending content when the outlet exists and update `drawerRef.componentInstance`.
+     */
+    private _attachPendingContent;
+    onOkClick(): void;
+    onCloseClick(): void;
+    onBackdropClick(): void;
+    open(): void;
+    close(): void;
+    private _createOverlay;
+    private _openTemplateOverlay;
+    private _getResizeKey;
+    private _restoreResize;
+    private _persistResize;
+    private _closeWithAnimation;
+    private _clearCloseTimeout;
+    private _disposeTemplateOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZDrawerComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZDrawerComponent<any, any>, "z-drawer", ["zDrawer"], { "class": { "alias": "class"; "required": false; "isSignal": true; }; "zBodyClass": { "alias": "zBodyClass"; "required": false; "isSignal": true; }; "zVisible": { "alias": "zVisible"; "required": false; "isSignal": true; }; "zTitle": { "alias": "zTitle"; "required": false; "isSignal": true; }; "zDescription": { "alias": "zDescription"; "required": false; "isSignal": true; }; "zWidth": { "alias": "zWidth"; "required": false; "isSignal": true; }; "zHeight": { "alias": "zHeight"; "required": false; "isSignal": true; }; "zPlacement": { "alias": "zPlacement"; "required": false; "isSignal": true; }; "zClosable": { "alias": "zClosable"; "required": false; "isSignal": true; }; "zMaskClosable": { "alias": "zMaskClosable"; "required": false; "isSignal": true; }; "zDisableShadow": { "alias": "zDisableShadow"; "required": false; "isSignal": true; }; "zHeaderBorder": { "alias": "zHeaderBorder"; "required": false; "isSignal": true; }; "zFooterBorder": { "alias": "zFooterBorder"; "required": false; "isSignal": true; }; "zHideFooter": { "alias": "zHideFooter"; "required": false; "isSignal": true; }; "zHideHeader": { "alias": "zHideHeader"; "required": false; "isSignal": true; }; "zOkText": { "alias": "zOkText"; "required": false; "isSignal": true; }; "zCancelText": { "alias": "zCancelText"; "required": false; "isSignal": true; }; "zOkDestructive": { "alias": "zOkDestructive"; "required": false; "isSignal": true; }; "zOkDisabled": { "alias": "zOkDisabled"; "required": false; "isSignal": true; }; "zLoading": { "alias": "zLoading"; "required": false; "isSignal": true; }; "zOverlay": { "alias": "zOverlay"; "required": false; "isSignal": true; }; "zShadow": { "alias": "zShadow"; "required": false; "isSignal": true; }; "zShape": { "alias": "zShape"; "required": false; "isSignal": true; }; "zContentLoading": { "alias": "zContentLoading"; "required": false; "isSignal": true; }; "zSkeletonRows": { "alias": "zSkeletonRows"; "required": false; "isSignal": true; }; "zExpand": { "alias": "zExpand"; "required": false; "isSignal": true; }; "zScrollMode": { "alias": "zScrollMode"; "required": false; "isSignal": true; }; }, { "zOnOk": "zOnOk"; "zOnCancel": "zOnCancel"; "zAfterClose": "zAfterClose"; "zScrollbar": "zScrollbar"; "zVisible": "zVisibleChange"; }, ["customHeader", "customContent", "customFooter"], ["*"], true, never>;
+}
+
+declare class ZDrawerService {
+    private readonly _overlayService;
+    private readonly _injector;
+    private readonly _platformId;
+    private readonly _zIndexService;
+    create<T, U>(config: ZDrawerOptions<T, U>): ZDrawerRef<T>;
+    private _open;
+    private _createOverlay;
+    private _attachDrawerContainer;
+    private _attachDrawerContent;
+    private _createInjector;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZDrawerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+declare const Z_DRAWER_DATA: InjectionToken<any>;
+
+export { ZDrawerComponent, ZDrawerContentDirective, ZDrawerFooterDirective, ZDrawerHeaderDirective, ZDrawerOptions, ZDrawerRef, ZDrawerService, Z_DRAWER_DATA, zDrawerVariants };
+export type { ZDrawerContentType, ZDrawerOnClickCallBack, ZDrawerPlacement, ZDrawerScrollMode };

package/types/shival99-z-ui-components-z-dropdown-menu.d.ts

@@ -0,0 +1,52 @@
+import * as _angular_core from '@angular/core';
+import { AfterContentInit, OnDestroy, ElementRef } from '@angular/core';
+import { ZIcon, ZIconVariants } from '@shival99/z-ui/components/z-icon';
+import { ZPopoverPosition, ZPopoverControl } from '@shival99/z-ui/components/z-popover';
+
+interface ZDropdownMenuItem {
+    label: string;
+    icon?: ZIcon;
+    iconSize?: ZIconVariants['zSize'];
+    shortcut?: string;
+    class?: string;
+    loading?: boolean;
+    disabled?: boolean;
+    hidden?: boolean;
+    onClick?: () => void;
+    divide?: 'before' | 'after';
+    submenu?: ZDropdownMenuItem[];
+    submenuPosition?: ZPopoverPosition;
+    subMinWidth?: number;
+    subMaxWidth?: number;
+}
+
+declare class ZDropdownMenuComponent implements AfterContentInit, OnDestroy {
+    private readonly _host;
+    private _visibilityObserver;
+    protected readonly contentWrapper: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    readonly zOnItemClick: _angular_core.OutputEmitterRef<ZDropdownMenuItem>;
+    readonly zItems: _angular_core.InputSignal<ZDropdownMenuItem[]>;
+    readonly zLabel: _angular_core.InputSignal<string | undefined>;
+    readonly zIcon: _angular_core.InputSignal<ZIcon>;
+    readonly zButtonType: _angular_core.InputSignal<"primary" | "secondary" | "outline" | "ghost">;
+    readonly zPosition: _angular_core.InputSignal<ZPopoverPosition>;
+    readonly zButtonSize: _angular_core.InputSignal<"default" | "xs" | "sm" | "lg" | "xl" | null | undefined>;
+    readonly zOffset: _angular_core.InputSignal<number>;
+    readonly zMinWidth: _angular_core.InputSignal<number>;
+    readonly zMaxWidth: _angular_core.InputSignal<number>;
+    readonly zDisabled: _angular_core.InputSignal<boolean>;
+    readonly zWave: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    protected readonly hasContent: _angular_core.WritableSignal<boolean>;
+    protected readonly popoverControl: _angular_core.WritableSignal<ZPopoverControl | null>;
+    protected readonly visibleItems: _angular_core.Signal<ZDropdownMenuItem[]>;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    protected onItemClick(item: ZDropdownMenuItem): void;
+    protected onControl(control: ZPopoverControl): void;
+    private _setupVisibilityObserver;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZDropdownMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZDropdownMenuComponent, "z-dropdown-menu", never, { "zItems": { "alias": "zItems"; "required": true; "isSignal": true; }; "zLabel": { "alias": "zLabel"; "required": false; "isSignal": true; }; "zIcon": { "alias": "zIcon"; "required": false; "isSignal": true; }; "zButtonType": { "alias": "zButtonType"; "required": false; "isSignal": true; }; "zPosition": { "alias": "zPosition"; "required": false; "isSignal": true; }; "zButtonSize": { "alias": "zButtonSize"; "required": false; "isSignal": true; }; "zOffset": { "alias": "zOffset"; "required": false; "isSignal": true; }; "zMinWidth": { "alias": "zMinWidth"; "required": false; "isSignal": true; }; "zMaxWidth": { "alias": "zMaxWidth"; "required": false; "isSignal": true; }; "zDisabled": { "alias": "zDisabled"; "required": false; "isSignal": true; }; "zWave": { "alias": "zWave"; "required": false; "isSignal": true; }; }, { "zOnItemClick": "zOnItemClick"; }, never, ["*"], true, never>;
+}
+
+export { ZDropdownMenuComponent };
+export type { ZDropdownMenuItem };

package/types/shival99-z-ui-components-z-filter.d.ts

@@ -0,0 +1,285 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, ElementRef, PipeTransform } from '@angular/core';
+import { ZCalendarSize, ZDateRange } from '@shival99/z-ui/components/z-calendar';
+import { ZIcon } from '@shival99/z-ui/components/z-icon';
+import { ClassValue } from 'clsx';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+
+type ZFilterSize = 'sm' | 'md' | 'lg';
+type ZFilterFieldType = 'select' | 'multiselect' | 'date' | 'daterange' | 'text' | 'number' | 'numberrange' | 'boolean' | 'email' | 'url' | 'tel' | 'time' | 'datetime' | 'custom' | 'separator';
+interface ZFilterOption<T = unknown> {
+    value: T;
+    label: string;
+    icon?: ZIcon;
+    metadata?: Record<string, unknown>;
+}
+interface ZFilterOperator {
+    value: string;
+    label: string;
+    supportsMultiple?: boolean;
+}
+interface ZFilterCustomRendererContext<T = unknown> {
+    field: ZFilterFieldConfig<T>;
+    values: T[];
+    operator: string;
+    onChange: (values: T[]) => void;
+}
+interface ZFilterFieldConfig<T = unknown> {
+    key?: string;
+    label?: string;
+    icon?: ZIcon;
+    type?: ZFilterFieldType;
+    group?: string;
+    fields?: ZFilterFieldConfig<T>[];
+    options?: ZFilterOption<T>[];
+    operators?: ZFilterOperator[];
+    customRenderer?: TemplateRef<ZFilterCustomRendererContext<T>>;
+    customValueRenderer?: TemplateRef<{
+        values: T[];
+        options: ZFilterOption<T>[];
+    }>;
+    placeholder?: string;
+    searchable?: boolean;
+    maxSelections?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    prefix?: string;
+    suffix?: string;
+    pattern?: string;
+    validation?: (value: unknown) => boolean;
+    allowCustomValues?: boolean;
+    className?: string;
+    popoverContentClassName?: string;
+    selectedOptionsClassName?: string;
+    onLabel?: string;
+    offLabel?: string;
+    defaultOperator?: string;
+}
+interface ZFilterFieldGroup<T = unknown> {
+    group?: string;
+    fields: ZFilterFieldConfig<T>[];
+}
+type ZFilterFieldsConfig<T = unknown> = ZFilterFieldConfig<T>[] | ZFilterFieldGroup<T>[];
+interface ZFilter<T = unknown> {
+    id: string;
+    field: string;
+    operator: string;
+    values: T[];
+}
+interface ZFilterI18nConfig {
+    addFilter: string;
+    searchFields: string;
+    noFieldsFound: string;
+    noResultsFound: string;
+    select: string;
+    true: string;
+    false: string;
+    min: string;
+    max: string;
+    to: string;
+    selected: string;
+    selectedCount: string;
+    addFilterTitle: string;
+    operators: {
+        is: string;
+        isNot: string;
+        isAnyOf: string;
+        isNotAnyOf: string;
+        includesAll: string;
+        excludesAll: string;
+        before: string;
+        after: string;
+        between: string;
+        notBetween: string;
+        contains: string;
+        notContains: string;
+        startsWith: string;
+        endsWith: string;
+        isExactly: string;
+        equals: string;
+        notEquals: string;
+        greaterThan: string;
+        lessThan: string;
+        overlaps: string;
+        includes: string;
+        excludes: string;
+        includesAllOf: string;
+        includesAnyOf: string;
+        empty: string;
+        notEmpty: string;
+    };
+    placeholders: {
+        enterField: string;
+        selectField: string;
+        searchField: string;
+        enterKey: string;
+        enterValue: string;
+    };
+    validation: {
+        invalidEmail: string;
+        invalidUrl: string;
+        invalidTel: string;
+        invalid: string;
+    };
+}
+declare const DEFAULT_FILTER_I18N: ZFilterI18nConfig;
+
+declare class ZFilterComponent<T = unknown> {
+    readonly addButtonTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    readonly zFiltersChange: _angular_core.OutputEmitterRef<ZFilter<T>[]>;
+    readonly zFilterAdd: _angular_core.OutputEmitterRef<ZFilter<T>>;
+    readonly zFilterRemove: _angular_core.OutputEmitterRef<ZFilter<T>>;
+    readonly zFilterUpdate: _angular_core.OutputEmitterRef<{
+        filter: ZFilter<T>;
+        updates: Partial<ZFilter<T>>;
+    }>;
+    readonly class: _angular_core.InputSignal<ClassValue>;
+    readonly zFilters: _angular_core.InputSignal<ZFilter<T>[]>;
+    readonly zFields: _angular_core.InputSignal<ZFilterFieldsConfig<T>>;
+    readonly zSize: _angular_core.InputSignal<ZFilterSize>;
+    readonly zI18n: _angular_core.InputSignal<Partial<ZFilterI18nConfig>>;
+    readonly zShowAddButton: _angular_core.InputSignal<boolean>;
+    readonly zAllowMultiple: _angular_core.InputSignal<boolean>;
+    readonly zAddButtonIcon: _angular_core.InputSignal<ZIcon>;
+    readonly zAddButtonText: _angular_core.InputSignal<string | undefined>;
+    protected readonly addFilterOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly searchQuery: _angular_core.WritableSignal<string>;
+    protected readonly operatorPopoverOpen: _angular_core.WritableSignal<string | null>;
+    protected readonly valuePopoverOpen: _angular_core.WritableSignal<string | null>;
+    protected readonly addFilterSearchInput: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    protected focusSearchInput(): void;
+    protected focusSelectSearch(filterId: string): void;
+    protected readonly i18n: _angular_core.Signal<ZFilterI18nConfig>;
+    protected readonly fieldsMap: _angular_core.Signal<Record<string, ZFilterFieldConfig<T>>>;
+    protected readonly selectableFields: _angular_core.Signal<ZFilterFieldConfig<T>[]>;
+    protected readonly filteredFields: _angular_core.Signal<ZFilterFieldConfig<T>[]>;
+    protected readonly groupedFields: _angular_core.Signal<{
+        group: string;
+        fields: ZFilterFieldConfig<T>[];
+    }[]>;
+    protected readonly buttonSize: _angular_core.Signal<"sm" | "lg" | "default">;
+    protected readonly calendarSize: _angular_core.Signal<ZCalendarSize>;
+    protected readonly dateValueMap: _angular_core.Signal<Record<string, Date | null>>;
+    protected readonly dateRangeValueMap: _angular_core.Signal<Record<string, ZDateRange | null>>;
+    protected readonly timeValueMap: _angular_core.Signal<Record<string, Date | null>>;
+    protected readonly dateTimeValueMap: _angular_core.Signal<Record<string, Date | null>>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    protected getItemClasses(): string;
+    protected getLabelClasses(): string;
+    protected getInputClasses(): string;
+    protected getRemoveButtonClasses(): string;
+    protected getBetweenClasses(): string;
+    protected getFieldForFilter(filter: ZFilter<T>): ZFilterFieldConfig<T> | undefined;
+    protected getOperatorsForFilter(filter: ZFilter<T>): ZFilterOperator[];
+    protected getOperatorLabel(filter: ZFilter<T>): string;
+    protected getSelectedOptions(filter: ZFilter<T>): ZFilterOption<T>[];
+    protected getUnselectedOptions(filter: ZFilter<T>): ZFilterOption<T>[];
+    protected isValueHidden(filter: ZFilter<T>): boolean;
+    protected isBetweenOperator(filter: ZFilter<T>): boolean;
+    protected getInputPattern(field: ZFilterFieldConfig<T>): string | undefined;
+    protected onFieldSelect(field: ZFilterFieldConfig<T>): void;
+    protected updateFilterOperator(filter: ZFilter<T>, operator: string): void;
+    protected onSelectValueChange(filter: ZFilter<T>, option: ZFilterOption<T>): void;
+    protected onDateValueChange(filter: ZFilter<T>, value: Date | null): void;
+    protected onDateRangeValueChange(filter: ZFilter<T>, value: ZDateRange | null): void;
+    protected onTimeValueChange(filter: ZFilter<T>, value: Date | null): void;
+    protected onDateTimeValueChange(filter: ZFilter<T>, value: Date | null): void;
+    protected removeFilter(filter: ZFilter<T>): void;
+    protected onInputChange(filter: ZFilter<T>, event: Event, index?: number): void;
+    protected onBooleanChange(filter: ZFilter<T>, checked: boolean): void;
+    protected onSearchInput(event: Event): void;
+    protected trackByFilterId(index: number, filter: ZFilter<T>): string;
+    protected trackByOptionValue(index: number, option: ZFilterOption<T>): unknown;
+    protected trackByFieldKey(index: number, field: ZFilterFieldConfig<T>): string;
+    private _updateFilterValues;
+    private _parseDateValue;
+    private _formatDateValue;
+    private _parseTimeValue;
+    private _parseDateTimeValue;
+    private _formatTimeValue;
+    private _formatDateTimeValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZFilterComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZFilterComponent<any>, "z-filter", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "zFilters": { "alias": "zFilters"; "required": true; "isSignal": true; }; "zFields": { "alias": "zFields"; "required": true; "isSignal": true; }; "zSize": { "alias": "zSize"; "required": false; "isSignal": true; }; "zI18n": { "alias": "zI18n"; "required": false; "isSignal": true; }; "zShowAddButton": { "alias": "zShowAddButton"; "required": false; "isSignal": true; }; "zAllowMultiple": { "alias": "zAllowMultiple"; "required": false; "isSignal": true; }; "zAddButtonIcon": { "alias": "zAddButtonIcon"; "required": false; "isSignal": true; }; "zAddButtonText": { "alias": "zAddButtonText"; "required": false; "isSignal": true; }; }, { "zFiltersChange": "zFiltersChange"; "zFilterAdd": "zFilterAdd"; "zFilterRemove": "zFilterRemove"; "zFilterUpdate": "zFilterUpdate"; }, ["addButtonTemplate"], never, true, never>;
+}
+
+declare class ZFilterFieldPipe implements PipeTransform {
+    transform(filter: ZFilter, fields: ZFilterFieldsConfig): ZFilterFieldConfig | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZFilterFieldPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ZFilterFieldPipe, "zFilterField", true>;
+}
+
+declare class ZFilterOperatorLabelPipe implements PipeTransform {
+    transform(filter: ZFilter, fields: ZFilterFieldsConfig, i18n: ZFilterI18nConfig): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZFilterOperatorLabelPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ZFilterOperatorLabelPipe, "zFilterOperatorLabel", true>;
+}
+
+declare class ZFilterOperatorsPipe implements PipeTransform {
+    transform(filter: ZFilter, fields: ZFilterFieldsConfig, i18n: ZFilterI18nConfig): ZFilterOperator[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZFilterOperatorsPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ZFilterOperatorsPipe, "zFilterOperators", true>;
+}
+
+declare class ZFilterSelectedOptionsPipe implements PipeTransform {
+    transform(filter: ZFilter, fields: ZFilterFieldsConfig): ZFilterOption[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZFilterSelectedOptionsPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ZFilterSelectedOptionsPipe, "zFilterSelectedOptions", true>;
+}
+
+declare class ZFilterUnselectedOptionsPipe implements PipeTransform {
+    transform(filter: ZFilter, fields: ZFilterFieldsConfig): ZFilterOption[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZFilterUnselectedOptionsPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ZFilterUnselectedOptionsPipe, "zFilterUnselectedOptions", true>;
+}
+
+declare class ZFilterInputPatternPipe implements PipeTransform {
+    transform(field: ZFilterFieldConfig): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZFilterInputPatternPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ZFilterInputPatternPipe, "zFilterInputPattern", true>;
+}
+
+declare class ZFilterIsValueHiddenPipe implements PipeTransform {
+    transform(filter: ZFilter): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZFilterIsValueHiddenPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ZFilterIsValueHiddenPipe, "zFilterIsValueHidden", true>;
+}
+
+declare class ZFilterIsBetweenOperatorPipe implements PipeTransform {
+    transform(filter: ZFilter): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZFilterIsBetweenOperatorPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ZFilterIsBetweenOperatorPipe, "zFilterIsBetweenOperator", true>;
+}
+
+declare const Z_FILTER_PIPES: readonly [typeof ZFilterFieldPipe, typeof ZFilterOperatorLabelPipe, typeof ZFilterOperatorsPipe, typeof ZFilterSelectedOptionsPipe, typeof ZFilterUnselectedOptionsPipe, typeof ZFilterInputPatternPipe, typeof ZFilterIsValueHiddenPipe, typeof ZFilterIsBetweenOperatorPipe];
+
+declare function createFilter<T = unknown>(field: string, operator?: string, values?: T[]): ZFilter<T>;
+declare function flattenFields<T = unknown>(fields: ZFilterFieldsConfig<T>): ZFilterFieldConfig<T>[];
+declare function getFieldsMap<T = unknown>(fields: ZFilterFieldsConfig<T>): Record<string, ZFilterFieldConfig<T>>;
+declare function getOperatorsForField<T = unknown>(field: ZFilterFieldConfig<T>, values: T[], i18n: ZFilterI18nConfig): ZFilterOperator[];
+declare function formatOperator(operator: string): string;
+declare function getDefaultOperator(fieldType: string): string;
+declare function getDefaultValues<T = unknown>(fieldType: string, field: ZFilterFieldConfig<T>): unknown[];
+declare function getInputPattern(fieldType: string): string | undefined;
+
+declare const zFilterContainerVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zFilterItemVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zFilterFieldLabelVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zFilterInputVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zFilterRemoveButtonVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const zFilterBetweenVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+export { DEFAULT_FILTER_I18N, ZFilterComponent, ZFilterFieldPipe, ZFilterInputPatternPipe, ZFilterIsBetweenOperatorPipe, ZFilterIsValueHiddenPipe, ZFilterOperatorLabelPipe, ZFilterOperatorsPipe, ZFilterSelectedOptionsPipe, ZFilterUnselectedOptionsPipe, Z_FILTER_PIPES, createFilter, flattenFields, formatOperator, getDefaultOperator, getDefaultValues, getFieldsMap, getInputPattern, getOperatorsForField, zFilterBetweenVariants, zFilterContainerVariants, zFilterFieldLabelVariants, zFilterInputVariants, zFilterItemVariants, zFilterRemoveButtonVariants };
+export type { ZFilter, ZFilterCustomRendererContext, ZFilterFieldConfig, ZFilterFieldGroup, ZFilterFieldType, ZFilterFieldsConfig, ZFilterI18nConfig, ZFilterOperator, ZFilterOption, ZFilterSize };

package/types/shival99-z-ui-components-z-modal.d.ts

@@ -252,7 +252,7 @@ declare class ZModalComponent<T, U> implements OnDestroy, AfterViewChecked {
     protected readonly effectiveOkText: _angular_core.Signal<string | null | undefined>;
     protected readonly effectiveCancelText: _angular_core.Signal<string | null | undefined>;
     protected readonly effectiveOkDestructive: _angular_core.Signal<boolean | undefined>;
-    protected readonly effectiveTypeOk: _angular_core.Signal<"info" | "warning" | "error" | "default" | "primary" | "secondary" | "destructive" | "destructive-heartbeat" | "success" | "outline" | "outline-primary" | "outline-secondary" | "outline-success" | "outline-info" | "outline-warning" | "outline-error" | "outline-destructive" | "outline-shimmer" | "outline-success-secondary" | "outline-info-secondary" | "outline-warning-secondary" | "outline-error-secondary" | "outline-destructive-secondary" | "outline-primary-secondary" | "outline-primary-soft" | "outline-success-soft" | "outline-info-soft" | "outline-warning-soft" | "outline-error-soft" | "outline-destructive-soft" | "outline-primary-soft-border" | "outline-success-soft-border" | "outline-info-soft-border" | "outline-warning-soft-border" | "outline-error-soft-border" | "outline-destructive-soft-border" | "ghost" | "ghost-primary" | "ghost-success" | "ghost-info" | "ghost-warning" | "ghost-error" | "ghost-destructive" | "subtle" | "subtle-primary" | "subtle-success" | "subtle-info" | "subtle-warning" | "subtle-destructive" | "subtle-outline" | "subtle-primary-outline" | "subtle-success-outline" | "subtle-info-outline" | "subtle-warning-outline" | "subtle-destructive-outline" | "link" | null | undefined>;
+    protected readonly effectiveTypeOk: _angular_core.Signal<"info" | "warning" | "error" | "link" | "default" | "primary" | "secondary" | "destructive" | "destructive-heartbeat" | "success" | "outline" | "outline-primary" | "outline-secondary" | "outline-success" | "outline-info" | "outline-warning" | "outline-error" | "outline-destructive" | "outline-shimmer" | "outline-success-secondary" | "outline-info-secondary" | "outline-warning-secondary" | "outline-error-secondary" | "outline-destructive-secondary" | "outline-primary-secondary" | "outline-primary-soft" | "outline-success-soft" | "outline-info-soft" | "outline-warning-soft" | "outline-error-soft" | "outline-destructive-soft" | "outline-primary-soft-border" | "outline-success-soft-border" | "outline-info-soft-border" | "outline-warning-soft-border" | "outline-error-soft-border" | "outline-destructive-soft-border" | "ghost" | "ghost-primary" | "ghost-success" | "ghost-info" | "ghost-warning" | "ghost-error" | "ghost-destructive" | "subtle" | "subtle-primary" | "subtle-success" | "subtle-info" | "subtle-warning" | "subtle-destructive" | "subtle-outline" | "subtle-primary-outline" | "subtle-success-outline" | "subtle-info-outline" | "subtle-warning-outline" | "subtle-destructive-outline" | null | undefined>;
     protected readonly effectiveOkDisabled: _angular_core.Signal<boolean | undefined>;
     protected readonly effectiveLoading: _angular_core.Signal<boolean>;
     protected readonly effectiveContentLoading: _angular_core.Signal<boolean>;