import * as React from 'react';
import React__default, { ReactNode, ReactElement } from 'react';
import { J as JsonApiHydratedDataInterface } from '../ApiDataInterface-BcZeXy5X.mjs';
import { c as CompanyInterface, N as NotificationInterface, e as RoleInterface, U as UserInterface } from '../notification.interface-BWOCvKRP.mjs';
import { O as OnboardingProviderProps, a as OnboardingContextValue } from '../onboarding.interface-Djyl9qYu.mjs';
export { D as DEFAULT_ONBOARDING_LABELS, g as OnboardingCardRenderProps, f as OnboardingLabels, c as OnboardingStepConfig, b as OnboardingStepSide, d as OnboardingTourConfig, e as OnboardingTourPaths } from '../onboarding.interface-Djyl9qYu.mjs';
import { M as ModuleWithPermissions, A as Action } from '../types-Bq_UA8Lg.mjs';
import { a as HowToInterface, B as BreadcrumbItemData, d as AssistantMessageInterface } from '../AssistantMessageInterface-ddyG114R.mjs';
import { R as RbacMatrix, A as ActionType, P as PermissionValue } from '../RbacTypes-BTbr27Ew.mjs';
import { a as AssistantInterface } from '../AssistantInterface-DMh-zApr.mjs';
import { LucideIcon } from 'lucide-react';
import { u as useSocket } from '../useSocket-BZG9oX-L.mjs';
import * as jotai from 'jotai';
import * as jotai_utils from 'jotai/utils';
import '../feature.interface-CXb1-vNq.mjs';
import '../ApiRequestDataTypeInterface-CYEcRUrh.mjs';

interface AdministrationContextType {
}
type AdministrationProviderProps = {
    children: ReactNode;
};
/**
 * Supplies the page chrome for every administration surface.
 *
 * `RoundPageContainerTitle` and the header breadcrumb both read
 * `useSharedContext()`, and that context is provided far up the tree by the
 * layout — so an administration page that provides nothing of its own silently
 * inherits whatever the *previously rendered* page put there (a company name, a
 * "Notifications" title). Wrapping in this provider replaces that value, which
 * is why every administration container mounts inside it.
 *
 * Mirrors CommonProvider (contexts/CommonContext.tsx), which does the same job
 * for the ordinary application shell.
 */
declare const AdministrationProvider: ({ children }: AdministrationProviderProps) => React.JSX.Element;
declare const useAdministrationContext: () => AdministrationContextType;

interface CompanyContextType {
    company: CompanyInterface | undefined;
    setCompany: (value: CompanyInterface | undefined) => void;
}
type CompanyProviderProps = {
    children: ReactNode;
    dehydratedCompany?: JsonApiHydratedDataInterface;
    configurationEditorSlot?: ReactNode;
};
declare const CompanyProvider: ({ children, dehydratedCompany, configurationEditorSlot }: CompanyProviderProps) => React.JSX.Element;
declare const useCompanyContext: () => CompanyContextType;

interface NotificationContextType {
    notifications: NotificationInterface[];
    setNotifications: (notifications: NotificationInterface[]) => void;
    addNotification: (notification: NotificationInterface) => void;
    addSocketNotifications: (socketNotifications: NotificationInterface[]) => void;
    loadNotifications: () => Promise<void>;
    generateNotification: (notification: NotificationInterface, closePopover: () => void) => ReactElement<any>;
    generateToastNotification: (notification: NotificationInterface, t: any, generateUrl: any) => {
        title: string;
        description: string | ReactElement<any>;
        action?: {
            label: string;
            onClick: () => void;
        };
    };
    markNotificationsAsRead: (ids: string[]) => Promise<void>;
    isLoading: boolean;
    error: string | null;
    lastLoaded: number;
    shouldRefresh: boolean;
}
type NotificationContextProviderProps = {
    children: React__default.ReactNode;
};
declare const NotificationContextProvider: ({ children }: NotificationContextProviderProps) => React__default.JSX.Element;
declare const useNotificationContext: () => NotificationContextType;

declare function OnboardingProvider({ children, tours, tourPaths: _tourPaths, labels, renderCard, zIndex: _zIndex, }: OnboardingProviderProps): React.JSX.Element;
declare function useOnboarding(): OnboardingContextValue;

interface RoleContextType {
    role: RoleInterface | undefined;
    setRole: (value: RoleInterface | undefined) => void;
}
type RoleProviderProps = {
    children: ReactNode;
    dehydratedRole?: JsonApiHydratedDataInterface;
};
declare const RoleProvider: ({ children, dehydratedRole }: RoleProviderProps) => React.JSX.Element;
declare const useRoleContext: () => RoleContextType;

