@dashadmin/dash-admin 1.3.73 → 1.3.74-srcfree.2

package/dist/contexts/DashQueryClientContext.d.ts

@@ -0,0 +1,19 @@
+import React, { FC } from 'react';
+import { QueryClient } from '@tanstack/react-query';
+import { Persister, PersistQueryClientOptions } from '@tanstack/react-query-persist-client';
+export type IQueryClientContext = {
+    queryClient?: QueryClient;
+    persister?: Persister;
+};
+export interface IDASHQueryClientProvider {
+    queryClient?: QueryClient;
+    children: React.ReactNode;
+    persister?: Persister;
+    persistOptions?: Omit<PersistQueryClientOptions, 'queryClient' | 'persister'>;
+}
+export declare const DashQueryClientContext: React.Context<IQueryClientContext>;
+declare const DashQueryClientProvider: FC<IDASHQueryClientProvider>;
+export declare const useDashQueryClient: () => QueryClient;
+export declare const useDashQueryPersister: () => Persister;
+export declare const useIsCachePersisted: () => boolean;
+export default DashQueryClientProvider;

package/dist/contexts/DashResourceContext.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { IDashAutoAdminResourceConfig } from 'dash-auto-admin';
+interface DashResourceContextType {
+    resourceConfig: IDashAutoAdminResourceConfig;
+}
+export declare const DashResourceProvider: React.NamedExoticComponent<{
+    resourceConfig: IDashAutoAdminResourceConfig;
+    children: React.ReactNode;
+}>;
+export declare const useDashResource: () => DashResourceContextType;
+export {};

package/dist/contexts/I18nBridgeContext.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { I18nProvider } from 'react-admin';
+export declare const LOCALE_CHANGE_EVENT = "dash:locale-change";
+interface I18nBridgeContextValue {
+    i18nProvider: I18nProvider | null;
+    locale: string;
+    setI18nProvider: (provider: I18nProvider) => void;
+    setLocale: (locale: string) => void;
+}
+declare const I18nBridgeContext: React.Context<I18nBridgeContextValue>;
+export declare const I18nBridgeProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const useI18nBridge: () => I18nBridgeContextValue;
+export declare const useBridgedLocales: () => import("react-admin").Locale[];
+export declare const useBridgedChangeLocale: () => (locale: string) => Promise<void>;
+export declare const useBridgedLocale: () => string;
+export default I18nBridgeContext;

package/dist/contexts/I18nBridgeSetter.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const I18nBridgeSetter: React.FC;
+export default I18nBridgeSetter;

package/dist/contexts/I18nReduxSync.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface I18nReduxSyncProps {
+    locale?: string;
+}
+declare const I18nReduxSync: React.FC<I18nReduxSyncProps>;
+export default I18nReduxSync;

package/dist/contexts/SubscriptionPlanFormatsProvider.d.ts

@@ -0,0 +1,13 @@
+interface SubscriptionPlanFormatsContextValue {
+    formats: any;
+    addonFormats: any;
+    loading: boolean;
+    fetchFormats: () => Promise<void>;
+}
+interface SubscriptionPlanFormatsProviderProps {
+    cacheSeconds?: number;
+    children: React.ReactNode;
+}
+export declare const SubscriptionPlanFormatsProvider: React.FC<SubscriptionPlanFormatsProviderProps>;
+export declare function useSubscriptionPlanFormats(): SubscriptionPlanFormatsContextValue;
+export default SubscriptionPlanFormatsProvider;

package/dist/contexts/SystemRequestsCache.d.ts

@@ -0,0 +1,16 @@
+export declare function idbSet(key: string, value: any): Promise<void>;
+export declare function idbGet(key: string): Promise<any>;
+interface SystemRequestsCacheContextValue {
+    formats: any;
+    fetchFormats: () => Promise<void>;
+    loading: boolean;
+}
+interface SystemRequestsCacheProviderProps {
+    cacheKey: string;
+    apiUrl: string;
+    cacheSeconds?: number;
+    children: React.ReactNode;
+}
+export declare const SystemRequestsCacheProvider: React.FC<SystemRequestsCacheProviderProps>;
+export declare function useSystemRequestsCache(): SystemRequestsCacheContextValue;
+export default SystemRequestsCacheProvider;

