@shival99/z-ui 0.0.1 → 1.0.2

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

@@ -0,0 +1,188 @@
+import * as _angular_core from '@angular/core';
+import { Signal, OnInit, TemplateRef, ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { ClassValue } from 'clsx';
+import { Observable } from 'rxjs';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+interface ZInputControl {
+    validate: () => void;
+    reset: () => void;
+    focus: () => void;
+    blur: () => void;
+    markAsTouched: () => void;
+    markAsUntouched: () => void;
+    markAsDirty: () => void;
+    markAsPristine: () => void;
+    setValue: (value: string | number | null) => void;
+    hasError: Signal<boolean>;
+    isValidating: Signal<boolean>;
+    value: Signal<string | number | null>;
+    errorMessage: Signal<string>;
+}
+interface ZInputValidator {
+    error: string;
+    message: string;
+    pattern?: RegExp;
+    min?: number;
+    max?: number;
+    validate?: (value: string | number | null) => boolean;
+}
+interface ZAsyncValidator {
+    error: string;
+    message: string;
+    validate: (value: string | number | null) => Promise<boolean> | Observable<boolean>;
+}
+type ZInputType = 'text' | 'number' | 'password' | 'email' | 'tel' | 'url' | 'search' | 'color' | 'textarea';
+type ZInputSize = 'sm' | 'default' | 'lg';
+type ZAsyncValidateOn = 'change' | 'blur';
+
+declare class ZInputComponent implements OnInit, ControlValueAccessor {
+    readonly class: _angular_core.InputSignal<ClassValue>;
+    readonly zType: _angular_core.InputSignal<ZInputType>;
+    readonly zSize: _angular_core.InputSignal<ZInputSize>;
+    readonly zLabel: _angular_core.InputSignal<string>;
+    readonly zLabelClass: _angular_core.InputSignal<string>;
+    readonly zPlaceholder: _angular_core.InputSignal<string>;
+    readonly zRequired: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zDisabled: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zReadonly: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zPrefix: _angular_core.InputSignal<string | TemplateRef<unknown>>;
+    readonly zSuffix: _angular_core.InputSignal<string | TemplateRef<unknown>>;
+    readonly zMin: _angular_core.InputSignal<number | undefined>;
+    readonly zMax: _angular_core.InputSignal<number | undefined>;
+    readonly zStep: _angular_core.InputSignal<number>;
+    readonly zShowArrows: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zMask: _angular_core.InputSignal<string>;
+    readonly zDecimalPlaces: _angular_core.InputSignal<number | undefined>;
+    readonly zAllowNegative: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zThousandSeparator: _angular_core.InputSignal<string>;
+    readonly zDecimalMarker: _angular_core.InputSignal<"." | "," | [".", ","]>;
+    readonly zValidators: _angular_core.InputSignal<ZInputValidator[]>;
+    readonly zAsyncValidators: _angular_core.InputSignal<ZAsyncValidator[]>;
+    readonly zAsyncDebounce: _angular_core.InputSignal<number>;
+    readonly zAsyncValidateOn: _angular_core.InputSignal<ZAsyncValidateOn>;
+    readonly zShowPasswordToggle: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zSearch: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zDebounce: _angular_core.InputSignal<number>;
+    readonly zAutofocus: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zAutoComplete: _angular_core.InputSignal<string>;
+    readonly zAllowClear: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zAutoSizeContent: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zRows: _angular_core.InputSignal<number>;
+    readonly zResize: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zMaxLength: _angular_core.InputSignal<number | undefined>;
+    readonly zAutoSuggest: _angular_core.InputSignal<string | undefined>;
+    readonly zOnSearch: _angular_core.OutputEmitterRef<string | number | null>;
+    readonly zOnChange: _angular_core.OutputEmitterRef<string | number | null>;
+    readonly zControl: _angular_core.OutputEmitterRef<ZInputControl>;
+    protected readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    protected readonly inputId: string;
+    protected readonly passwordVisible: _angular_core.WritableSignal<boolean>;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly suggestHistory: _angular_core.WritableSignal<string[]>;
+    protected readonly suggestActiveIndex: _angular_core.WritableSignal<number>;
+    protected readonly showSuggestPopover: _angular_core.WritableSignal<boolean>;
+    protected readonly filteredSuggestHistory: _angular_core.Signal<string[]>;
+    private readonly _value;
+    private readonly _touched;
+    private readonly _disabled;
+    private readonly _dirty;
+    private readonly _formControl;
+    private readonly _formStateVersion;
+    private readonly _isNgModel;
+    private readonly _injector;
+    private readonly _destroyRef;
+    private readonly _toastService;
+    private readonly _searchSubject;
+    private readonly _changeSubject;
+    private readonly _asyncValidationSubject;
+    protected readonly isValidating: _angular_core.WritableSignal<boolean>;
+    private readonly _asyncErrors;
+    private readonly _asyncCancelSubject;
+    private _asyncValidationAbortController;
+    private _onChange;
+    private _onTouched;
+    private _ngControl;
+    private _arrowInterval;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isPasswordType: _angular_core.Signal<boolean>;
+    protected readonly isColorType: _angular_core.Signal<boolean>;
+    protected readonly colorCopied: _angular_core.WritableSignal<boolean>;
+    protected readonly isPrefixTemplate: _angular_core.Signal<boolean>;
+    protected readonly isSuffixTemplate: _angular_core.Signal<boolean>;
+    protected readonly isTextarea: _angular_core.Signal<boolean>;
+    protected readonly effectiveType: _angular_core.Signal<ZInputType>;
+    protected readonly showArrows: _angular_core.Signal<boolean>;
+    protected readonly effectiveMask: _angular_core.Signal<string>;
+    protected readonly effectiveDecimalMarker: _angular_core.Signal<"." | "," | [".", ","]>;
+    protected readonly displayValue: _angular_core.Signal<string>;
+    private readonly _shouldShowValidation;
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly showError: _angular_core.Signal<boolean>;
+    protected readonly errorMessage: _angular_core.Signal<string>;
+    protected readonly hasPrefix: _angular_core.Signal<boolean>;
+    protected readonly hasSuffix: _angular_core.Signal<boolean>;
+    protected readonly isTextPrefix: _angular_core.Signal<boolean>;
+    protected readonly isTextSuffix: _angular_core.Signal<boolean>;
+    protected readonly currentStatus: _angular_core.Signal<"default" | "disabled" | "readonly" | "error">;
+    protected readonly inputClasses: _angular_core.Signal<string>;
+    protected readonly textareaClasses: _angular_core.Signal<string>;
+    protected readonly hasAutoSuggest: _angular_core.Signal<boolean>;
+    protected readonly hasValue: _angular_core.Signal<boolean>;
+    protected readonly showClearButton: _angular_core.Signal<boolean>;
+    ngOnInit(): void;
+    private _runAsyncValidation;
+    private _cancelAsyncValidation;
+    writeValue(value: string | number | null): void;
+    registerOnChange(fn: (value: string | number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    focus(): void;
+    blur(): void;
+    markAsTouched(): void;
+    markAsUntouched(): void;
+    markAsDirty(): void;
+    markAsPristine(): void;
+    validate(): void;
+    reset(): void;
+    setValue(value: string | number | null): void;
+    getValue(): string | number | null;
+    protected clearValue(event: MouseEvent): void;
+    private _emitControl;
+    protected onInput(event: Event): void;
+    protected onModelChange(rawValue: string | number | null): void;
+    protected onBlur(): void;
+    protected onFocus(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onSuggestKeydown(event: KeyboardEvent): void;
+    protected selectSuggestItem(item: string): void;
+    protected closeSuggestPopover(): void;
+    private _showSuggestPopover;
+    private _hideSuggestPopover;
+    saveToSuggestHistory(value: string): void;
+    private _loadSuggestHistory;
+    protected onArrowMouseDown(event: MouseEvent, direction: 'up' | 'down'): void;
+    protected onArrowMouseUp(): void;
+    protected togglePasswordVisibility(): void;
+    protected copyColorToClipboard(): void;
+    private _incrementValue;
+    private _cleanNumberValue;
+    private _getValidationErrors;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZInputComponent, "z-input", ["zInput"], { "class": { "alias": "class"; "required": false; "isSignal": true; }; "zType": { "alias": "zType"; "required": false; "isSignal": true; }; "zSize": { "alias": "zSize"; "required": false; "isSignal": true; }; "zLabel": { "alias": "zLabel"; "required": false; "isSignal": true; }; "zLabelClass": { "alias": "zLabelClass"; "required": false; "isSignal": true; }; "zPlaceholder": { "alias": "zPlaceholder"; "required": false; "isSignal": true; }; "zRequired": { "alias": "zRequired"; "required": false; "isSignal": true; }; "zDisabled": { "alias": "zDisabled"; "required": false; "isSignal": true; }; "zReadonly": { "alias": "zReadonly"; "required": false; "isSignal": true; }; "zPrefix": { "alias": "zPrefix"; "required": false; "isSignal": true; }; "zSuffix": { "alias": "zSuffix"; "required": false; "isSignal": true; }; "zMin": { "alias": "zMin"; "required": false; "isSignal": true; }; "zMax": { "alias": "zMax"; "required": false; "isSignal": true; }; "zStep": { "alias": "zStep"; "required": false; "isSignal": true; }; "zShowArrows": { "alias": "zShowArrows"; "required": false; "isSignal": true; }; "zMask": { "alias": "zMask"; "required": false; "isSignal": true; }; "zDecimalPlaces": { "alias": "zDecimalPlaces"; "required": false; "isSignal": true; }; "zAllowNegative": { "alias": "zAllowNegative"; "required": false; "isSignal": true; }; "zThousandSeparator": { "alias": "zThousandSeparator"; "required": false; "isSignal": true; }; "zDecimalMarker": { "alias": "zDecimalMarker"; "required": false; "isSignal": true; }; "zValidators": { "alias": "zValidators"; "required": false; "isSignal": true; }; "zAsyncValidators": { "alias": "zAsyncValidators"; "required": false; "isSignal": true; }; "zAsyncDebounce": { "alias": "zAsyncDebounce"; "required": false; "isSignal": true; }; "zAsyncValidateOn": { "alias": "zAsyncValidateOn"; "required": false; "isSignal": true; }; "zShowPasswordToggle": { "alias": "zShowPasswordToggle"; "required": false; "isSignal": true; }; "zSearch": { "alias": "zSearch"; "required": false; "isSignal": true; }; "zDebounce": { "alias": "zDebounce"; "required": false; "isSignal": true; }; "zAutofocus": { "alias": "zAutofocus"; "required": false; "isSignal": true; }; "zAutoComplete": { "alias": "zAutoComplete"; "required": false; "isSignal": true; }; "zAllowClear": { "alias": "zAllowClear"; "required": false; "isSignal": true; }; "zAutoSizeContent": { "alias": "zAutoSizeContent"; "required": false; "isSignal": true; }; "zRows": { "alias": "zRows"; "required": false; "isSignal": true; }; "zResize": { "alias": "zResize"; "required": false; "isSignal": true; }; "zMaxLength": { "alias": "zMaxLength"; "required": false; "isSignal": true; }; "zAutoSuggest": { "alias": "zAutoSuggest"; "required": false; "isSignal": true; }; }, { "zOnSearch": "zOnSearch"; "zOnChange": "zOnChange"; "zControl": "zControl"; }, never, never, true, never>;
+}
+
+declare const zInputVariants: (props?: ({
+    zSize?: "sm" | "default" | "lg" | null | undefined;
+    zStatus?: "default" | "error" | "disabled" | "readonly" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ZInputVariants = VariantProps<typeof zInputVariants>;
+declare const zTextareaVariants: (props?: ({
+    zStatus?: "default" | "error" | "disabled" | "readonly" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ZTextareaVariants = VariantProps<typeof zTextareaVariants>;
+
+export { ZInputComponent, zInputVariants, zTextareaVariants };
+export type { ZAsyncValidateOn, ZAsyncValidator, ZInputControl, ZInputSize, ZInputType, ZInputValidator, ZInputVariants, ZTextareaVariants };

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

@@ -0,0 +1,46 @@
+import * as _angular_core from '@angular/core';
+import { ClassValue } from 'clsx';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+type ZLoadingSpinner = 'spinner' | 'orbit' | 'matrix' | 'conic' | 'polygon' | 'triple';
+type ZLoadingSize = '2xs' | 'xs' | 'default' | 'lg' | 'xl';
+type ZLoadingColor = 'primary' | 'secondary' | 'white' | 'current';
+type ZLoadingOverlayType = 'default' | 'dark' | 'blur';
+
+declare class ZLoadingComponent {
+    readonly class: _angular_core.InputSignal<ClassValue>;
+    readonly zSpinner: _angular_core.InputSignal<ZLoadingSpinner>;
+    readonly zSize: _angular_core.InputSignal<ZLoadingSize>;
+    readonly zColor: _angular_core.InputSignal<ZLoadingColor>;
+    readonly zText: _angular_core.InputSignal<string>;
+    readonly zOverlay: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zOverlayType: _angular_core.InputSignal<ZLoadingOverlayType>;
+    readonly zFullscreen: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly zLoading: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    protected readonly isVisible: _angular_core.WritableSignal<boolean>;
+    protected readonly isLeaving: _angular_core.WritableSignal<boolean>;
+    private _leaveTimeout;
+    constructor();
+    protected readonly spinnerClasses: _angular_core.Signal<string>;
+    protected readonly baseClasses: _angular_core.Signal<string>;
+    protected readonly overlayClasses: _angular_core.Signal<string>;
+    protected readonly textSizeClasses: _angular_core.Signal<{
+        'text-xs': boolean;
+        'text-sm': boolean;
+        'text-base': boolean;
+        'text-lg': boolean;
+    }>;
+    private _handleLoadingChange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZLoadingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZLoadingComponent, "z-loading", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "zSpinner": { "alias": "zSpinner"; "required": false; "isSignal": true; }; "zSize": { "alias": "zSize"; "required": false; "isSignal": true; }; "zColor": { "alias": "zColor"; "required": false; "isSignal": true; }; "zText": { "alias": "zText"; "required": false; "isSignal": true; }; "zOverlay": { "alias": "zOverlay"; "required": false; "isSignal": true; }; "zOverlayType": { "alias": "zOverlayType"; "required": false; "isSignal": true; }; "zFullscreen": { "alias": "zFullscreen"; "required": false; "isSignal": true; }; "zLoading": { "alias": "zLoading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const zLoadingVariants: (props?: ({
+    zSize?: "2xs" | "xs" | "default" | "lg" | "xl" | null | undefined;
+    zColor?: "primary" | "secondary" | "white" | "current" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ZLoadingVariants = VariantProps<typeof zLoadingVariants>;
+
+export { ZLoadingComponent, zLoadingVariants };
+export type { ZLoadingColor, ZLoadingSize, ZLoadingSpinner, ZLoadingVariants };

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

@@ -0,0 +1,116 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Signal } from '@angular/core';
+import { ZIcon } from '@shival99/z-ui/components/z-icon';
+
+interface ZMenuItemTemplateContext {
+    $implicit: ZMenuItem;
+    close: () => void;
+}
+type ZMenuOverlayType = 'dark' | 'blur';
+interface ZMenuItem {
+    id: string;
+    name: string;
+    icon?: ZIcon;
+    iconSvg?: string;
+    parent?: string[];
+    active?: boolean;
+    expanded?: boolean;
+    children?: ZMenuItem[];
+    permission?: string[];
+    path: string;
+    level?: number;
+    subPaths?: string[];
+    menuTemplate?: TemplateRef<ZMenuItemTemplateContext>;
+    menuTemplateWidth?: number;
+}
+interface ZMenuProcessed {
+    tree: ZMenuItem[];
+    flat: Map<string, ZMenuItem>;
+}
+interface ZMenuUser {
+    name: string;
+    email: string;
+    avatar?: string;
+}
+interface ZMenuControl {
+    openMobileMenu: () => void;
+    closeMobileMenu: () => void;
+    toggleMobileMenu: () => void;
+    setSelectedMenuItem: (menuId: string) => void;
+    toggleSidebar: () => void;
+    openMobileTemplateDrawer: (parentId: string) => void;
+    closeMobileTemplateDrawer: () => void;
+    sidebarCollapsed: Signal<boolean>;
+    mobileMenuOpen: Signal<boolean>;
+    mobileTemplateDrawerOpen: Signal<boolean>;
+    selectedMenuItem: Signal<ZMenuItem | null>;
+    selectedParent: Signal<ZMenuItem | null>;
+    menuProcessed: Signal<ZMenuProcessed>;
+}
+
+declare class ZMenuComponent {
+    private readonly _breakpointObserver;
+    private readonly _destroyRef;
+    private readonly _platformId;
+    private readonly _router;
+    readonly zLogo: _angular_core.InputSignal<string>;
+    readonly zMenus: _angular_core.InputSignal<ZMenuItem[]>;
+    readonly zUser: _angular_core.InputSignal<ZMenuUser | null>;
+    readonly zActionsTemplate: _angular_core.InputSignal<TemplateRef<{
+        close: () => void;
+    }> | null>;
+    readonly zCurrentPath: _angular_core.InputSignal<string>;
+    readonly zOnSelect: _angular_core.OutputEmitterRef<ZMenuItem>;
+    readonly zOnLogout: _angular_core.OutputEmitterRef<void>;
+    readonly zControl: _angular_core.OutputEmitterRef<ZMenuControl>;
+    readonly selectedParent: _angular_core.WritableSignal<ZMenuItem | null>;
+    readonly selectedMenuItem: _angular_core.WritableSignal<ZMenuItem | null>;
+    readonly sidebarCollapsed: _angular_core.WritableSignal<boolean>;
+    readonly mobileMenuOpen: _angular_core.WritableSignal<boolean>;
+    readonly mobileTemplateDrawerOpen: _angular_core.WritableSignal<boolean>;
+    private readonly _templateDrawerParentId;
+    protected readonly closeSidebarFn: () => void;
+    protected readonly closeMobileDrawerFn: () => void;
+    private readonly _isMobile$;
+    readonly isMobile: _angular_core.Signal<boolean>;
+    private readonly _routerPath;
+    private readonly _currentPath;
+    protected readonly overlayType: _angular_core.Signal<ZMenuOverlayType>;
+    protected readonly menuProcessed: _angular_core.Signal<ZMenuProcessed>;
+    protected readonly menuParents: _angular_core.Signal<ZMenuItem[]>;
+    protected readonly menuChildren: _angular_core.Signal<ZMenuItem[]>;
+    protected readonly parentWithActiveChild: _angular_core.Signal<ZMenuItem | null>;
+    protected isParentOfActiveItem(item: ZMenuItem): boolean;
+    protected readonly avatarSrc: _angular_core.Signal<string>;
+    protected readonly customDrawerParent: _angular_core.Signal<ZMenuItem | null>;
+    private readonly _defaultSidebarChildWidth;
+    private readonly _defaultMobileDrawerWidth;
+    protected readonly sidebarChildWidth: _angular_core.Signal<number>;
+    protected readonly mobileCustomDrawerWidth: _angular_core.Signal<number>;
+    constructor();
+    private _emitControl;
+    openMobileMenu(): void;
+    closeMobileMenu(): void;
+    toggleMobileMenu(): void;
+    openMobileTemplateDrawer(parentId: string): void;
+    closeMobileTemplateDrawer(): void;
+    setSelectedMenuItem(menuId: string): void;
+    protected selectParent(item: ZMenuItem): void;
+    protected onMenuItemClick(item: ZMenuItem): void;
+    protected onMobileParentClick(item: ZMenuItem): void;
+    protected toggleSidebar(): void;
+    protected closeSidebar(): void;
+    protected onLogoutClick(): void;
+    protected onBackdropClick(): void;
+    private _findMenuItemById;
+    private _findParentOfMenuItem;
+    private _isChildOf;
+    private _expandParentsOfItem;
+    private _processMenus;
+    private _findMenuItemByPath;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZMenuComponent, "z-menu", never, { "zLogo": { "alias": "zLogo"; "required": false; "isSignal": true; }; "zMenus": { "alias": "zMenus"; "required": false; "isSignal": true; }; "zUser": { "alias": "zUser"; "required": false; "isSignal": true; }; "zActionsTemplate": { "alias": "zActionsTemplate"; "required": false; "isSignal": true; }; "zCurrentPath": { "alias": "zCurrentPath"; "required": false; "isSignal": true; }; }, { "zOnSelect": "zOnSelect"; "zOnLogout": "zOnLogout"; "zControl": "zControl"; }, never, never, true, never>;
+}
+
+export { ZMenuComponent };
+export type { ZMenuControl, ZMenuItem, ZMenuItemTemplateContext, ZMenuProcessed, ZMenuUser };

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

@@ -0,0 +1,270 @@
+import { ComponentType, OverlayRef } from '@angular/cdk/overlay';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Type, WritableSignal, EventEmitter, ViewContainerRef, InjectionToken, OnDestroy, AfterViewChecked, ComponentRef, EmbeddedViewRef } from '@angular/core';
+import { ClassValue } from 'clsx';
+import { Observable } from 'rxjs';
+import { ZIcon } from '@shival99/z-ui/components/z-icon';
+import { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal } from '@angular/cdk/portal';
+import { NgScrollbar } from 'ngx-scrollbar';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+
+type ZModalContentType<T> = ComponentType<T> | TemplateRef<T> | string;
+declare const Z_MODAL_DATA: InjectionToken<any>;
+type ZModalOnClickCallBack<T> = (instance: T, modalRef?: unknown) => false | void | object;
+type ZModalConfirmType = 'show' | 'info' | 'warning' | 'danger';
+/**
+ * Configuration options for z-modal component.
+ *
+ * @template T - The type of the content component
+ * @template U - The type of the data passed to the modal
+ */
+declare class ZModalOptions<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 modal is closable (shows close button) */
+    zClosable?: boolean;
+    /** Confirm type for preset styling (show, info, warning, danger) */
+    zConfirmType?: 'show' | 'info' | 'warning' | 'danger';
+    /** Icon for the confirm modal */
+    zConfirmIcon?: ZIcon;
+    /** Modal content - can be a component, template, or string */
+    zContent?: string | TemplateRef<T> | Type<T>;
+    /** Custom CSS classes for the modal */
+    class?: ClassValue;
+    /** Data to be passed to the content component via Z_MODAL_DATA token */
+    zData?: U;
+    /**
+     * Observable for deferred data loading before showing modal content.
+     * Modal will show a loading spinner until the Observable completes.
+     * The resolved data will be available via Z_MODAL_DATA.
+     *
+     * @example
+     * ```typescript
+     * this.modalService.create({
+     *   zDefer: this.userService.getUser(userId),
+     *   zContent: UserFormComponent,
+     * });
+     * ```
+     */
+    zDefer?: Observable<U>;
+    /** Description text shown below the title */
+    zDescription?: string;
+    /** Whether to hide the default footer */
+    zHideFooter?: boolean;
+    /**
+     * WritableSignal to control loading state of the OK button.
+     * Use this when submitting forms or calling APIs.
+     *
+     * @example Using with confirm modal (delete action)
+     * ```typescript
+     * const modalRef = this.modalService.danger({
+     *   zTitle: 'Delete Item',
+     *   zContent: 'Are you sure you want to delete this item?',
+     *   zOkText: 'Delete',
+     *   zOnOk: () => {
+     *     modalRef.setLoading(true);
+     *     this.api.delete(itemId).subscribe({
+     *       next: () => {
+     *         modalRef.setLoading(false);
+     *         modalRef.close();
+     *       },
+     *       error: () => modalRef.setLoading(false),
+     *     });
+     *     return false; // Prevent auto-close
+     *   },
+     * });
+     * ```
+     */
+    readonly zLoading?: WritableSignal<boolean>;
+    /** Whether clicking mask closes the modal */
+    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> | ZModalOnClickCallBack<T>;
+    /** Callback or EventEmitter when OK is clicked */
+    zOnOk?: EventEmitter<T> | ZModalOnClickCallBack<T>;
+    /** Modal title - supports string, HTML string, or TemplateRef */
+    zTitle?: string | TemplateRef<T>;
+    /** ViewContainerRef for the modal portal */
+    zViewContainerRef?: ViewContainerRef;
+    /** Modal width (e.g., '425px', '80%') */
+    zWidth?: string;
+    /** WritableSignal to control content loading state (shows skeleton when true) */
+    readonly zContentLoading?: WritableSignal<boolean>;
+    /** Number of skeleton rows to show when content is loading */
+    zSkeletonRows?: number;
+}
+interface ZModalConfirmOptions<U = unknown> {
+    zTitle: string;
+    zContent?: string;
+    zIcon?: ZIcon;
+    zOkText?: string;
+    zCancelText?: string | null;
+    /** Callback when OK is clicked. Return false to prevent auto-close */
+    zOnOk?: () => void | false | Promise<void>;
+    zOnCancel?: () => void;
+    zMaskClosable?: boolean;
+    zWidth?: string;
+    zData?: U;
+}
+interface ZModalConfirmIconColors {
+    ring: string;
+    bg: string;
+    icon: string;
+}
+
+declare class ZModalContentDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZModalContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZModalContentDirective, "[z-modal-content], [zModalContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ZModalFooterDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZModalFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZModalFooterDirective, "[z-modal-footer], [zModalFooter]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ZModalHeaderDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZModalHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZModalHeaderDirective, "[z-modal-header], [zModalHeader]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ZModalRef<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>;
+    constructor(_overlayRef: OverlayRef, _config: ZModalOptions<T, U>, _containerInstance: ZModalComponent<T, U>, _platformId: object);
+    setLoading(value: boolean): void;
+    close(result?: R): void;
+    private _trigger;
+    private _getContentComponent;
+    private _closeWithResult;
+}
+
+declare class ZModalComponent<T, U> extends BasePortalOutlet implements OnDestroy, AfterViewChecked {
+    zOk: _angular_core.OutputEmitterRef<void>;
+    zCancel: _angular_core.OutputEmitterRef<void>;
+    readonly class: _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 zClosable: _angular_core.InputSignal<boolean>;
+    readonly zMaskClosable: _angular_core.InputSignal<boolean>;
+    readonly zHideFooter: _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 zContentLoading: _angular_core.InputSignal<boolean>;
+    readonly zSkeletonRows: _angular_core.InputSignal<number>;
+    readonly zOverlay: _angular_core.InputSignal<"dark" | "blur">;
+    protected readonly customHeader: _angular_core.Signal<ZModalHeaderDirective | undefined>;
+    protected readonly customContent: _angular_core.Signal<ZModalContentDirective | undefined>;
+    protected readonly customFooter: _angular_core.Signal<ZModalFooterDirective | undefined>;
+    modalRef?: ZModalRef<T>;
+    readonly portalOutlet: _angular_core.Signal<CdkPortalOutlet | undefined>;
+    protected readonly dummyTemplateRef: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    protected readonly mainContentRef: _angular_core.Signal<NgScrollbar | undefined>;
+    protected readonly config: ZModalOptions<T, U>;
+    private readonly _platformId;
+    private readonly _host;
+    private readonly _overlay;
+    private readonly _viewContainerRef;
+    private readonly _cdr;
+    private _templateOverlayRef;
+    private _originalParent;
+    private _originalNextSibling;
+    private _backdropSubscription;
+    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 isConfirmMode: _angular_core.Signal<boolean>;
+    protected readonly shouldRenderContent: _angular_core.Signal<boolean>;
+    protected readonly isStringContent: _angular_core.Signal<boolean>;
+    protected readonly shouldShowShadow: _angular_core.Signal<boolean>;
+    private _lastScrollHeight;
+    ngAfterViewChecked(): void;
+    private _checkScrollState;
+    onContentScroll(event: Event): void;
+    protected readonly confirmIconColors: _angular_core.Signal<ZModalConfirmIconColors>;
+    protected readonly effectiveTitle: _angular_core.Signal<string | TemplateRef<unknown> | undefined>;
+    protected readonly effectiveDescription: _angular_core.Signal<string | TemplateRef<unknown> | undefined>;
+    protected readonly effectiveClosable: _angular_core.Signal<boolean>;
+    protected readonly effectiveHideFooter: _angular_core.Signal<boolean | undefined>;
+    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" | "link" | "default" | "primary" | "secondary" | "destructive" | "success" | "outline" | "outline-primary" | "outline-secondary" | "outline-success" | "outline-info" | "outline-warning" | "outline-error" | "outline-destructive" | "outline-success-secondary" | "outline-info-secondary" | "outline-warning-secondary" | "outline-error-secondary" | "outline-destructive-secondary" | "outline-primary-secondary" | "ghost" | "ghost-primary" | "ghost-success" | "ghost-info" | "ghost-warning" | "ghost-error" | "ghost-destructive" | "subtle" | null | 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 effectiveWidth: _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;
+    getNativeElement(): HTMLElement;
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    onOkClick(): void;
+    onCloseClick(): void;
+    onBackdropClick(): void;
+    open(): void;
+    close(): void;
+    private _createOverlay;
+    private _openTemplateOverlay;
+    private _closeWithAnimation;
+    private _disposeTemplateOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZModalComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZModalComponent<any, any>, "z-modal", ["zModal"], { "class": { "alias": "class"; "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; }; "zClosable": { "alias": "zClosable"; "required": false; "isSignal": true; }; "zMaskClosable": { "alias": "zMaskClosable"; "required": false; "isSignal": true; }; "zHideFooter": { "alias": "zHideFooter"; "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; }; "zContentLoading": { "alias": "zContentLoading"; "required": false; "isSignal": true; }; "zSkeletonRows": { "alias": "zSkeletonRows"; "required": false; "isSignal": true; }; "zOverlay": { "alias": "zOverlay"; "required": false; "isSignal": true; }; }, { "zOk": "zOk"; "zCancel": "zCancel"; "zVisible": "zVisibleChange"; }, ["customHeader", "customContent", "customFooter"], ["*"], true, never>;
+}
+
+declare class ZModalService {
+    private readonly _overlay;
+    private readonly _injector;
+    private readonly _platformId;
+    create<T, U>(config: ZModalOptions<T, U>): ZModalRef<T>;
+    show<U = unknown>(options: ZModalConfirmOptions<U>): ZModalRef<unknown>;
+    info<U = unknown>(options: ZModalConfirmOptions<U>): ZModalRef<unknown>;
+    warning<U = unknown>(options: ZModalConfirmOptions<U>): ZModalRef<unknown>;
+    danger<U = unknown>(options: ZModalConfirmOptions<U>): ZModalRef<unknown>;
+    private _confirmModal;
+    private _open;
+    private _createOverlay;
+    private _attachModalContainer;
+    private _attachModalContent;
+    private _createInjector;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZModalService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ZModalService>;
+}
+
+declare const zModalVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+
+export { ZModalComponent, ZModalContentDirective, ZModalFooterDirective, ZModalHeaderDirective, ZModalOptions, ZModalRef, ZModalService, Z_MODAL_DATA, zModalVariants };
+export type { ZModalConfirmOptions, ZModalConfirmType, ZModalContentType, ZModalOnClickCallBack };