interface CurrentUserContextType<T extends UserInterface = UserInterface> {
    currentUser: T | null;
    company: CompanyInterface | null;
    setUser: (user?: T) => void;
    hasPermissionToModule: <M extends ModuleWithPermissions>(params: {
        module: M;
        action: Action;
        data?: any;
    }) => boolean;
    hasPermissionToModules: <M extends ModuleWithPermissions>(params: {
        modules: M[];
        action: Action;
        data?: any;
    }) => boolean;
    hasPermissionToPath: (path: string) => boolean;
    hasAccesToFeature: (featureIdentifier: string) => boolean;
    matchUrlToModule: (prarms?: {
        path: string;
    }) => ModuleWithPermissions | undefined;
    hasRole: (roleId: string) => boolean;
    refreshUser: (options?: {
        skipCookieUpdate?: boolean;
    }) => Promise<void>;
    isRefreshing: boolean;
}
declare const CurrentUserProvider: ({ children }: {
    children: React__default.ReactNode;
}) => React__default.JSX.Element;
declare function useCurrentUserContext<T extends UserInterface = UserInterface>(): CurrentUserContextType<T>;

interface UserContextType {
    user: UserInterface | undefined;
    setUser: (value: UserInterface | undefined) => void;
}
type UserProviderProps = {
    children: ReactNode;
    dehydratedUser?: JsonApiHydratedDataInterface;
};
declare const UserProvider: ({ children, dehydratedUser }: UserProviderProps) => React.JSX.Element;
declare const useUserContext: () => UserContextType;

interface HowToContextType {
    howTo: HowToInterface | undefined;
    setHowTo: (value: HowToInterface | undefined) => void;
    reloadHowTo: () => Promise<void>;
}
type HowToProviderProps = {
    children: ReactNode;
    dehydratedHowTo?: JsonApiHydratedDataInterface;
};
declare const HowToProvider: ({ children, dehydratedHowTo }: HowToProviderProps) => React.JSX.Element;
declare const useHowToContext: () => HowToContextType;

interface RbacContextType {
    matrix: RbacMatrix | null;
    modulePaths: Record<string, readonly string[]>;
    loading: boolean;
    error: string | null;
    saving: boolean;
    roleNames?: Record<string, string>;
    moduleNames?: Record<string, string>;
    updateCell: (moduleId: string, rowKey: "default" | string, action: ActionType, value: PermissionValue) => void;
    clearCell: (moduleId: string, roleId: string, action: ActionType) => void;
}
type RbacProviderProps = {
    children: ReactNode;
    /** UUID → PascalCase map for roles (e.g. from `@neural-erp/shared`'s `RoleId`). */
    roleNames?: Record<string, string>;
    /** UUID → PascalCase map for modules (e.g. from `@neural-erp/shared`'s `ModuleId`). */
    moduleNames?: Record<string, string>;
    /**
     * Output path for the serialized `permissions.ts` file. Absolute, or
     * relative to the API's repo root. Defaults to
     * `"apps/api/src/rbac/permissions.ts"`.
     */
    outputPath?: string;
};
/**
 * RbacProvider — owns the matrix state, the save handler, and the breadcrumb +
 * title wiring. Renders the "Save to permissions.ts" button into
 * `title.functions` so it appears in the page header, following the same
 * convention as CompanyContext / other context providers in this codebase.
 *
 * The child `RbacContainer` is stateless — it consumes state via
 * `useRbacContext()`.
 */
declare const RbacProvider: ({ children, roleNames, moduleNames, outputPath, }: RbacProviderProps) => React.JSX.Element;
declare const useRbacContext: () => RbacContextType;