package/dist/contexts/auth/AuthContext.d.ts

@@ -0,0 +1,40 @@
+import { IGetAuth } from '../../interfaces/user/IGetAuth';
+import { IGetAuthUser } from '../../interfaces/user/IUser';
+import React, { FC, PropsWithChildren } from 'react';
+export declare class AuthContextClass {
+    static values: Partial<IAuthContextProps>;
+}
+export interface IAuthContextProps {
+    authenticated: boolean;
+    user: IGetAuthUser;
+    auth: IGetAuth;
+    token: string;
+    roles: any;
+    systemValues?: any;
+}
+export interface IAuthContext {
+    user: IGetAuthUser;
+    authenticated: boolean;
+    auth?: IGetAuth;
+    token?: string;
+    roles?: any;
+    systemValues?: any;
+    updateValues: (values: Partial<IAuthContextProps>) => void;
+    logout: (callback?: () => void) => Promise<void>;
+    handleReactAdminIdentity: (identity: any) => void;
+    getPermissions: () => Promise<any>;
+    fetchAuth: () => Promise<any>;
+    getSystemValues: () => any;
+    getSystemValue: (key: string) => any;
+    getPointOfSales: () => any;
+}
+export declare const AuthContext: React.Context<IAuthContext>;
+export interface IAuthContextProvider extends PropsWithChildren {
+    values?: Partial<IAuthContextProps>;
+}
+export declare const AuthContextProvider: FC<IAuthContextProvider>;
+export declare const AuthContextConsumer: React.Consumer<IAuthContext>;
+export declare const useAuthContext: () => IAuthContext;
+export declare const setAuthEvent: (values: Partial<IAuthContextProps>) => Partial<IAuthContextProps>;
+export declare const getAuthPermissions: () => Promise<any>;
+export default AuthContext;

package/dist/contexts/auth/AuthContextLocalStorage.d.ts

@@ -0,0 +1,27 @@
+import { IGetAuth } from '../../interfaces/user/IGetAuth';
+import { IGetAuthUser } from '../../interfaces/user/IUser';
+import React, { FC, PropsWithChildren } from 'react';
+export declare class AuthContextClass {
+    static values: Partial<IAuthContextProps>;
+}
+export interface IAuthContextProps {
+    authenticated: boolean;
+    user: IGetAuthUser;
+    auth: IGetAuth;
+    token: string;
+    roles: any;
+}
+export interface IAuthContext extends Partial<IAuthContextProps> {
+    updateValues: (values: Partial<IAuthContextProps>) => void;
+}
+export declare const AuthContextLocalStorage: React.Context<IAuthContext>;
+export interface IAuthContextProvider extends PropsWithChildren {
+    values?: Partial<IAuthContextProps>;
+}
+export declare const AuthContextProvider: FC<IAuthContextProvider>;
+export declare const AuthContextConsumer: React.Consumer<IAuthContext>;
+export declare const useAuthContext: () => IAuthContext;
+export declare const getAuthContext: () => Partial<IAuthContextProps>;
+export declare const updateAuthContext: (values: Partial<IAuthContextProps>) => Partial<IAuthContextProps>;
+export declare const setAuthContext: (values: Partial<IAuthContextProps>) => Partial<IAuthContextProps>;
+export default AuthContextLocalStorage;

package/dist/contexts/auth/DASHAuthenticationService.d.ts

