qucoon-components 0.0.1

package/dist/types/configs/themeConfig.d.ts

@@ -0,0 +1,97 @@
+import { default as React } from 'react';
+export type ThemeConfigProps = {
+    color: {
+        white: string;
+        black: string;
+        color1: string;
+        color2: string;
+        color3: string;
+        color4: string;
+        color5: string;
+        color6: string;
+        color7: string;
+        color8: string;
+        color9: string;
+        color10: string;
+        color11: string;
+        color12: string;
+        color13: string;
+    };
+    fontWeight: {
+        regular: number;
+        medium: number;
+        semibold: number;
+        bold: number;
+    };
+    fontFamily: {
+        primary: string;
+        secondary: string;
+        tertiary: string;
+    };
+    fontSize: {
+        xs?: string;
+        sm?: string;
+        base?: string;
+        lg?: string;
+        xl?: string;
+        "2xl"?: string;
+        "3xl"?: string;
+        "4xl"?: string;
+        "5xl"?: string;
+        "6xl"?: string;
+    };
+};
+export declare const themeConfig: {
+    color: {
+        white: string;
+        black: string;
+        color1: string;
+        color2: string;
+        color3: string;
+        color4: string;
+        color5: string;
+        color6: string;
+        color7: string;
+        color8: string;
+        color9: string;
+        color10: string;
+        color11: string;
+        color12: string;
+        color13: string;
+    };
+    fontWeight: {
+        regular: number;
+        medium: number;
+        semibold: number;
+        bold: number;
+    };
+    fontFamily: {
+        primary: string;
+        secondary: string;
+        tertiary: string;
+    };
+    fontSize: {
+        xs: string;
+        sm: string;
+        base: string;
+        lg: string;
+        xl: string;
+        "2xl": string;
+        "3xl": string;
+        "4xl": string;
+        "5xl": string;
+        "6xl": string;
+    };
+};
+export type Theme = typeof themeConfig;
+export declare const ThemeContext: React.Context<{
+    theme: Theme;
+    setTheme: (theme: Theme) => void;
+}>;
+export default function ThemeProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const useTheme: () => {
+    theme: Theme;
+    setTheme: (theme: Theme) => void;
+};

package/dist/types/importLcDetailsSection.d.ts

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

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './components';
+export * from './utilities';

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

@@ -0,0 +1,2 @@
+export declare const rootReducer: import('redux').Reducer<{}, never, Partial<{}>>;
+export type RootState = ReturnType<typeof rootReducer>;

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