interface AssistantContextValue {
    assistant?: AssistantInterface;
    messages: AssistantMessageInterface[];
    threads: AssistantInterface[];
    threadsLoading: boolean;
    sending: boolean;
    status?: string;
    failedMessageIds: Set<string>;
    sendMessage(content: string, opts?: {
        howToMode?: boolean;
        limitToHowToId?: string;
        contentBlocks?: unknown[];
    }): Promise<void>;
    retrySend(tempId: string): Promise<void>;
    selectThread(id: string): Promise<void>;
    startNew(): void;
    renameThread(id: string, title: string): Promise<void>;
    deleteThread(id: string): Promise<void>;
    /** When true, create/append route to the operator-engine endpoints. */
    operatorMode: boolean;
    setOperatorMode(value: boolean): void;
    /** Appends a message returned outside the send flow (e.g. an approve/deny resume). */
    appendResolvedMessage(message: AssistantMessageInterface): void;
}
interface Props {
    children: React__default.ReactNode;
    dehydratedAssistant?: JsonApiHydratedDataInterface;
    dehydratedMessages?: JsonApiHydratedDataInterface[];
    /**
     * When `true` (default), the provider mutates the browser URL on
     * create/selectThread/startNew (e.g. `/assistants/{id}`). Set to `false`
     * when the assistant is hosted inside a sheet / overlay so the user's
     * current route is preserved.
     */
    manageUrl?: boolean;
    /**
     * Confines the provider to one bound resource (e.g. a campaign): the thread
     * list is filtered to that resource and newly created threads are bound to
     * it, so a scoped surface never shows or creates cross-scope threads.
     */
    scope?: {
        type: string;
        id: string;
    };
    /**
     * Builds the browser URL for a thread. Defaults to `/assistants/{id}` (or
     * `/assistants` when no thread is active), which is only correct for the
     * standalone assistant route; a scoped host passes its own builder.
     */
    threadUrl?: (id?: string) => string;
    /**
     * Page heading. Defaults to the "Assistants" entity label; a scoped host
     * passes something meaningful for its own surface.
     */
    titleOverride?: string;
    /**
     * Breadcrumb trail. Defaults to a single crumb pointing at the global
     * assistant list, which is wrong for a scoped surface.
     */
    breadcrumbsOverride?: BreadcrumbItemData[];
}
declare function AssistantProvider({ children, dehydratedAssistant, dehydratedMessages, manageUrl, titleOverride, breadcrumbsOverride, scope, threadUrl, }: Props): React__default.JSX.Element;
declare function useAssistantContext(): AssistantContextValue;

interface CommonContextType {
}
type CommonProviderProps = {
    children: ReactNode;
};
declare const CommonProvider: ({ children }: CommonProviderProps) => React.JSX.Element;
declare const useCommonContext: () => CommonContextType;

interface HeaderChildrenProviderProps {
    children: ReactNode;
    content: ReactNode;
    mobileContent?: ReactNode;
    rootLabel?: string;
}
/**
 * Provider to supply custom content to be rendered in the Header component.
 * Wrap your layout with this provider and pass the content you want in the header.
 * Optionally pass `rootLabel` to override the first breadcrumb entry (defaults to `common.home`).
 *
 * The header has far less room on mobile, so `content` is desktop-only. Pass `mobileContent`
 * to choose which widgets survive there; omit it and the header stays bare on mobile.
 */
declare function HeaderChildrenProvider({ children, content, mobileContent, rootLabel }: HeaderChildrenProviderProps): React.JSX.Element;
/**
 * Hook to get the header children content from context.
 * Used internally by PageContainer to pass children to Header.
 */
declare function useHeaderChildren(): ReactNode | null;
/**
 * Hook to get the header content the application wants kept on mobile.
 * Returns null when the application supplied none, in which case the Header shows no widgets there.
 */
declare function useHeaderMobileChildren(): ReactNode | null;
/**
 * Hook to get the label of the first breadcrumb entry, when the application supplies one.
 * Returns null when no override was provided, in which case the Header falls back to `common.home`.
 */
declare function useHeaderRootLabel(): string | null;

interface HeaderLeftContentProviderProps {
    children: ReactNode;
    content: ReactNode;
}
declare function HeaderLeftContentProvider({ children, content }: HeaderLeftContentProviderProps): React.JSX.Element;
declare function useHeaderLeftContent(): ReactNode | null;

interface HeaderLogoProviderProps {
    children: ReactNode;
    content: ReactNode;
}
declare function HeaderLogoProvider({ children, content }: HeaderLogoProviderProps): React.JSX.Element;
declare function useHeaderLogo(): ReactNode | null;

/**
 * One slot in the mobile bottom navigation bar.
 *
 * Supply exactly one of `icon` / `render`, and exactly one of `href` / `onClick`.
 * This is a review-time contract, not a runtime-validated one — the mistake is
 * immediately visible in dev, and validation code would ship to every consumer.
 *
 * `render` content MUST NOT contain an interactive element: an `href` slot is
 * already wrapped in a <Link>, so a nested <a>/<button> is invalid HTML and
 * triggers a hydration error.
 */
type MobileNavigationItem = {
    /** Stable unique key. Used as the React key and the `data-testid` suffix. */
    key: string;
    /** Accessible name. The bar is icons-only, so this is never rendered as text. */
    label: string;
    /** Rendered at 24px. Mutually exclusive with `render`. */
    icon?: LucideIcon;
    /** Escape hatch for slots an icon cannot express (logo mark, user avatar). */
    render?: ReactNode;
    /** Navigational slot — receives the active highlight. */
    href?: string;
    /** Action slot — never highlighted. */
    onClick?: () => void;
};
/**
 * Supplies the items rendered by `MobileNavigationBar`.
 *
 * Unlike `useSharedContext`, the hook below does NOT throw without a provider —
 * it returns `[]` and the bar renders nothing. Apps that never install this
 * provider are completely unaffected.
 *
 * MUST be rendered inside `ViewportProvider` so the bar's `useIsMobile()` reads
 * the server-seeded viewport rather than flashing.
 */