@@ -0,0 +1,46 @@
+export interface DASHAuthenticationServiceLoginCredentials {
+    username: string;
+    password: string;
+    redirect?: string;
+    meta?: any;
+}
+export interface DASHAuthenticationServiceAuthResponse {
+    success: boolean;
+    token?: string;
+    user?: any;
+    auth?: any;
+    refreshToken?: string;
+    error?: string;
+    redirectAfterLogin?: string;
+}
+declare class DASHAuthenticationService {
+    private axiosInstance;
+    private readonly REDIRECT_STORAGE_KEY;
+    constructor();
+    reinitializeAxios(options?: any): void;
+    private sanitizeRedirectUrl;
+    setPendingRedirect(url: string): void;
+    getPendingRedirect(): string | null;
+    clearPendingRedirect(): void;
+    private getRoleRedirect;
+    private determineRedirectUrl;
+    private syncActiveTenant;
+    login(credentials: DASHAuthenticationServiceLoginCredentials): Promise<DASHAuthenticationServiceAuthResponse>;
+    initializeFromToken(): Promise<DASHAuthenticationServiceAuthResponse>;
+    refreshToken(refreshToken: string): Promise<DASHAuthenticationServiceAuthResponse>;
+    private logoutFromStorage;
+    checkAuth(): Promise<boolean>;
+    getIdentity(): Promise<any>;
+    shouldRefreshToken(): Promise<boolean>;
+    handleTokenRefresh(): Promise<boolean>;
+    shouldInitializeFromToken(forceGetAuth?: boolean): Promise<boolean>;
+    initializeApp(forceGetAuth?: boolean): Promise<DASHAuthenticationServiceAuthResponse>;
+    loginWithReactAdmin(credentials: DASHAuthenticationServiceLoginCredentials, reactAdminLogin?: any): Promise<void>;
+    getInitialAuthState: () => {
+        authenticated: boolean;
+        user: any;
+        auth: any;
+    };
+}
+declare const _default: DASHAuthenticationService;
+export default _default;

package/dist/contexts/auth/WindowContext.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export type IWindowContext = {
+    isMobile: boolean;
+    width: number;
+    height: number;
+    mq: string;
+};
+export declare const WindowContext: React.Context<IWindowContext>;

package/{src/contexts/auth/index.tsx → dist/contexts/auth/index.d.ts}

@@ -1,3 +1,2 @@
-//export * from './AuthProvider'
 export * from './AuthContext';
 export * from './WindowContext';

package/dist/contexts/com/FCMContext.d.ts

@@ -0,0 +1,62 @@
+import React, { FC } from 'react';
+export type IFCMContext = {
+    notifications: any[];
+    lastNotification: any;
+    clear: () => void;
+    initializePushNotifications: () => Promise<void>;
+    permissionStatus: 'unknown' | 'granted' | 'denied' | 'not_supported';
+    isSupported: boolean;
+    platform: string;
+};
+export interface IFCMProvider {
+    children: React.ReactNode;
+    manager?: () => {
+        notifications: any[];
+        lastNotification: any;
+        clear: () => void;
+        initializePushNotifications: () => Promise<void>;
+        permissionStatus: 'unknown' | 'granted' | 'denied' | 'not_supported';
+        isSupported: boolean;
+        platform: string;
+    };
+}
+export declare class FCMService {
+    private notifications;
+    private lastNotification;
+    private axiosInstance;
+    private permissionStatus;
+    constructor();
+    isSupported(): boolean;
+    getPlatform(): string;
+    checkPermissions(): Promise<boolean>;
+    requestPermissions(): Promise<boolean>;
+    initializePushNotifications(): Promise<void>;
+    private registerNotifications;
+    private addListeners;
+    private sendTokenToBackend;
+    clear(): void;
+    cleanup(): void;
+    getState(): {
+        notifications: any[];
+        lastNotification: any;
+        clear: () => void;
+        initializePushNotifications: () => Promise<void>;
+        permissionStatus: "unknown" | "granted" | "denied" | "not_supported";
+        isSupported: boolean;
+        platform: string;
+    };
+    getDebugInfo(): {
+        windowCapacitor: boolean;
+        hasPushNotificationsPlugin: boolean;
+        availablePlugins: string[];
+        platform: string;
+        isNativePlatform: any;
+        isSupported: boolean;
+        permissionStatus: "unknown" | "granted" | "denied" | "not_supported";
+        notificationsCount: number;
+        hasLastNotification: boolean;
+    };
+}
+export declare const FCMContext: React.Context<IFCMContext>;
+declare const FCMProvider: FC<IFCMProvider>;
+export { FCMContext as default, FCMProvider };