@@ -0,0 +1,3 @@
+export declare class BaseUtil {
+    static logger(...logInfo: any): void;
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Auto-generated barrel for src/utilities/constants
+ */
+export * from './routeConstant';

package/dist/types/utilities/constants/routeConstant.d.ts

@@ -0,0 +1,33 @@
+export declare const RouteConstant: {
+    auth: {
+        login: {
+            name: string;
+            path: string;
+        };
+        register: {
+            name: string;
+            path: string;
+        };
+        getStarted: {
+            path: string;
+            name: string;
+            moduleName: string;
+        };
+    };
+    dashboard: {
+        getStarted: {
+            name: string;
+            path: string;
+        };
+        createDummy: {
+            path: string;
+            name: string;
+            moduleName: string;
+        };
+        allDummies: {
+            path: string;
+            name: string;
+            moduleName: string;
+        };
+    };
+};

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

@@ -0,0 +1,10 @@
+import { ChangeEventHandler } from 'react';
+interface CheckboxGroupContextType {
+    name: string;
+    value: string[];
+    onChange: ChangeEventHandler<HTMLInputElement>;
+    disabled?: boolean;
+}
+export declare const CheckboxGroupContext: import('react').Context<CheckboxGroupContextType | null>;
+export declare const useCheckboxGroupContext: () => CheckboxGroupContextType | null;
+export {};

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

@@ -0,0 +1,6 @@
+/**
+ * Auto-generated barrel for src/utilities/context
+ */
+export * from './checkboxContext';
+export * from './modalContext';
+export * from './radioContext';

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

@@ -0,0 +1,25 @@
+import { ReactNode } from 'react';
+import { ModalBaseConfig, ModalRegistry } from '../types/modalTypes';
+export interface ModalInstance<T extends keyof ModalRegistry = keyof ModalRegistry> {
+    id: string;
+    type: T;
+    data: ModalRegistry[T]["data"];
+    resolve: (result: ModalRegistry[T]["result"]) => void;
+    reject: (reason?: any) => void;
+    options?: ModalBaseConfig;
+}
+export interface ModalOpenResult<T extends keyof ModalRegistry> {
+    id: string;
+    promise: Promise<ModalRegistry[T]["result"]>;
+    resolve: (result: ModalRegistry[T]["result"]) => 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>;
+    closeModal: (id: string) => void;
+    getModalById: (id: string) => ModalInstance | undefined;
+}
+export declare const ModalProvider: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,9 @@
+import { ChangeEventHandler } from 'react';
+export type RadioGroupContextType = {
+    name: string;
+    value: string | number | null;
+    onChange: ChangeEventHandler<HTMLInputElement>;
+    disabled?: boolean;
+};
+export declare const RadioGroupContext: import('react').Context<RadioGroupContextType | null>;
+export declare const useRadioGroupContext: () => RadioGroupContextType | null;

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

@@ -0,0 +1,4 @@
+/**
+ * Auto-generated barrel for src/utilities/data
+ */
+export * from './sidebarData';

package/dist/types/utilities/data/sidebarData.d.ts

@@ -0,0 +1,3 @@
+import { BaseSidebarModuleConfig } from '../../components';
+export declare const sidebarItemsConfig: BaseSidebarModuleConfig[];
+export declare const sidebarBottomMenuConfig: BaseSidebarModuleConfig[];

package/dist/types/utilities/enums/baseEnum.d.ts

@@ -0,0 +1,5 @@
+export declare enum BaseEnum {
+    RESPONSE_CODE_SUCCESS = "00",
+    RESPONSE_CODE_ERROR_BAD_REQUEST = "106",
+    RESPONSE_CODE_UNAUTHORIZED = "22"
+}

package/dist/types/utilities/enums/baseTableIdEnum.d.ts

@@ -0,0 +1,10 @@
+export declare enum BaseTableIdEnum {
+    DASHBOARD_TRANSACTIONS_TABLE = "DASHBOARD_TRANSACTIONS_TABLE",
+    DASHBOARD_TRANSFERS_TABLE = "DASHBOARD_TRANSFERS_TABLE",
+    DASHBOARD_BULK_TRANSFERS_TABLE = "DASHBOARD_BULK_TRANSFERS_TABLE",
+    DASHBOARD_BULK_TRANSFER_BATCH_ENTRIES_TABLE = "DASHBOARD_BULK_TRANSFER_BATCH_ENTRIES_TABLE",
+    DASHBOARD_SETTINGS_TEAM_TABLE = "DASHBOARD_SETTINGS_TEAM_TABLE",
+    DASHBOARD_AUDIT_LOGS_TABLE = "DASHBOARD_AUDIT_LOGS_TABLE",
+    DASHBOARD_PENDING_INVITATIONS_TABLE = "DASHBOARD_PENDING_INVITATIONS_TABLE",
+    DASHBOARD_DUMMY_TABLE = "DASHBOARD_DUMMY_TABLE"
+}

package/dist/types/utilities/enums/documentStatusEnum.d.ts

@@ -0,0 +1,5 @@
+export declare enum DocumentStatusEnum {
+    REJECTED = "REJECTED",
+    PENDING = "PENDING",
+    APPROVED = "APPROVED"
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Auto-generated barrel for src/utilities/enums
+ */
+export * from './baseEnum';
+export * from './baseTableIdEnum';
+export * from './documentStatusEnum';
+export * from './modalEnum';
+export * from './popupEnum';

package/dist/types/utilities/enums/modalEnum.d.ts

@@ -0,0 +1,4 @@
+export declare enum ModalEnum {
+    ConfirmationModal = "ConfirmationModal",
+    NotificationModal = "NotificationModal"
+}

package/dist/types/utilities/enums/popupEnum.d.ts

@@ -0,0 +1,3 @@
+export declare enum PopupEnum {
+    ADD_CUSTOM_ROLE = "ADD_CUSTOM_ROLE"
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Auto-generated barrel for src/utilities/factory
+ */
+export * from './modalFactory';

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

@@ -0,0 +1,7 @@
+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;

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

@@ -0,0 +1,17 @@
+import { FormikValues } from 'formik';
+import { Formik } from './types/formTypes';
+export declare class FormUtil {
+    static getFileSizeInText: (sizeInBytes: number) => string;
+    static touchAllFields: <T extends FormikValues>(formik: Formik<T>) => void;
+    static isErrorInForm: <T extends FormikValues>(formik: Formik<T>) => Promise<boolean>;
+    static handleNonNegativeInput(event: React.ChangeEvent<HTMLInputElement>, formik: any): void;
+    static handlePercentageInput<T extends FormikValues>(event: React.ChangeEvent<HTMLInputElement>, formik: Formik<T>): void;
+    static formatDisplayPercentage: (value: number | string) => string;
+    static touchFieldsForStep: <T extends FormikValues>(formik: Formik<T>, fields: string[]) => void;
+    static isErrorInFormForStep: <T extends FormikValues>(formik: Formik<T>, fields: string[]) => Promise<boolean>;
+    static cleanInputToAcceptOnlyNumberText: (inputValue: string) => string;
+    static formatNumberWithCommas: (number: string | number) => string;
+    static formatDecimalNumberWithCommas: (number: string | number, decimalPlaces: number) => string;
+    static parseFormattedNumber(value: string): number;
+    static convertObjFieldsFromEmptyStringToNull: <T extends Record<string, any>>(obj: T) => { [K in keyof T]: T[K] | null; };
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Auto-generated barrel for src/utilities/hooks
+ */
+export { default as useFetchOnStageChange } from './useFetchOnStageChange';
+export * from './useFetchOnStageChange';
+export { default as useFirstRender } from './useFirstRender';
+export * from './useFirstRender';
+export { default as useModal } from './useModal';
+export * from './useModal';
+export { default as useModalContext } from './useModalContext';
+export * from './useModalContext';
+export { default as useModalRegistration } from './useModalRegistration';
+export * from './useModalRegistration';
+export { default as useModalRegistrations } from './useModalRegistrations';
+export * from './useModalRegistrations';
+export { default as useNotification } from './useNotification';
+export * from './useNotification';
+export { default as useOnClickOutside } from './useOnClickOutside';
+export * from './useOnClickOutside';
+export { default as usePopup } from './usePopup';
+export * from './usePopup';
+export { default as useTableDataSync } from './useTableDataSync';
+export * from './useTableDataSync';

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

@@ -0,0 +1,2 @@
+declare const useFetchOnStageChange: () => void;
+export default useFetchOnStageChange;

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

@@ -0,0 +1,2 @@
+export declare const useFirstRender: () => boolean;
+export default useFirstRender;

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

@@ -0,0 +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;
+    cancel: (reason?: any) => void;
+    closeAll: (result?: ModalRegistry[T]["result"]) => void;
+    isOpen: boolean;
+    instances: import('..').ModalInstance<keyof ModalRegistry>[];
+    latestInstance: import('..').ModalInstance<keyof ModalRegistry>;
+    focusedInstance: import('..').ModalInstance<keyof ModalRegistry> | undefined;
+    activeInstance: import('..').ModalInstance<keyof ModalRegistry>;
+    count: number;
+    focus: () => void;
+    data: import('../..').NotificationModalLayoutProps | import('../..').ConfirmationModalLayoutProps;
+    id: string;
+};
+export default useModal;

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

@@ -0,0 +1,4 @@
+import { ModalContextValue } from '../context/modalContext';
+export declare const ModalContext: import('react').Context<ModalContextValue | undefined>;
+export declare const useModalContext: () => ModalContextValue;
+export default useModalContext;

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

@@ -0,0 +1,7 @@
+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;

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

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

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

@@ -0,0 +1,22 @@
+import { NotificationModalLayoutProps } from '../../components';
+export type NotificationVariant = NotificationModalLayoutProps["variant"];
+export type NotificationPosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center' | 'bottom-center';
+export interface NotificationOptions {
+    variant?: NotificationVariant;
+    position?: NotificationPosition;
+    autoClose?: boolean | number;
+    persistent?: boolean;
+    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;
+    isOpen: boolean;
+    count: number;
+};
+export default useNotification;

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

@@ -0,0 +1,2 @@
+declare function useOnClickOutside(ref: React.RefObject<HTMLElement>, handler: () => void): void;
+export default useOnClickOutside;

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

@@ -0,0 +1,24 @@
+import { Boundary, Placement } from '@popperjs/core';
+export interface UsePopupOptions {
+    placement?: Placement;
+    strategy?: 'absolute' | 'fixed';
+    offset?: [number, number];
+    closeOnOutsideClick?: boolean;
+    closeOnEscape?: boolean;
+    boundary?: Boundary;
+    flipFallbackPlacements?: Placement[];
+}
+export interface UsePopupReturn {
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    toggle: () => void;
+    referenceElement: HTMLElement | null;
+    setReferenceElement: (el: HTMLElement | null) => void;
+    popperElement: HTMLElement | null;
+    setPopperElement: (el: HTMLElement | null) => void;
+    styles: Record<string, React.CSSProperties>;
+    attributes: Record<string, Record<string, string> | undefined>;
+    containerRef: React.RefObject<HTMLDivElement>;
+}
+export declare const usePopup: ({ placement, strategy, offset, closeOnOutsideClick, closeOnEscape, boundary, flipFallbackPlacements }?: UsePopupOptions) => UsePopupReturn;
+export default usePopup;

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

@@ -0,0 +1,23 @@
+/**
+ * Hook to manage table data syncing with external source and internal state.
+ * Supports internal and external updates, pagination tracking, and loading state.
+ *
+ * @param items - external data array (optional)
+ * @param refreshPage - async function to refresh page data
+ * @param itemIdKey - key to uniquely identify items in data array
+ * @param pageSizeDefault - default page size for pagination (default 10)
+ * @returns table data and control functions
+ */
+export declare function useTableDataSync<T>(items: T[] | undefined, refreshPage?: (pageNo: number, pageSize: number) => Promise<{
+    responseCode: string;
+    data: T[];
+}>, itemIdKey?: string, pageSizeDefault?: number): {
+    rowData: T[];
+    loading: boolean;
+    pageNo: number;
+    setPageNo: import('react').Dispatch<import('react').SetStateAction<number>>;
+    maxPage: number;
+    setMaxPage: import('react').Dispatch<import('react').SetStateAction<number>>;
+    refreshData: (page?: number, pageSize?: number) => Promise<void>;
+};
+export default useTableDataSync;

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

@@ -0,0 +1,18 @@
+/**
+ * Auto-generated barrel for src/utilities
+ */
+export * from './baseUtil';
+export * from './formUtil';
+export * from './modalRegistrationUtil';
+export * from './modalUtil';
+export * from './routerUtil';
+export * from './stringUtil';
+export * from './timeUtil';
+export * from './constants';
+export * from './context';
+export * from './data';
+export * from './enums';
+export * from './factory';
+export * from './hooks';
+export * from './theme';
+export * from './types';

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

@@ -0,0 +1,18 @@
+import { ModalBaseConfig, ModalRegistry } from './types';
+export interface RegisteredModal {
+    component: React.ComponentType<any>;
+    defaultConfig?: ModalBaseConfig;
+}
+declare class ModalRegistrationManager {
+    private static instance;
+    private modalComponents;
+    static getInstance(): ModalRegistrationManager;
+    register<TKey extends keyof ModalRegistry>(key: TKey, component: React.ComponentType<ModalRegistry[TKey]['data']>, defaultConfig?: ModalBaseConfig): void;
+    getComponent(key: string): React.ComponentType<any> | undefined;
+    getDefaultConfig(key: string): ModalBaseConfig | undefined;
+    getAllRegistered(): [string, RegisteredModal][];
+    unregister(key: string): void;
+    clear(): void;
+}
+export declare const modalRegistration: ModalRegistrationManager;
+export {};

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

@@ -0,0 +1,33 @@
+import { ModalContextValue, ModalInstance } from './context/modalContext';
+import { ModalBaseConfig, ModalRegistry } from './types/modalTypes';
+export declare class ModalUtil {
+    private static instance;
+    private contextValue;
+    private focusedModalId;
+    private pendingModals;
+    private autoCloseTimers;
+    private componentCleanupCallbacks;
+    static getInstance(): ModalUtil;
+    setContext(contextValue: ModalContextValue): void;
+    setFocusedModal(id: string): void;
+    getFocusedModal(): ModalInstance | null;
+    getPendingModals(): Map<string, ModalInstance>;
+    getTopmostModal(): ModalInstance | null;
+    isModalFocused(id: string): boolean;
+    registerComponentCleanup(componentId: string, cleanup: () => void): void;
+    unregisterComponentCleanup(componentId: string): 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;
+    getModalConfig(): Required<ModalBaseConfig>;
+    getModalDefaultConfig<T extends keyof ModalRegistry>(type: T): ModalBaseConfig | undefined;
+    private cleanupModal;
+}
+export declare const modalUtil: ModalUtil;

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

@@ -0,0 +1,13 @@
+import { NavigateFunction } from 'react-router-dom';
+import { NavigateOptions } from 'react-router/dist/lib/context';
+declare class RouterUtil {
+    private static navigateFn;
+    static setNavigateFn(navigateFn: NavigateFunction): void;
+    static goBack(): void;
+    static navigate(path: string, options?: NavigateOptions & {
+        paramsToReplaceWithValue?: {
+            [key: string]: string;
+        }[];
+    }): void;
+}
+export default RouterUtil;

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

@@ -0,0 +1,17 @@
+export declare class StringUtil {
+    static toTitleCase(sentence: string): string;
+    static convertToSentenceCase(input: string): string;
+    static spaceAfterEveryNletter(input: string, n?: number): string;
+    static abbreviateToTwoCharacter(word: string): string;
+    static formatCurrency(amount: string, currency?: string): string;
+    static removeNonDigits(input: string): string;
+    static insertSpaces(input: string): string;
+    static formatPhoneNumber(input: string): string;
+    static formatValue(value: string): string;
+    static handleCurrencyFormatter: (amount: string) => string;
+    static formatAmount: (amount: string) => string;
+    static countOccurrences(mainStr: string, subStr: string): number;
+    static fromStringToNumber: (stringAmount: string) => number;
+    static isStringNullOrEmpty: (string: string | null) => boolean;
+    static shortenWord(word: string, replace?: string, length?: number): string;
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Auto-generated barrel for src/utilities/theme
+ */
+export * from './themeProvider';

package/dist/types/utilities/theme/themeProvider.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { DesignTokens } from '../types/themeTypes';
+export declare const ThemeContext: React.Context<DesignTokens>;
+export declare const ThemeProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const useTheme: () => DesignTokens;

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

@@ -0,0 +1,38 @@
+import { DateTimeFormatOptions } from 'luxon';
+export declare class TimeUtil {
+    static now(): string;
+    static differentInDays(dataTime1: string, dataTime2: string): number;
+    static time(dataTime: string, timeFormat?: "12" | "24"): string;
+    static date(dataTime: string): string;
+    static timeStamp(dataTime: string): number;
+    static localDateTime(dateTime: string): string;
+    static decorateTime(dataTime: string): string;
+    static decorateDate(dataTime: string): string;
+    static getOrdinalSuffix: (num: number) => string;
+    static getDecoratedDate(dataTime: string): string;
+    static formatDateString: (dateString: string) => string;
+    static getFormattedDateStringWithoutTime: (dateString: string, showOrdinalSuffix?: boolean) => string;
+    static formatDateToMonDayYear: (dateString: string) => string;
+    static formatToDashedDate: (dateString: string) => string;
+    static formatGetTimeInMinSecHrAgo: (dateString: string) => string;
+    static convertToTargetISO(dateTime: string): string;
+    static convertToISOWithMilliseconds(dateTime: string): string;
+    static formatDateTimeForFilter(dateTime: string): string;
+    static formatDateTime(date: string): string;
+    /**
+     * Validates if the input is a valid date.
+     * Accepts ISO date strings, formatted date strings, and 13-digit timestamps.
+     * @param dateInput - The date input to validate.
+     * @returns {boolean} - Returns true if the input is a valid date, false otherwise.
+     */
+    static isValidDate(dateInput: string | number): boolean;
+    static getFormatDateTime: (input: string | number, options?: {
+        formatDateAs?: DateTimeFormatOptions;
+        formatTimeAs?: DateTimeFormatOptions;
+    }) => {
+        formattedDate: string;
+        formattedTime: string;
+        fullFormattedDateTime: string;
+        isDateTimeValid: boolean;
+    };
+}

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

@@ -0,0 +1,2 @@
+import { FormikValues, useFormik } from 'formik';
+export type Formik<Values extends FormikValues = FormikValues> = ReturnType<typeof useFormik<Values>>;

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

@@ -0,0 +1,6 @@
+/**
+ * Auto-generated barrel for src/utilities/types
+ */
+export * from './formTypes';
+export * from './modalTypes';
+export * from './themeTypes';