qucoon-components 0.0.6 → 0.0.7

package/dist/types/components/custom/bulkUploadLayout.d.ts

@@ -0,0 +1,26 @@
+import { BulkUploadConfig, BulkUploadError } from '../../utilities/helpers/bulkUploadFileParser';
+export interface BulkUploadLayoutProps<T> {
+    config: BulkUploadConfig<T>;
+    onSuccess: (data: T[], additionalData?: Record<string, any>) => Promise<void>;
+    onError?: (errors: BulkUploadError[]) => void;
+    title?: string;
+    subtitle?: string;
+    additionalFields?: Array<{
+        name: string;
+        label: string;
+        type?: 'text' | 'number' | 'email' | 'tel';
+        required?: boolean;
+        placeholder?: string;
+        validator?: (value: string) => string | null;
+    }>;
+    showPreview?: boolean;
+    maxPreviewRows?: number;
+    allowAutoSubmit?: boolean;
+    submitButtonText?: string;
+    cancelButtonText?: string;
+    onCancel?: () => void;
+    className?: string;
+    disabled?: boolean;
+}
+declare const BulkUploadLayout: <T>({ config, onSuccess, onError, title, subtitle, additionalFields, showPreview, maxPreviewRows, allowAutoSubmit, submitButtonText, cancelButtonText, onCancel, className, disabled, }: BulkUploadLayoutProps<T>) => import("react/jsx-runtime").JSX.Element;
+export default BulkUploadLayout;

package/dist/types/components/custom/index.d.ts

@@ -21,5 +21,7 @@ export { default as TextDecorator } from './TextDecorator';
 export * from './TextDecorator';
 export { default as TodoList } from './TodoList';
 export * from './TodoList';
+export { default as bulkUploadLayout } from './bulkUploadLayout';
+export * from './bulkUploadLayout';
 export { default as reduxProvider } from './reduxProvider';
 export * from './reduxProvider';

package/dist/types/components/ui/datepicker/BaseDatePicker.d.ts

@@ -2,9 +2,10 @@ import { default as React, CSSProperties } from 'react';
 import { BaseCalendarProps } from '../calendar/BaseCalendar';
 import { FormikProps, FormikValues } from 'formik';
 import { EnhancedLabelProps } from '../label/EnhancedLabel';