package/dist/contexts/com/LaravelEchoContext.d.ts

@@ -0,0 +1,18 @@
+import { IDashNotificationPayloadBase } from '../../interfaces/communication/INotification';
+import React, { FC } from 'react';
+export type ILaravelEchoContext = {
+    events: IDashNotificationPayloadBase[];
+    lastEvent: IDashNotificationPayloadBase;
+    clear: () => void;
+};
+export interface ILaravelEchoProvider {
+    children: React.ReactNode;
+    manager?: () => {
+        events: IDashNotificationPayloadBase[];
+        lastEvent: IDashNotificationPayloadBase;
+        clear: () => void;
+    };
+}
+export declare const LaravelEchoContext: React.Context<ILaravelEchoContext>;
+declare const LaravelEchoProvider: FC<ILaravelEchoProvider>;
+export { LaravelEchoContext as default, LaravelEchoProvider };

package/dist/contexts/com/LaravelEchoMgr.d.ts

@@ -0,0 +1,8 @@
+import type { IDashNotificationPayloadBase } from '../../interfaces/communication/INotification';
+export type ILaravelEchoManager = {
+    events: IDashNotificationPayloadBase[];
+    lastEvent: IDashNotificationPayloadBase;
+    clear: () => void;
+};
+declare const LaravelEchoMgr: () => ILaravelEchoManager;
+export default LaravelEchoMgr;

package/dist/contexts/com/components/DefaultNotificationComponent.d.ts

@@ -0,0 +1,6 @@
+import { IDashNotificationBase } from '../../../interfaces/communication/INotification';
+export interface IDefaultNotificationComponent {
+    notification: IDashNotificationBase<any>;
+}
+declare const ValidateProductsToImportNotificationComponent: React.FC<IDefaultNotificationComponent>;
+export default ValidateProductsToImportNotificationComponent;

package/dist/contexts/com/components/EchoNotificationsCenter.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const EchoNotificationsCenter: React.FC;
+export default EchoNotificationsCenter;

package/dist/contexts/com/components/NotificationAttributesTable.d.ts

@@ -0,0 +1,8 @@
+import { FC } from 'react';
+export interface ISimpleAntAttrTable {
+    tableData: any;
+    ignore?: string[];
+    include?: string[];
+}
+declare const NotificationAttributesTable: FC<ISimpleAntAttrTable>;
+export default NotificationAttributesTable;

package/dist/contexts/com/components/NotificationRenderer.d.ts

@@ -0,0 +1,8 @@
+import React, { FC } from 'react';
+import { IDashAutoAdminCustomFieldComponent } from 'dash-auto-admin';
+import { IDashNotificationBase } from '../../../interfaces/communication/INotification';
+export declare const NotificationComponent: FC<{
+    notification: IDashNotificationBase<any>;
+}>;
+declare const NotificationRenderer: ({ method, attribute, resourceConfig }: IDashAutoAdminCustomFieldComponent) => React.JSX.Element;
+export default NotificationRenderer;

package/dist/contexts/com/components/NotificationsWidget.d.ts

@@ -0,0 +1,17 @@
+import React, { FC } from 'react';
+import { IDashNotificationBase } from '../../../interfaces/communication/INotification';
+export interface INotificationItem {
+    key: React.Key;
+    title: string;
+    notification: IDashNotificationBase<any>;
+    image?: string;
+    name?: string;
+    time?: string;
+}
+export declare const NotificationWrapper: FC<{
+    notification: IDashNotificationBase<any>;
+    key: React.Key;
+    children: React.ReactNode;
+}>;
+export declare const NotificationsWidget: FC<{}>;
+export default NotificationsWidget;