declare function MobileNavigationProvider({ children, items }: {
    children: ReactNode;
    items: MobileNavigationItem[];
}): React.JSX.Element;
/** Returns the application-supplied bottom-navigation items, or `[]` when none. */
declare function useMobileNavigationItems(): MobileNavigationItem[];

interface SharedProviderProps {
    children: ReactNode;
    value: {
        breadcrumbs: BreadcrumbItemData[];
        title: {
            type: string;
            element?: string;
            functions?: ReactNode;
            titleActions?: ReactNode;
            prioritizeFunctions?: boolean;
            icon?: ReactNode;
            actionBar?: ReactNode;
        };
    };
}
declare const SharedProvider: ({ children, value }: SharedProviderProps) => React.JSX.Element;
declare const useSharedContext: () => {
    breadcrumbs: BreadcrumbItemData[];
    title: {
        type: string | string[];
        element?: string;
        functions?: ReactNode;
        titleActions?: ReactNode;
        prioritizeFunctions?: boolean;
        icon?: ReactNode;
        actionBar?: ReactNode;
    };
};

interface SocketContextProps {
    socket: ReturnType<typeof useSocket>["socket"];
    isConnected: boolean;
    messages: any[];
    socketNotifications: NotificationInterface[];
    sendMessage: (event: string, data: any) => void;
    removeMessage: (index: number) => void;
    removeSocketNotification: (index: number) => void;
    clearMessages: () => void;
    clearSocketNotifications: () => void;
}
declare const SocketContext: React__default.Context<SocketContextProps>;
interface SocketProviderProps {
    token?: string;
    children: React__default.ReactNode;
}
declare const SocketProvider: React__default.FC<SocketProviderProps>;
declare const useSocketContext: () => SocketContextProps;

/**
 * Seeds the viewport from the server so SSR and the first client render agree,
 * removing the desktop-then-mobile chrome flash.
 *
 * `initialIsMobile` comes from the request — cookie first (a real measurement
 * from a previous visit), user agent as the first-visit fallback. See the
 * (main)/(admin) layouts.
 *
 * THIS LIVES IN `contexts/`, NOT `utils/`, AND MUST STAY HERE. The server
 * layouts render it directly, so it needs a genuine "use client" boundary in
 * the BUILT output. tsup.config.ts stamps the directive onto `dist/contexts/*`
 * via its `clientEntries` list; `dist/core/*` is deliberately excluded so that
 * instrumentation can import it server-side. Exporting this provider from
 * `core` therefore made Next execute it as a Server Component and fail with
 * "createContext only works in Client Components".
 *
 * `SocketContext` in this directory is the reference: it is likewise rendered
 * straight from `(main)/layout.tsx`, a Server Component, and works.
 */
declare function ViewportProvider({ initialIsMobile, children, }: {
    initialIsMobile: boolean;
    children: React.ReactNode;
}): React.JSX.Element;

interface RecentPage {
    url: string;
    title: string;
    moduleType: string;
    timestamp: number;
}
declare const recentPagesAtom: jotai.WritableAtom<RecentPage[], [typeof jotai_utils.RESET | RecentPage[] | ((prev: RecentPage[]) => typeof jotai_utils.RESET | RecentPage[])], void>;

export { AdministrationProvider, AssistantProvider, CommonProvider, CompanyProvider, type CurrentUserContextType, CurrentUserProvider, HeaderChildrenProvider, HeaderLeftContentProvider, HeaderLogoProvider, HowToProvider, type MobileNavigationItem, MobileNavigationProvider, NotificationContextProvider, OnboardingContextValue, OnboardingProvider, OnboardingProviderProps, RbacProvider, type RecentPage, RoleProvider, SharedProvider, SocketContext, SocketProvider, UserProvider, ViewportProvider, recentPagesAtom, useAdministrationContext, useAssistantContext, useCommonContext, useCompanyContext, useCurrentUserContext, useHeaderChildren, useHeaderLeftContent, useHeaderLogo, useHeaderMobileChildren, useHeaderRootLabel, useHowToContext, useMobileNavigationItems, useNotificationContext, useOnboarding, useRbacContext, useRoleContext, useSharedContext, useSocketContext, useUserContext };