-export type BaseDatePickerProps<T extends FormikValues> = {
-    selected?: Date;
-    onSelect?: (date: Date | undefined) => void;
+import { DateFormatConfig, DateFormatPresets, DateFormatType } from '../../../utilities/enhancedTimeUtil';
+export type BaseDatePickerProps<T extends FormikValues = any> = {
+    selected?: unknown;
+    onSelect?: (date: unknown) => void;
     placeholder?: string;
     className?: string;
     label?: string;
@@ -18,7 +19,8 @@ export type BaseDatePickerProps<T extends FormikValues> = {
         isLoading?: boolean;
     };
     formik?: FormikProps<T>;
+    dateFormat?: DateFormatConfig<any, any> | keyof typeof DateFormatPresets | DateFormatType;
     useTimestamp?: boolean;
 } & Omit<BaseCalendarProps, "selected" | "onSelect" | "mode">;
-declare const BaseDatePicker: <T extends FormikValues>({ selected, onSelect, placeholder, className, showPresetRanges, label, labelStyle, labelProps, helperText, helperTextProps, formik, name, error, useTimestamp, ...baseCalendarProps }: BaseDatePickerProps<T>) => import("react/jsx-runtime").JSX.Element;
+declare const BaseDatePicker: <T extends FormikValues = any>({ selected, onSelect, placeholder, className, showPresetRanges, label, labelStyle, labelProps, helperText, helperTextProps, formik, name, error, dateFormat, useTimestamp, ...baseCalendarProps }: BaseDatePickerProps<T>) => import("react/jsx-runtime").JSX.Element;
 export default BaseDatePicker;

package/dist/types/components/ui/datepicker/BaseDateRangePicker.d.ts

@@ -1,12 +1,11 @@
-import { default as React, CSSProperties } from 'react';
-import { BaseCalendarProps } from '../calendar/BaseCalendar';
-import { DateRange } from 'react-day-picker';
 import { FormikProps, FormikValues } from 'formik';
-import { EnhancedLabelProps } from '../label/EnhancedLabel';
-export type BaseDateRangePickerProps<T extends FormikValues> = {
+import { CSSProperties } from 'react';
+import { BaseCalendarProps, EnhancedLabelProps } from '../..';
+import { DateFormatConfig, DateFormatPresets, DateFormatType } from '../../../utilities/enhancedTimeUtil';
+export type BaseDateRangePickerProps<T extends FormikValues = any> = {
     type?: "single" | "double";
-    selected?: DateRange;
-    onSelect?: (date: DateRange | undefined) => void;
+    selected?: unknown;
+    onSelect?: (date: unknown) => void;
     placeholder?: string;
     className?: string;
     label?: string;
@@ -20,9 +19,10 @@ export type BaseDateRangePickerProps<T extends FormikValues> = {
         isLoading?: boolean;
     };
     formik?: FormikProps<T>;
+    dateFormat?: DateFormatConfig<any, any> | keyof typeof DateFormatPresets | DateFormatType;
     startDateField?: string;
     endDateField?: string;
     useTimestamps?: boolean;
 } & Omit<BaseCalendarProps, "selected" | "onSelect" | "mode">;
-declare const BaseDateRangePicker: <T extends FormikValues>({ type, selected, onSelect, placeholder, className, showPresetRanges, label, labelStyle, labelProps, helperText, helperTextProps, formik, name, error, startDateField, endDateField, useTimestamps, ...baseCalendarProps }: BaseDateRangePickerProps<T>) => import("react/jsx-runtime").JSX.Element;
+declare const BaseDateRangePicker: <T extends FormikValues = any>({ type, selected, onSelect, placeholder, className, showPresetRanges, label, labelStyle, labelProps, helperText, helperTextProps, formik, name, error, startDateField, endDateField, dateFormat, useTimestamps, ...baseCalendarProps }: BaseDateRangePickerProps<T>) => import("react/jsx-runtime").JSX.Element;
 export default BaseDateRangePicker;

package/dist/types/components/ui/modal/BaseModal.d.ts

@@ -1,6 +1,6 @@
 import { default as React, ReactNode } from 'react';
 import { ModalPosition } from '../../../utilities/types/modalTypes';
-export interface BaseModalProps {
+interface BaseModalProps {
     ref: React.RefObject<HTMLDivElement>;
     id: string;
     zIndex?: number;
@@ -17,3 +17,4 @@ export interface BaseModalProps {
     containerClassName?: string;
 }
 export default function BaseModal({ ref, id, zIndex, backdrop, closeOnBackdropClick, enableBackDrop, position, offset, animation, children, onClose, onFocus, containerClassName, }: BaseModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/ui/modal/GlobalModal.d.ts

@@ -1,2 +1,2 @@
-declare const GlobalModal: () => import("react/jsx-runtime").JSX.Element;
+declare const GlobalModal: () => null;
 export default GlobalModal;

package/dist/types/components/ui/modal/index.d.ts

@@ -17,3 +17,4 @@ export { default as confirmationModal } from './confirmationModal';
 export * from './confirmationModal';
 export { default as notificationModal } from './notificationModal';
 export * from './notificationModal';
+export * from './v2';

package/dist/types/components/ui/modal/v2/BaseModal.d.ts

@@ -0,0 +1,26 @@
+import { default as React, ReactNode } from 'react';
+import { ModalPosition } from '../../../../utilities/types/modalTypes';
+export interface BaseModalProps {
+    ref: React.RefObject<HTMLDivElement>;
+    id: string;
+    zIndex?: number;
+    backdrop?: 'blur' | 'solid' | 'transparent';
+    closeOnBackdropClick?: boolean;
+    enableBackDrop?: boolean;
+    closeOnEscape?: boolean;
+    position?: ModalPosition;
+    offset?: number;
+    animation?: 'fade' | 'slide' | 'scale' | 'none';
+    children: ReactNode;
+    onClose?: () => void;
+    onFocus?: () => void;
+    containerClassName?: string;
+    containerStyle?: React.CSSProperties;
+    backdropClassName?: string;
+    backdropStyle?: React.CSSProperties;
+    theme?: 'default' | 'minimal' | 'glass' | 'elevated';
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'auto';
+    cssProps?: Record<string, string>;
+}
+export declare function BaseModal({ ref, id, zIndex, backdrop, closeOnBackdropClick, enableBackDrop, position, offset, animation, theme, size, children, onClose, onFocus, containerClassName, containerStyle, backdropClassName, backdropStyle, cssProps, }: BaseModalProps): import("react/jsx-runtime").JSX.Element;
+export default BaseModal;

package/dist/types/components/ui/modal/v2/ModalRenderer.d.ts

@@ -0,0 +1,6 @@
+import { ModalInstance } from '../../../../utilities/context/modalContext';
+interface Props {
+    modals: ModalInstance[];
+}
+export default function ModalRenderer({ modals }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/ui/modal/v2/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Auto-generated barrel for src/components/ui/modal/v2
+ */
+export { default as BaseModal } from './BaseModal';
+export * from './BaseModal';
+export { default as ModalRenderer } from './ModalRenderer';
+export * from './ModalRenderer';

package/dist/types/utilities/context/modalContext.d.ts

@@ -1,22 +1,24 @@
 import { ReactNode } from 'react';
-import { ModalBaseConfig, ModalRegistry } from '../types/modalTypes';
-export interface ModalInstance<T extends keyof ModalRegistry = keyof ModalRegistry> {
+import { ModalBaseConfig } from '../types/modalTypes';
+export interface ModalInstance {
     id: string;
-    type: T;
-    data: ModalRegistry[T]["data"];
-    resolve: (result: ModalRegistry[T]["result"]) => void;
+    type: string;
+    data: any;
+    resolve: (result: any) => void;
     reject: (reason?: any) => void;
     options?: ModalBaseConfig;
 }
-export interface ModalOpenResult<T extends keyof ModalRegistry> {
+export interface ModalOpenResult {
     id: string;
-    promise: Promise<ModalRegistry[T]["result"]>;
-    resolve: (result: ModalRegistry[T]["result"]) => void;
+    promise: Promise<any>;
+    resolve: (result: any) => void;
     reject: (reason?: any) => void;
 }
 export interface ModalContextValue {
     modals: ModalInstance[];
-    openModal: <T extends keyof ModalRegistry>(type: T, data: ModalRegistry[T]["data"], options?: ModalBaseConfig) => ModalOpenResult<T>;
+    openModal: (type: string, // Changed from keyof ModalRegistry
+    data: any, // Changed from ModalRegistry[T]["data"]
+    options?: ModalBaseConfig) => ModalOpenResult;
     closeModal: (id: string) => void;
     getModalById: (id: string) => ModalInstance | undefined;
 }

package/dist/types/utilities/enhancedTimeUtil.d.ts

@@ -0,0 +1,105 @@
+import { TimeUtil } from './timeUtil';
+import { DateRange } from 'react-day-picker';
+export type DateFormatType = 'iso' | 'timestamp-ms' | 'timestamp-s' | 'date-object' | 'date-only' | 'datetime-local' | 'formatted' | 'luxon-iso' | 'custom';
+export type SupportedLocale = 'en-US' | 'en-GB' | 'en-CA' | 'en-AU' | 'fr-FR' | 'fr-CA' | 'de-DE' | 'de-AT' | 'de-CH' | 'es-ES' | 'es-MX' | 'es-AR' | 'it-IT' | 'pt-BR' | 'pt-PT' | 'ja-JP' | 'ko-KR' | 'zh-CN' | 'zh-TW' | 'ru-RU' | 'ar-SA' | 'hi-IN' | string;
+export type SupportedTimeZone = 'UTC' | 'GMT' | 'America/New_York' | 'America/Chicago' | 'America/Denver' | 'America/Los_Angeles' | 'America/Toronto' | 'America/Mexico_City' | 'America/Sao_Paulo' | 'Europe/London' | 'Europe/Paris' | 'Europe/Berlin' | 'Europe/Rome' | 'Asia/Tokyo' | 'Asia/Seoul' | 'Asia/Shanghai' | 'Asia/Hong_Kong' | 'Australia/Sydney' | 'Australia/Melbourne' | 'Pacific/Auckland' | string;
+export interface DateFormatOptions {
+    locale?: SupportedLocale;
+    timeZone?: SupportedTimeZone;
+    customFormat?: string;
+    includeTime?: boolean;
+}
+export type DateFormatTypeMap = {
+    'iso': string;
+    'timestamp-ms': number;
+    'timestamp-s': number;
+    'date-object': Date;
+    'date-only': string;
+    'datetime-local': string;
+    'formatted': string;
+    'luxon-iso': string;
+    'custom': string;
+};
+export interface DateFormatConfig<TInput extends DateFormatType = 'date-object', TOutput extends DateFormatType = 'date-object'> {
+    input: TInput;
+    output: TOutput;
+    display?: DateFormatType;
+    options?: DateFormatOptions;
+}
+export declare const DateFormatPresets: {
+    readonly timestamp: {
+        readonly input: "timestamp-ms";
+        readonly output: "timestamp-ms";
+    };
+    readonly apiStandard: {
+        readonly input: "iso";
+        readonly output: "iso";
+    };
+    readonly timeUtilCompatible: {
+        readonly input: "luxon-iso";
+        readonly output: "luxon-iso";
+    };
+    readonly htmlDate: {
+        readonly input: "date-only";
+        readonly output: "date-only";
+    };
+    readonly international: (locale?: SupportedLocale, timeZone?: SupportedTimeZone) => {
+        input: "iso";
+        output: "iso";
+        options: {
+            locale: string;
+            timeZone: string;
+        };
+    };
+};
+export type DateRangeFormatTypeMap = {
+    'iso': {
+        from?: string;
+        to?: string;
+    };
+    'timestamp-ms': {
+        from?: number;
+        to?: number;
+    };
+    'timestamp-s': {
+        from?: number;
+        to?: number;
+    };
+    'date-object': DateRange;
+    'date-only': {
+        from?: string;
+        to?: string;
+    };
+    'datetime-local': {
+        from?: string;
+        to?: string;
+    };
+    'formatted': {
+        from?: string;
+        to?: string;
+    };
+    'luxon-iso': {
+        from?: string;
+        to?: string;
+    };
+    'custom': {
+        from?: string;
+        to?: string;
+    };
+};
+export declare class EnhancedTimeUtil extends TimeUtil {
+    static parseInput(value: unknown, inputFormat: DateFormatType): Date | undefined;
+    static formatOutput(date: Date | undefined, outputFormat: DateFormatType, options?: DateFormatOptions): unknown;
+    static formatForDisplay(date: Date | undefined, displayFormat?: DateFormatType, options?: DateFormatOptions): string;
+    static parseRangeInput(value: unknown, inputFormat: DateFormatType): DateRange | undefined;
+    static formatRangeOutput(range: DateRange | undefined, outputFormat: DateFormatType, options?: DateFormatOptions): unknown;
+    static createFormatter<TInput extends DateFormatType = 'date-object', TOutput extends DateFormatType = 'date-object'>(config: DateFormatConfig<TInput, TOutput>): {
+        parseInput: (value: unknown) => Date | undefined;
+        formatOutput: (date: Date | undefined) => unknown;
+        formatForDisplay: (date: Date | undefined) => string;
+        parseRangeInput: (value: unknown) => DateRange | undefined;
+        formatRangeOutput: (range: DateRange | undefined) => unknown;
+        config: DateFormatConfig<TInput, TOutput>;
+    };
+    private static formatForLocale;
+}

package/dist/types/utilities/factory/modalFactory.d.ts

@@ -1,7 +1,55 @@
-import { ModalEnum } from '../enums/modalEnum';
-import { ModalRegistry } from '../types/modalTypes';
-export declare const modalFactory: {
-    [K in ModalEnum]: React.FC<ModalRegistry[K]["data"]>;
-};
-export declare const getModalComponent: (modalType: string) => import('react').ComponentType<any> | undefined;
-export declare const getModalDefaultConfig: (modalType: string) => import('../types/modalTypes').ModalBaseConfig | undefined;
+import { default as React } from 'react';
+import { ModalBaseConfig } from '../types/modalTypes';
+interface ModalRegistration<TData = any, TResult = any> {
+    key: string;
+    component: React.ComponentType<TData>;
+    defaultConfig: ModalBaseConfig;
+    containerClassName?: string;
+    containerStyle?: React.CSSProperties;
+    theme?: 'default' | 'minimal' | 'glass' | 'elevated';
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    cssProps?: Record<string, string>;
+    __dataType?: TData;
+    __resultType?: TResult;
+}
+declare class EnhancedModalFactory {
+    private registry;
+    private typeRegistry;
+    register<TData, TResult = void>(config: {
+        key: string;
+        component: React.ComponentType<TData>;
+        defaultConfig?: ModalBaseConfig;
+        containerClassName?: string;
+        containerStyle?: React.CSSProperties;
+        theme?: 'default' | 'minimal' | 'glass' | 'elevated';
+        size?: 'sm' | 'md' | 'lg' | 'xl';
+        cssProps?: Record<string, string>;
+    }): void;
+    get(key: string): ModalRegistration | undefined;
+    getComponent(key: string): React.ComponentType<any> | null;
+    getDefaultConfig(key: string): ModalBaseConfig;
+    getModalConfig(key: string): Omit<ModalRegistration, 'component' | '__dataType' | '__resultType'>;
+    getAllRegistered(): string[];
+    getTypeInfo(key: string): {
+        dataType: any;
+        resultType: any;
+    } | undefined;
+    validateRegistrations(): void;
+    clear(): void;
+    unregister(key: string): boolean;
+}
+export declare const modalFactory: EnhancedModalFactory;
+export declare function registerModal<TData, TResult = void>(config: {
+    key: string;
+    component: React.ComponentType<TData>;
+    defaultConfig?: ModalBaseConfig;
+    containerClassName?: string;
+    containerStyle?: React.CSSProperties;
+    theme?: 'default' | 'minimal' | 'glass' | 'elevated';
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    cssProps?: Record<string, string>;
+}): void;
+export declare function getModalConfig(key: string): ModalBaseConfig;
+export declare function getModalComponent(key: string): React.ComponentType<any> | null;
+export { modalFactory as default };
+export declare const getModalDefaultConfig: typeof getModalConfig;

package/dist/types/utilities/helpers/bulkUploadFileGenerator.d.ts

@@ -0,0 +1,22 @@
+import { BulkUploadConfig } from './bulkUploadFileParser';
+export declare class BulkUploadTemplateGenerator {
+    static generateExcelTemplate<T>(config: BulkUploadConfig<T>): Blob;
+    static generateCSVTemplate<T>(config: BulkUploadConfig<T>): Blob;
+}
+export declare const ValidationUtils: {
+    email: (value: string) => string | null;
+    required: (value: string) => string | null;
+    numeric: (value: string) => string | null;
+    minLength: (min: number) => (value: string) => string | null;
+    maxLength: (max: number) => (value: string) => string | null;
+    pattern: (regex: RegExp, message: string) => (value: string) => string | null;
+};
+export declare const TransformUtils: {
+    toNumber: (value: string) => number;
+    toDate: (value: string) => Date;
+    toUpperCase: (value: string) => string;
+    toLowerCase: (value: string) => string;
+    trimSpaces: (value: string) => string;
+    removeSpecialChars: (value: string) => string;
+    formatCurrency: (value: string) => number;
+};

package/dist/types/utilities/helpers/bulkUploadFileParser.d.ts

@@ -0,0 +1,50 @@
+export interface BulkUploadColumn<T = any> {
+    key: keyof T;
+    label?: string;
+    required?: boolean;
+    validator?: (value: string, row: Record<string, string>, index: number) => string | null;
+    transformer?: (value: string) => T[keyof T];
+    aliases?: string[];
+}
+export interface BulkUploadConfig<T = any> {
+    columns: BulkUploadColumn<T>[];
+    maxFileSize?: number;
+    maxRows?: number;
+    allowedFileTypes?: string[];
+    templateFileName?: string;
+    strictColumnMapping?: boolean;
+}
+export interface ParsedBulkData<T = any> {
+    data: T[];
+    errors: BulkUploadError[];
+    warnings: BulkUploadWarning[];
+    summary: {
+        totalRows: number;
+        validRows: number;
+        errorRows: number;
+    };
+}
+export interface BulkUploadError {
+    row: number;
+    column?: string;
+    message: string;
+    type: 'validation' | 'parsing' | 'structure';
+}
+export interface BulkUploadWarning {
+    row: number;
+    column?: string;
+    message: string;
+}
+export declare class BulkUploadFileParser {
+    private static readonly CHUNK_SIZE;
+    static parseFile<T>(file: File, config: BulkUploadConfig<T>): Promise<ParsedBulkData<T>>;
+    private static validateFile;
+    private static parseCSV;
+    private static processCSVText;
+    private static parseCSVRow;
+    private static parseExcel;
+    private static processExcelData;
+    private static createColumnMapping;
+    private static normalizeHeader;
+    private static processDataRow;
+}

package/dist/types/utilities/helpers/index.d.ts

@@ -1,4 +1,6 @@
 /**
  * Auto-generated barrel for src/utilities/helpers
  */
+export * from './bulkUploadFileGenerator';
+export * from './bulkUploadFileParser';
 export * from './iconRenderer';

package/dist/types/utilities/hooks/index.d.ts

@@ -1,6 +1,8 @@
 /**
  * Auto-generated barrel for src/utilities/hooks
  */
+export { default as useBulkUpload } from './useBulkUpload';
+export * from './useBulkUpload';
 export { default as useFetchOnStageChange } from './useFetchOnStageChange';
 export * from './useFetchOnStageChange';
 export { default as useFirstRender } from './useFirstRender';

package/dist/types/utilities/hooks/useBulkUpload.d.ts

@@ -0,0 +1,39 @@
+import { BulkUploadConfig, BulkUploadError, BulkUploadWarning, ParsedBulkData } from '../helpers/bulkUploadFileParser';
+export interface UseBulkUploadOptions<T> {
+    config: BulkUploadConfig<T>;
+    onSuccess?: (data: T[], additionalData?: Record<string, any>) => Promise<void>;
+    onError?: (errors: BulkUploadError[]) => void;
+    onProgress?: (progress: {
+        loaded: number;
+        total: number;
+    }) => void;
+}
+export interface BulkUploadState<T> {
+    file: File | null;
+    parsedData: ParsedBulkData<T> | null;
+    isProcessing: boolean;
+    isUploading: boolean;
+    progress: number;
+    errors: BulkUploadError[];
+    warnings: BulkUploadWarning[];
+}
+export declare const useBulkUpload: <T>({ config, onSuccess, onError, }: UseBulkUploadOptions<T>) => {
+    setFile: (file: File | null) => void;
+    parseFile: () => Promise<ParsedBulkData<T> | undefined>;
+    submitData: (additionalData?: Record<string, any>) => Promise<void>;
+    downloadTemplate: (format?: "excel" | "csv") => void;
+    reset: () => void;
+    abort: () => void;
+    hasValidData: boolean | 0 | undefined;
+    hasErrors: boolean;
+    hasWarnings: boolean;
+    canSubmit: boolean | 0 | undefined;
+    file: File | null;
+    parsedData: ParsedBulkData<T> | null;
+    isProcessing: boolean;
+    isUploading: boolean;
+    progress: number;
+    errors: BulkUploadError[];
+    warnings: BulkUploadWarning[];
+};
+export default useBulkUpload;

package/dist/types/utilities/hooks/useModal.d.ts

@@ -1,18 +1,18 @@
-import { ModalBaseConfig, ModalRegistry } from '../types/modalTypes';
-export declare const useModal: <T extends keyof ModalRegistry>(type: T) => {
-    open: (data: ModalRegistry[T]["data"], options?: ModalBaseConfig) => Promise<ModalRegistry[T]["result"]>;
-    close: (result?: ModalRegistry[T]["result"]) => void;
-    submit: (result?: ModalRegistry[T]["result"]) => void;
+import { ModalBaseConfig } from '../types/modalTypes';
+export declare const useModal: <T extends string>(modalKey: T) => {
+    open: (data: any, options?: ModalBaseConfig) => Promise<any>;
+    close: (result?: any) => void;
+    submit: (result?: any) => void;
     cancel: (reason?: any) => void;
-    closeAll: (result?: ModalRegistry[T]["result"]) => void;
+    closeAll: (result?: any) => void;
     isOpen: boolean;
-    instances: import('..').ModalInstance<keyof ModalRegistry>[];
-    latestInstance: import('..').ModalInstance<keyof ModalRegistry>;
-    focusedInstance: import('..').ModalInstance<keyof ModalRegistry> | undefined;
-    activeInstance: import('..').ModalInstance<keyof ModalRegistry>;
+    instances: import('..').ModalInstance[];
+    latestInstance: import('..').ModalInstance;
+    focusedInstance: import('..').ModalInstance | undefined;
+    activeInstance: import('..').ModalInstance;
     count: number;
     focus: () => void;
-    data: import('../..').ConfirmationModalLayoutProps | import('../..').NotificationModalLayoutProps;
+    data: any;
     id: string;
 };
 export default useModal;

package/dist/types/utilities/hooks/useModalRegistration.d.ts

@@ -1,7 +1,2 @@
-import { ModalBaseConfig, ModalRegistry } from '..';
-export interface ModalRegistrationConfig<TKey extends keyof ModalRegistry> {
-    key: TKey;
-    component: React.ComponentType<ModalRegistry[TKey]['data']>;
-    defaultConfig?: ModalBaseConfig;
-}
-export default function useModalRegistration<TKey extends keyof ModalRegistry>(config: ModalRegistrationConfig<TKey>): void;
+import { ModalRegistrationConfig } from '..';
+export default function useModalRegistration<TKey>(config: ModalRegistrationConfig<TKey>): void;

package/dist/types/utilities/hooks/useModalRegistrations.d.ts

@@ -1,3 +1,2 @@
-import { ModalRegistrationConfig } from './useModalRegistration';
-import { ModalRegistry } from '..';
+import { ModalRegistrationConfig, ModalRegistry } from '..';
 export default function useModalRegistrations(configs: ModalRegistrationConfig<keyof ModalRegistry>[]): void;

package/dist/types/utilities/hooks/useNotification.d.ts

@@ -9,13 +9,13 @@ export interface NotificationOptions {
     showCloseButton?: boolean;
 }
 export declare const useNotification: (defaultPosition?: NotificationPosition) => {
-    show: (message: string, options?: NotificationOptions) => Promise<void>;
-    success: (message: string, options?: Omit<NotificationOptions, "variant">) => Promise<void>;
-    error: (message: string, options?: Omit<NotificationOptions, "variant">) => Promise<void>;
-    warning: (message: string, options?: Omit<NotificationOptions, "variant">) => Promise<void>;
-    info: (message: string, options?: Omit<NotificationOptions, "variant">) => Promise<void>;
-    close: (result?: void | undefined) => void;
-    closeAll: (result?: void | undefined) => void;
+    show: (message: string, options?: NotificationOptions) => Promise<any>;
+    success: (message: string, options?: Omit<NotificationOptions, "variant">) => Promise<any>;
+    error: (message: string, options?: Omit<NotificationOptions, "variant">) => Promise<any>;
+    warning: (message: string, options?: Omit<NotificationOptions, "variant">) => Promise<any>;
+    info: (message: string, options?: Omit<NotificationOptions, "variant">) => Promise<any>;
+    close: (result?: any) => void;
+    closeAll: (result?: any) => void;
     isOpen: boolean;
     count: number;
 };

package/dist/types/utilities/index.d.ts

@@ -2,6 +2,7 @@
  * Auto-generated barrel for src/utilities
  */
 export * from './baseUtil';
+export * from './enhancedTimeUtil';
 export * from './formUtil';
 export * from './modalRegistrationUtil';
 export * from './modalUtil';

package/dist/types/utilities/modalUtil.d.ts

@@ -1,5 +1,5 @@
 import { ModalContextValue, ModalInstance } from './context/modalContext';
-import { ModalBaseConfig, ModalRegistry } from './types/modalTypes';
+import { ModalBaseConfig } from './types/modalTypes';
 export declare class ModalUtil {
     private static instance;
     private contextValue;
@@ -7,6 +7,9 @@ export declare class ModalUtil {
     private pendingModals;
     private autoCloseTimers;
     private componentCleanupCallbacks;
+    private cleanupInterval;
+    private cleaningUp;
+    constructor();
     static getInstance(): ModalUtil;
     setContext(contextValue: ModalContextValue): void;
     setFocusedModal(id: string): void;
@@ -16,18 +19,19 @@ export declare class ModalUtil {
     isModalFocused(id: string): boolean;
     registerComponentCleanup(componentId: string, cleanup: () => void): void;
     unregisterComponentCleanup(componentId: string): void;
+    open<TData, TResult>(modalKey: string, data: TData, options?: ModalBaseConfig): Promise<TResult>;
+    close(id: string, result?: any): void;
+    closeAllOfType(type: string, result?: any): void;
+    closeAll(): void;
     closeFocused(result?: any): void;
     submitFocused(result?: any): void;
     cancelFocused(reason?: any): void;
-    open<T extends keyof ModalRegistry>(type: T, data: ModalRegistry[T]["data"], options?: ModalBaseConfig): Promise<ModalRegistry[T]["result"]>;
-    close(id: string, result?: any): void;
-    closeAllOfType<T extends keyof ModalRegistry>(type: T, result?: ModalRegistry[T]["result"]): void;
-    closeAll(): void;
-    destroy(): void;
-    getModalsByType<T extends keyof ModalRegistry>(type: T): ModalInstance[];
-    isTypeOpen<T extends keyof ModalRegistry>(type: T): boolean;
+    getModalsByType(type: string): ModalInstance[];
+    isTypeOpen(type: string): boolean;
     getModalConfig(): Required<ModalBaseConfig>;
-    getModalDefaultConfig<T extends keyof ModalRegistry>(type: T): ModalBaseConfig | undefined;
-    private cleanupModal;
+    destroy(): void;
+    __resetForTesting(): void;
+    private performMaintenanceCleanup;
+    private safeCleanupModal;
 }
 export declare const modalUtil: ModalUtil;

package/dist/types/utilities/timeUtil.d.ts

@@ -35,4 +35,6 @@ export declare class TimeUtil {
         fullFormattedDateTime: string;
         isDateTimeValid: boolean;
     };
+    static formatDate: (date: Date, format: string | ((date: Date) => string)) => string;
+    static parseDate: (value: unknown, inputFormat?: string) => Date | undefined;
 }