package/dist/contexts/com/components/notificationFormats.d.ts

@@ -0,0 +1,38 @@
+import { IDashNotificationBase, IDashNotificationPayloadBase } from '../../../interfaces/communication/INotification';
+export interface DefaultDashNotificationPayload extends IDashNotificationPayloadBase {
+    [x: string]: any;
+}
+export interface IDashFormattedNotification {
+    class: string;
+    title: React.FC<{
+        notification: IDashNotificationBase<any>;
+    }>;
+    content: React.FC<{
+        notification: IDashNotificationBase<any>;
+    }>;
+    date?: string;
+    icon: React.FC<{
+        notification: IDashNotificationBase<any>;
+    }>;
+    [key: string]: any;
+}
+export interface INotificationFormat<T> {
+    class: string;
+    title: React.FC<{
+        notification: IDashNotificationBase<T>;
+    }>;
+    content: React.FC<{
+        notification: IDashNotificationBase<T>;
+    }>;
+    icon: React.FC<{
+        notification: IDashNotificationBase<T>;
+    }>;
+}
+export declare function formatNotification<T>(notification: IDashNotificationBase<T>, titleComponent?: React.FC<{
+    notification: IDashNotificationBase<T>;
+}>, iconComponent?: React.FC<{
+    notification: IDashNotificationBase<T>;
+}>, contentComponent?: React.FC<{
+    notification: IDashNotificationBase<T>;
+}>): IDashFormattedNotification;
+export default formatNotification;

package/dist/contexts/com/useLaravelEcho.d.ts

@@ -0,0 +1,37 @@
+import { Channel } from 'laravel-echo/src/channel';
+import Echo from 'laravel-echo';
+declare class EchoClientManager {
+    private static instance;
+    clients: Map<string, Echo<"pusher">>;
+    private constructor();
+    static getInstance(): EchoClientManager;
+    setClient(hash: string, client: Echo<"pusher">): void;
+    getClient(hash: string): Echo<"pusher"> | undefined;
+    removeClient(hash: string): boolean;
+    hasClient(hash: string): boolean;
+}
+export declare const echoManager: EchoClientManager;
+declare const useLaravelEcho: ({ type, channel, events, userId, socketId, pingInterval, debug, enabled }: {
+    type: "public" | "private";
+    channel: string;
+    events?: {
+        [key: string]: (e: any) => any;
+    };
+    userId?: number;
+    socketId?: string;
+    pingInterval?: number;
+    debug?: boolean;
+    enabled?: boolean;
+}) => {
+    echoChannel: Channel;
+    isConnected: boolean;
+    lastEvent: {
+        event: string;
+        data: any;
+        channel?: string;
+    };
+    ping: () => void;
+    addListener: (eventName: string, callback: (data: any) => void) => void;
+    removeListener: (eventName: string) => void;
+};
+export default useLaravelEcho;

package/dist/contexts/dictionary/DictionaryContext.d.ts

@@ -0,0 +1,21 @@
+import React, { FC } from 'react';
+export interface IDictionaryContext {
+    dictionary: {
+        [key: string]: any;
+    };
+    replacements: {
+        [key: string]: any;
+    };
+    get: (key: string, replace?: boolean) => string;
+}
+export declare const DictionaryContext: React.Context<IDictionaryContext>;
+declare const DictionaryProvider: FC<{
+    dictionary: {
+        [key: string]: any;
+    };
+    replacements: {
+        [key: string]: any;
+    };
+    children: React.ReactNode;
+}>;
+export { DictionaryContext as default, DictionaryProvider };

package/dist/default-theme/DASHAppProviders.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import WSMessagesManager from '../hooks/notifications/WSMessagesManager';
+import { Theme } from '@mui/material';
+import { LocalizationProviderProps } from '@mui/x-date-pickers';
+import { IDASHAppState } from 'dash-admin-state';
+import { Store } from 'redux';
+import { IDashAutoAdminCustomFieldComponent } from 'dash-auto-admin';
+import { Persister } from '@tanstack/react-query-persist-client';
+export interface IDomainAppProviders<U, A, R> extends React.PropsWithChildren {
+    wsMessagesManager?: typeof WSMessagesManager;
+    theme?: Partial<Theme> | ((outerTheme: Partial<Theme>) => Partial<Theme>);
+    dateAdapter?: LocalizationProviderProps<any>["dateAdapter"];
+    store?: Store<IDASHAppState<U, A, R>>;
+    extendedThemeOptions?: any;
+    dashAutoAdminComponents?: Record<string, React.FC<IDashAutoAdminCustomFieldComponent>>;
+    queryClient?: any;
+    queryPersister?: Persister;
+    CustomEchoProvider?: React.ComponentType<any>;
+}
+declare const DomainAppProviders: <U, A, R>({ wsMessagesManager, dateAdapter, store, children, extendedThemeOptions, dashAutoAdminComponents, queryClient, queryPersister, CustomEchoProvider }: IDomainAppProviders<U, A, R>) => React.JSX.Element;
+export default DomainAppProviders;

package/dist/default-theme/DashThemeContext.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { appTheme } from 'dash-styles';
+import { Theme } from '@mui/material';
+interface DashThemeContextType {
+    theme: Theme;
+    themeOptions: ReturnType<typeof appTheme>;
+    recreateTheme: (tenantSettings?: any) => void;
+    currentMode: string;
+}
+declare const DashThemeContext: React.Context<DashThemeContextType>;
+export declare const useDashThemeContext: () => DashThemeContextType;
+interface DashThemeProviderProps {
+    children?: React.ReactNode;
+    extendedOptions?: any;
+}
+export declare const DashThemeProvider: React.FC<DashThemeProviderProps>;
+export default DashThemeContext;

package/dist/default-theme/DashThemeHelperProvider.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface DashThemeHelperContextType {
+    mode: string;
+}
+export declare const useDashThemeHelperContext: () => DashThemeHelperContextType;
+interface DashThemeHelperProviderProps {
+    children?: React.ReactNode;
+}
+export declare const DashThemeHelperProvider: React.FC<DashThemeHelperProviderProps>;
+export default DashThemeHelperProvider;

package/dist/default-theme/DomainAppLayout.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { IAppLayout } from '../layout/AppLayout';
+import { IDomainTheme } from './DomainTheme';
+export interface IDomainAppLayout<U = any, A = any> extends IAppLayout {
+    ThemeComponent?: React.ComponentType<IDomainTheme<any, any>>;
+    showBreadcrumbs?: boolean;
+    breadcrumbLabelMap?: Record<string, string>;
+    breadcrumbIncludeHome?: boolean;
+    CustomDomainHeader?: React.JSX.Element;
+    CustomDomainFooter?: React.JSX.Element;
+}
+declare const DomainAppLayout: <U, A>(props: IDomainAppLayout<U, A>) => React.JSX.Element;
+export default DomainAppLayout;

package/dist/default-theme/DomainHeader.d.ts

@@ -0,0 +1,6 @@
+import { JSX, PropsWithChildren } from 'react';
+export interface IDomainHeader<U = any, A = any> extends PropsWithChildren {
+    showBreadcrumbs?: boolean;
+}
+declare const DomainHeader: <U, A>({ showBreadcrumbs, ...props }: IDomainHeader<U, A>) => JSX.Element;
+export default DomainHeader;

package/dist/default-theme/DomainTheme.d.ts

@@ -0,0 +1,8 @@
+import { JSX, PropsWithChildren } from 'react';
+export interface IDomainTheme<U = any, A = any> extends PropsWithChildren {
+    menuComponent?: JSX.Element;
+    headerToolBar?: JSX.Element;
+    footerComponent?: JSX.Element;
+}
+declare const DomainTheme: <U, A>({ children, menuComponent, headerToolBar, footerComponent, ...props }: IDomainTheme<U, A>) => JSX.Element;
+export default DomainTheme;

package/dist/default-theme/FullLayoutMarkup.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export interface IFullLayoutMarkup<U = any, A = any> extends React.PropsWithChildren {
+    logo?: string | React.ReactNode;
+    loginBackground?: string | React.ReactNode;
+}
+declare const FullLayoutMarkup: <U, A>({ children, className, logo, loginBackground, ...props }: IFullLayoutMarkup<U, A> & {
+    className?: string;
+}) => React.JSX.Element;
+export default FullLayoutMarkup;

package/dist/default-theme/StaticLayout.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export interface IStaticLayout<U = any, A = any> extends React.PropsWithChildren {
+}
+declare const StaticLayout: <U, A>({ children, ...props }: IStaticLayout<U, A>) => React.JSX.Element;
+export default StaticLayout;

package/{src/default-theme/index.tsx → dist/default-theme/index.d.ts}

@@ -1,11 +1,8 @@
 export { default as DASHAppLayout } from './DomainAppLayout';
 export { default as DASHAppProviders } from './DASHAppProviders';
-
 export { default as DomainTheme } from './DomainTheme';
 export { default as DomainHeader } from './DomainHeader';
 export { default as FullLayoutMarkup } from './FullLayoutMarkup';
 export { default as StaticLayout } from './StaticLayout';
 export { default as DashThemeContext } from './DashThemeContext';
 export { default as DashThemeHelperProvider, useDashThemeHelperContext } from './DashThemeHelperProvider';
-//export { default as updateDomCssVariables } from './updateDomCssVariables';
-

package/dist/default-theme/menu/AppDashboardGrid.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import { SxProps, Theme } from '@mui/material';
+import { IDashAutoAdminResourceConfig } from 'dash-auto-admin';
+export type DashboardGridCardSize = 'small' | 'medium' | 'large' | number;
+export interface IDashboardMenuGridColumns {
+    xs?: number;
+    sm?: number;
+    md?: number;
+    lg?: number;
+    xl?: number;
+}
+export interface IDashboardMenuGridProps {
+    columns?: number | IDashboardMenuGridColumns;
+    rows?: number;
+    orientation?: 'vertical' | 'horizontal';
+    size?: DashboardGridCardSize;
+    gap?: number;
+    menu?: IDashAutoAdminResourceConfig[];
+    debug?: boolean;
+    sx?: SxProps<Theme>;
+    className?: string;
+}
+declare const AppDashboardGrid: React.FC<IDashboardMenuGridProps>;
+export default AppDashboardGrid;

package/dist/default-theme/menu/AppMaterialMenu.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { IAppMenu } from './AppMenuComponents/interfaces';
+interface IAppMenuExtended extends IAppMenu {
+    logos?: {
+        horizontalLogo: React.ReactNode;
+        squaredLogo: React.ReactNode;
+    };
+    onToggleDrawer?: (e: React.MouseEvent) => void;
+}
+declare const AppMaterialMenu: React.FC<IAppMenuExtended>;
+export default AppMaterialMenu;

package/dist/default-theme/menu/AppMenuComponents/SubmenuPortal.d.ts

@@ -0,0 +1,15 @@
+import React, { RefObject } from 'react';
+import { SidebarPosition } from '../AppSidebarMaterial';
+export interface SubmenuPortalProps {
+    open: boolean;
+    itemRef: RefObject<HTMLElement | null>;
+    sidebarPosition: SidebarPosition;
+    children: React.ReactNode;
+    onMouseEnter?: () => void;
+    onMouseLeave?: () => void;
+    childrenCount?: number;
+    className?: string;
+    contentRef?: RefObject<HTMLDivElement | null>;
+}
+declare const SubmenuPortal: React.FC<SubmenuPortalProps>;
+export default SubmenuPortal;