@launchdarkly/toolbar 2.0.0-beta.1 → 2.1.0

package/dist/core/ui/Toolbar/components/new/SearchSection.module.css.d.ts

@@ -0,0 +1,3 @@
+export declare const searchFieldWrapper: string;
+export declare const searchField: string;
+export declare const searchGroup: string;

package/dist/core/ui/Toolbar/components/new/Settings/ConnectionStatus.d.ts

@@ -0,0 +1,5 @@
+interface ConnectionStatusProps {
+    status: 'connected' | 'disconnected' | 'error';
+}
+export declare function ConnectionStatus({ status }: ConnectionStatusProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/components/new/Settings/ConnectionStatus.module.css.d.ts

@@ -0,0 +1,6 @@
+export declare const container: string;
+export declare const text: string;
+export declare const dot: string;
+export declare const connected: string;
+export declare const disconnected: string;
+export declare const error: string;

package/dist/core/ui/Toolbar/components/new/Settings/EnvironmentSelector.d.ts

@@ -0,0 +1 @@
+export declare function EnvironmentSelector(): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/components/new/Settings/GeneralSettings.d.ts

@@ -0,0 +1 @@
+export declare function GeneralSettings(): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/components/new/Settings/LogoutButton.d.ts

@@ -0,0 +1 @@
+export declare function LogoutButton(): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/components/new/Settings/LogoutButton.module.css.d.ts

@@ -0,0 +1 @@
+export declare const button: string;

package/dist/core/ui/Toolbar/components/new/Settings/PositionSelector.d.ts

@@ -0,0 +1,6 @@
+import { ToolbarPosition } from '../../../types/toolbar';
+interface PositionSelectorProps {
+    currentPosition: ToolbarPosition;
+}
+export declare function PositionSelector({ currentPosition }: PositionSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/components/new/Settings/Privacy/PrivacySettings.d.ts

@@ -0,0 +1 @@
+export declare function PrivacySettings(): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/components/new/Settings/ProjectSelector.d.ts

@@ -0,0 +1 @@
+export declare function ProjectSelector(): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/components/new/Settings/SettingsContent.module.css.d.ts

@@ -0,0 +1,5 @@
+export declare const container: string;
+export declare const value: string;
+export declare const placeholder: string;
+export declare const feedbackSection: string;
+export declare const feedbackTitle: string;

package/dist/core/ui/Toolbar/components/new/Settings/SettingsItem.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface SettingsItemProps {
+    label: string;
+    description?: string;
+    children: React.ReactNode;
+}
+export declare function SettingsItem({ label, description, children }: SettingsItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/components/new/Settings/SettingsItem.module.css.d.ts

@@ -0,0 +1,6 @@
+export declare const item: string;
+export declare const info: string;
+export declare const label: string;
+export declare const description: string;
+export declare const control: string;
+export declare const switch_: string;

package/dist/core/ui/Toolbar/components/new/Settings/SettingsSection.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface SettingsSectionProps {
+    title: string;
+    children: React.ReactNode;
+}
+export declare function SettingsSection({ title, children }: SettingsSectionProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/components/new/Settings/SettingsSection.module.css.d.ts

@@ -0,0 +1,3 @@
+export declare const section: string;
+export declare const title: string;
+export declare const content: string;

package/dist/core/ui/Toolbar/components/new/Settings/ShareButton.d.ts

@@ -0,0 +1,5 @@
+interface ShareButtonProps {
+    onClick: (e: React.MouseEvent) => void;
+}
+export declare function ShareButton({ onClick }: ShareButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/components/new/Settings/ShareButton.module.css.d.ts

@@ -0,0 +1 @@
+export declare const button: string;

package/dist/core/ui/Toolbar/components/new/Settings/index.d.ts

@@ -0,0 +1,8 @@
+export * from './GeneralSettings';
+export * from './Privacy/PrivacySettings';
+export * from './SettingsSection';
+export * from './SettingsItem';
+export * from './ProjectSelector';
+export * from './PositionSelector';
+export * from './ConnectionStatus';
+export * from './LogoutButton';

package/dist/core/ui/Toolbar/components/new/SubtabDropdown.d.ts

@@ -0,0 +1,8 @@
+import { SubTab, TabConfig } from './types';
+interface SubtabDropdownProps {
+    subtabs: TabConfig[];
+    activeSubtab: SubTab | undefined;
+    onSelectSubtab: (subtab: SubTab) => void;
+}
+export declare function SubtabDropdown({ subtabs, activeSubtab, onSelectSubtab }: SubtabDropdownProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/components/new/SubtabDropdown.module.css.d.ts

@@ -0,0 +1,10 @@
+export declare const container: string;
+export declare const trigger: string;
+export declare const triggerOpen: string;
+export declare const filterIcon: string;
+export declare const label: string;
+export declare const chevron: string;
+export declare const chevronIcon: string;
+export declare const menu: string;
+export declare const menuItem: string;
+export declare const menuItemActive: string;

package/dist/core/ui/Toolbar/components/new/TabBar.d.ts

@@ -0,0 +1 @@
+export declare function TabBar(): import("react/jsx-runtime").JSX.Element | null;

package/dist/core/ui/Toolbar/components/new/TabBar.module.css.d.ts

@@ -0,0 +1,4 @@
+export declare const container: string;
+export declare const tabs: string;
+export declare const tab: string;
+export declare const active: string;

package/dist/core/ui/Toolbar/components/new/Tooltip.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface TooltipProps {
+    content: string;
+    children: React.ReactNode;
+    offsetTop?: number;
+    offsetLeft?: number;
+}
+export declare function Tooltip({ content, children, offsetTop, offsetLeft }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/components/new/Tooltip.module.css.d.ts

@@ -0,0 +1,2 @@
+export declare const container: string;
+export declare const tooltip: string;

package/dist/core/ui/Toolbar/components/new/context/ActiveSubtabProvider.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { SubTab } from '../types';
+interface ActiveSubtabContextValue {
+    activeSubtab: SubTab | undefined;
+    setActiveSubtab: (subtab: SubTab) => void;
+}
+export interface ActiveSubtabProviderProps {
+    children: ReactNode;
+}
+export declare function ActiveSubtabProvider({ children }: ActiveSubtabProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useActiveSubtabContext(): ActiveSubtabContextValue;
+export {};

package/dist/core/ui/Toolbar/components/new/context/FiltersProvider.d.ts

@@ -0,0 +1,41 @@
+import { ReactNode } from 'react';
+import { SubTab } from '../types';
+export interface FilterOption {
+    id: string;
+    label: string;
+    description?: string;
+}
+export interface SubtabFilterConfig {
+    subtab: SubTab;
+    options: FilterOption[];
+    defaultSelected: string[];
+    allowMultiple: boolean;
+}
+export declare const SUBTAB_FILTER_CONFIGS: Record<string, SubtabFilterConfig>;
+interface FiltersContextValue {
+    getActiveFilters: (subtab: SubTab) => Set<string>;
+    getFilterConfig: (subtab: SubTab) => SubtabFilterConfig | null;
+    toggleFilter: (subtab: SubTab, filterId: string) => void;
+    setFilters: (subtab: SubTab, filterIds: string[]) => void;
+    resetFilters: (subtab: SubTab) => void;
+    hasFilters: (subtab: SubTab) => boolean;
+    hasActiveNonDefaultFilters: (subtab: SubTab) => boolean;
+    isFilterOverlayOpen: boolean;
+    openFilterOverlay: () => void;
+    closeFilterOverlay: () => void;
+    toggleFilterOverlay: () => void;
+}
+interface FiltersProviderProps {
+    children: ReactNode;
+}
+export declare function FiltersProvider({ children }: FiltersProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useFilters(): FiltersContextValue;
+export declare function useSubtabFilters(subtab: SubTab): {
+    activeFilters: Set<string>;
+    config: SubtabFilterConfig | null;
+    toggle: (filterId: string) => void;
+    reset: () => void;
+    hasFilters: boolean;
+    hasActiveNonDefaultFilters: boolean;
+};
+export {};

package/dist/core/ui/Toolbar/components/new/context/TabSearchProvider.d.ts

@@ -0,0 +1,12 @@
+import { SubTab } from '../types';
+type SubTabSearchContextType = {
+    searchTerms: Record<SubTab, string>;
+    setSearchTerm: (subtab: SubTab, searchTerm: string) => void;
+    clearSearchTerm: (subtab: SubTab) => void;
+    clearAllSearchTerms: () => void;
+};
+export declare function TabSearchProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useTabSearchContext(): SubTabSearchContextType;
+export {};

package/dist/core/ui/Toolbar/components/new/context/index.d.ts

@@ -0,0 +1,3 @@
+export { ActiveSubtabProvider, useActiveSubtabContext } from './ActiveSubtabProvider';
+export { TabSearchProvider, useTabSearchContext } from './TabSearchProvider';
+export { FiltersProvider, useFilters, useSubtabFilters, SUBTAB_FILTER_CONFIGS, type FilterOption, type SubtabFilterConfig, } from './FiltersProvider';

package/dist/core/ui/Toolbar/components/new/index.d.ts

@@ -0,0 +1,10 @@
+export * from './ExpandedToolbarContent';
+export * from './IconBar/IconBar';
+export * from './TabBar';
+export * from './ContentActions';
+export * from './Tooltip';
+export * from './ContentRenderer';
+export * from './context';
+export * from './types';
+export * from './Settings';
+export * from './FilterOverlay';

package/dist/core/ui/Toolbar/components/new/types.d.ts

@@ -0,0 +1,16 @@
+export type FlagsSubtab = 'flags' | 'contexts';
+export type MonitoringSubtab = 'events';
+export type SettingsSubtab = 'general' | 'privacy';
+export type InteractiveSubtab = 'workflows';
+export type SubTab = FlagsSubtab | MonitoringSubtab | SettingsSubtab | InteractiveSubtab;
+export interface TabConfig {
+    id: string;
+    label: string;
+}
+export declare const TAB_SUBTABS_MAP: {
+    readonly flags: TabConfig[];
+    readonly monitoring: TabConfig[];
+    readonly settings: TabConfig[];
+    readonly interactive: TabConfig[];
+};
+export declare function getDefaultSubtab(mainTab: string): SubTab;

package/dist/core/ui/Toolbar/constants/animations.d.ts

@@ -40,6 +40,20 @@ export declare const ANIMATION_CONFIG: {
             readonly ease: "easeInOut";
         };
     };
+    readonly containerInstant: {
+        readonly width: {
+            readonly duration: 0.01;
+        };
+        readonly height: {
+            readonly duration: 0.01;
+        };
+        readonly borderRadius: {
+            readonly duration: 0.01;
+        };
+        readonly boxShadow: {
+            readonly duration: 0.01;
+        };
+    };
     readonly container: {
         readonly width: {
             readonly duration: 0.25;

package/dist/core/ui/Toolbar/constants/virtualization.d.ts

@@ -1,4 +1,5 @@
 export declare const VIRTUALIZATION: {
     readonly ITEM_HEIGHT: 80;
     readonly OVERSCAN: 5;
+    readonly GAP: 12;
 };

package/dist/core/ui/Toolbar/context/DevServerProvider.d.ts

@@ -1,4 +1,5 @@
 import type { FC, ReactNode } from 'react';
+import { DevServerClient } from '../../../services/DevServerClient';
 import { LdToolbarConfig, ToolbarState } from '../../../types/devServer';
 interface DevServerContextValue {
     state: ToolbarState;
@@ -6,6 +7,7 @@ interface DevServerContextValue {
     clearOverride: (flagKey: string) => Promise<void>;
     clearAllOverrides: () => Promise<void>;
     refresh: () => Promise<void>;
+    devServerClient: DevServerClient | null;
 }
 export declare const useDevServerContext: () => DevServerContextValue;
 export interface DevServerProviderProps {

package/dist/core/ui/Toolbar/context/ElementSelectionProvider.d.ts

@@ -0,0 +1,52 @@
+import { ReactNode } from 'react';
+import { ElementInfo } from '../components/new/Interactive/utils/elementUtils';
+/**
+ * Context value for element selection functionality.
+ * Provides state and actions for selecting DOM elements in the interactive mode.
+ */
+export interface ElementSelectionContextValue {
+    /** Whether the user is currently in element selection mode */
+    isSelecting: boolean;
+    /** The currently selected DOM element, or null if none selected */
+    selectedElement: HTMLElement | null;
+    /** Extracted information about the selected element */
+    selectedElementInfo: ElementInfo | null;
+    /** The element currently being hovered over during selection */
+    hoveredElement: HTMLElement | null;
+    /** Start element selection mode */
+    startSelection: () => void;
+    /** Exit element selection mode without selecting an element */
+    exitSelection: () => void;
+    /** Select an element and exit selection mode */
+    selectElement: (element: HTMLElement) => void;
+    /** Clear the current selection */
+    clearSelection: () => void;
+    /** Set the currently hovered element (used internally by SelectionOverlay) */
+    setHoveredElement: (element: HTMLElement | null) => void;
+}
+export interface ElementSelectionProviderProps {
+    /** Child components that will have access to the element selection context */
+    children: ReactNode;
+    /** Optional callback invoked when selection mode starts */
+    onSelectionStart?: () => void;
+    /** Optional callback invoked when selection mode ends (either by selecting or exiting) */
+    onSelectionEnd?: () => void;
+}
+/**
+ * Provider component that manages element selection state for the interactive mode.
+ * Wraps components that need access to element selection functionality.
+ *
+ * @param props - The provider props
+ * @param props.children - Child components
+ * @param props.onSelectionStart - Optional callback when selection starts
+ * @param props.onSelectionEnd - Optional callback when selection ends
+ */
+export declare function ElementSelectionProvider({ children, onSelectionStart, onSelectionEnd, }: ElementSelectionProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access the element selection context.
+ * Must be used within an ElementSelectionProvider.
+ *
+ * @returns The element selection context value
+ * @throws Error if used outside of ElementSelectionProvider
+ */
+export declare function useElementSelection(): ElementSelectionContextValue;

package/dist/core/ui/Toolbar/context/FlagSdkOverrideProvider.d.ts

@@ -1,14 +1,18 @@
 import { IFlagOverridePlugin } from '../../../../types';
+import { ApiVariation } from '../types/ldApi';
 interface LocalFlag {
     key: string;
     name: string;
     currentValue: any;
     isOverridden: boolean;
-    type: 'boolean' | 'string' | 'number' | 'object';
+    type: 'boolean' | 'multivariate' | 'string' | 'number' | 'object';
+    availableVariations: ApiVariation[];
 }
 interface FlagSdkOverrideContextType {
     flags: Record<string, LocalFlag>;
     isLoading: boolean;
+    setOverride: (flagKey: string, value: any) => void;
+    removeOverride: (flagKey: string) => void;
 }
 interface FlagSdkOverrideProviderProps {
     children: React.ReactNode;

package/dist/core/ui/Toolbar/context/api/ApiBundleProvider.d.ts

@@ -0,0 +1,8 @@
+interface ApiBundleProviderProps {
+    authUrl: string;
+    clientSideId?: string;
+    providedProjectKey?: string;
+    children: React.ReactNode;
+}
+export declare function ApiBundleProvider(props: ApiBundleProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/context/{ApiProvider.d.ts → api/ApiProvider.d.ts}

@@ -1,7 +1,6 @@
-import { FlagsPaginationParams, FlagsResponse, ApiFlag, ProjectsResponse } from '../types/ldApi';
+import { FlagsPaginationParams, FlagsResponse, ProjectsResponse } from '../../types/ldApi';
 interface ApiProviderContextValue {
     apiReady: boolean;
-    getFlag: (flagKey: string) => Promise<ApiFlag>;
     getProjects: () => Promise<ProjectsResponse>;
     getFlags: (projectKey: string, params?: FlagsPaginationParams) => Promise<FlagsResponse>;
 }

package/dist/core/ui/Toolbar/context/{AuthProvider.d.ts → api/AuthProvider.d.ts}

@@ -1,13 +1,13 @@
 import { Dispatch, SetStateAction } from 'react';
-type AuthProviderType = {
+interface AuthContextType {
     authenticated: boolean;
     authenticating: boolean;
     loading: boolean;
     setAuthenticating: Dispatch<SetStateAction<boolean>>;
     logout: () => void;
-};
+}
 export declare function AuthProvider({ children }: {
     children: React.ReactNode;
 }): import("react/jsx-runtime").JSX.Element;
-export declare function useAuthContext(): AuthProviderType;
+export declare function useAuthContext(): AuthContextType;
 export {};

package/dist/core/ui/Toolbar/context/api/ContextsProvider.d.ts

@@ -0,0 +1,19 @@
+import type { LDContext } from 'launchdarkly-js-client-sdk';
+interface ContextsContextType {
+    contexts: LDContext[];
+    filter: string;
+    setFilter: (filter: string) => void;
+    addContext: (context: LDContext) => void;
+    removeContext: (contextId: string) => void;
+    updateContext: (contextId: string, newContext: LDContext) => void;
+    setContext: (context: LDContext) => Promise<void>;
+    activeContext: LDContext | null;
+    isAddFormOpen: boolean;
+    setIsAddFormOpen: (isOpen: boolean) => void;
+    clearContexts: () => void;
+}
+export declare const ContextsProvider: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function useContextsContext(): ContextsContextType;
+export {};

package/dist/core/ui/Toolbar/context/api/EnvironmentProvider.d.ts

@@ -0,0 +1,12 @@
+import { FC } from 'react';
+interface EnvironmentContextType {
+    environment: string;
+    setEnvironment: (environment: string) => void;
+}
+interface EnvironmentProviderProps {
+    children: React.ReactNode;
+    clientSideId?: string;
+}
+export declare const EnvironmentProvider: FC<EnvironmentProviderProps>;
+export declare function useEnvironmentContext(): EnvironmentContextType;
+export {};

package/dist/core/ui/Toolbar/context/{FlagsProvider.d.ts → api/FlagsProvider.d.ts}

@@ -1,12 +1,13 @@
-import { ApiFlag, FlagsResponse } from '../types/ldApi';
-type FlagsContextType = {
+import { ApiFlag, FlagsResponse } from '../../types/ldApi';
+interface FlagsContextType {
     flags: ApiFlag[];
     loading: boolean;
     getProjectFlags: (projectKey: string) => Promise<FlagsResponse>;
     resetFlags: () => void;
-};
+    refreshFlags: () => Promise<void>;
+}
 export declare const FlagsProvider: ({ children }: {
     children: React.ReactNode;
 }) => import("react/jsx-runtime").JSX.Element;
-export declare const useFlagsContext: () => FlagsContextType;
+export declare function useFlagsContext(): FlagsContextType;
 export {};

package/dist/core/ui/Toolbar/context/{ProjectProvider.d.ts → api/ProjectProvider.d.ts}

@@ -1,11 +1,12 @@
-import { ApiProject, ProjectsResponse } from '../types/ldApi';
-type ProjectContextType = {
+import { ApiProject, ProjectsResponse, ApiEnvironment } from '../../types/ldApi';
+interface ProjectContextType {
     projectKey: string;
     setProjectKey: (projectKey: string) => void;
     getProjects: () => Promise<ProjectsResponse>;
     projects: ApiProject[];
+    environments: ApiEnvironment[];
     loading: boolean;
-};
+}
 interface ProjectProviderProps {
     children: React.ReactNode;
     clientSideId?: string;

package/dist/core/ui/Toolbar/context/api/index.d.ts

@@ -0,0 +1,8 @@
+export * from './ApiBundleProvider';
+export * from './ApiProvider';
+export * from './AuthProvider';
+export * from './ContextsProvider';
+export * from './EnvironmentProvider';
+export * from './FlagsProvider';
+export * from './IFrameProvider';
+export * from './ProjectProvider';

package/dist/core/ui/Toolbar/context/index.d.ts

@@ -1,7 +1,7 @@
-export { DevServerProvider, useDevServerContext } from './DevServerProvider';
-export { SearchProvider, useSearchContext } from './SearchProvider';
-export { ActiveTabProvider, useActiveTabContext } from './ActiveTabProvider';
-export { ToolbarUIProvider, useToolbarUIContext } from './ToolbarUIProvider';
-export { FlagSdkOverrideProvider, useFlagSdkOverrideContext, type LocalFlag, type FlagSdkOverrideContextType, } from './FlagSdkOverrideProvider';
-export { AnalyticsProvider, useAnalytics } from './AnalyticsProvider';
-export { StarredFlagsProvider, useStarredFlags } from './StarredFlagsProvider';
+export * from './api';
+export * from './state';
+export * from './telemetry';
+export * from './DevServerProvider';
+export * from './FlagSdkOverrideProvider';
+export * from './StarredFlagsProvider';
+export * from './ElementSelectionProvider';

package/dist/core/ui/Toolbar/context/{ActiveTabProvider.d.ts → state/ActiveTabProvider.d.ts}

@@ -1,8 +1,8 @@
-import type { ActiveTabId } from '../types/toolbar';
-type ActiveTabContextType = {
+import type { ActiveTabId } from '../../types';
+interface ActiveTabContextType {
     activeTab: ActiveTabId;
     setActiveTab: (tab: ActiveTabId) => void;
-};
+}
 export declare function ActiveTabProvider({ children }: {
     children: React.ReactNode;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/context/state/PluginsProvider.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { IEventInterceptionPlugin, IFlagOverridePlugin } from '../../../../../types';
+interface PluginsContextValue {
+    baseUrl: string;
+    flagOverridePlugin?: IFlagOverridePlugin;
+    eventInterceptionPlugin?: IEventInterceptionPlugin;
+}
+export interface PluginsProviderProps {
+    children: ReactNode;
+    baseUrl: string;
+    flagOverridePlugin?: IFlagOverridePlugin;
+    eventInterceptionPlugin?: IEventInterceptionPlugin;
+}
+export declare function PluginsProvider({ children, baseUrl, flagOverridePlugin, eventInterceptionPlugin, }: PluginsProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function usePlugins(): PluginsContextValue;
+export {};

package/dist/core/ui/Toolbar/context/{SearchProvider.d.ts → state/SearchProvider.d.ts}

@@ -1,8 +1,8 @@
 import React, { Dispatch, type SetStateAction } from 'react';
-type SearchContextType = {
+interface SearchContextType {
     searchTerm: string;
     setSearchTerm: Dispatch<SetStateAction<string>>;
-};
+}
 export declare function SearchProvider({ children }: {
     children: React.ReactNode;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/core/ui/Toolbar/context/state/ToolbarStateBundleProvider.d.ts

@@ -0,0 +1,13 @@
+import { IEventInterceptionPlugin, IFlagOverridePlugin } from '../../../../../types';
+import { ToolbarPosition } from '../../types';
+interface ToolbarStateBundleProviderProps {
+    initialPosition?: ToolbarPosition;
+    domId: string;
+    devServerUrl?: string;
+    baseUrl: string;
+    flagOverridePlugin?: IFlagOverridePlugin;
+    eventInterceptionPlugin?: IEventInterceptionPlugin;
+    children: React.ReactNode;
+}
+export declare function ToolbarStateBundleProvider(props: ToolbarStateBundleProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/ui/Toolbar/context/state/ToolbarStateProvider.d.ts

@@ -0,0 +1,35 @@
+import React, { Dispatch, SetStateAction, ReactNode } from 'react';
+import { ActiveTabId, ToolbarMode } from '../../types';
+export interface ToolbarStateContextValue {
+    isExpanded: boolean;
+    previousTab: ActiveTabId;
+    isAnimating: boolean;
+    searchIsExpanded: boolean;
+    slideDirection: number;
+    hasBeenExpanded: boolean;
+    reloadOnFlagChangeIsEnabled: boolean;
+    isAutoCollapseEnabled: boolean;
+    mode: ToolbarMode;
+    isOptedInToAnalytics: boolean;
+    isOptedInToEnhancedAnalytics: boolean;
+    isOptedInToSessionReplay: boolean;
+    toolbarRef: React.RefObject<HTMLDivElement | null>;
+    handleTabChange: (tabId: string) => void;
+    handleClose: () => void;
+    handleSearch: (newSearchTerm: string) => void;
+    handleToggleReloadOnFlagChange: () => void;
+    handleToggleAutoCollapse: () => void;
+    handleCircleClick: () => void;
+    setIsAnimating: Dispatch<SetStateAction<boolean>>;
+    setSearchIsExpanded: Dispatch<SetStateAction<boolean>>;
+    handleToggleAnalyticsOptOut: (enabled: boolean) => void;
+    handleToggleEnhancedAnalyticsOptOut: (enabled: boolean) => void;
+    handleToggleSessionReplayOptOut: (enabled: boolean) => void;
+}
+export interface ToolbarStateProviderProps {
+    children: ReactNode;
+    domId: string;
+    devServerUrl?: string;
+}
+export declare function ToolbarStateProvider({ children, domId, devServerUrl }: ToolbarStateProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useToolbarState(): ToolbarStateContextValue;

package/dist/core/ui/Toolbar/context/{ToolbarUIProvider.d.ts → state/ToolbarUIProvider.d.ts}

@@ -1,5 +1,5 @@
 import type { FC, ReactNode } from 'react';
-import type { ToolbarPosition } from '../types/toolbar';
+import { ToolbarPosition } from '../../types';
 interface ToolbarUIContextValue {
     position: ToolbarPosition;
     handlePositionChange: (position: ToolbarPosition) => void;

package/dist/core/ui/Toolbar/context/state/index.d.ts

@@ -0,0 +1,6 @@
+export * from './ActiveTabProvider';
+export * from './PluginsProvider';
+export * from './SearchProvider';
+export * from './ToolbarStateBundleProvider';
+export * from './ToolbarStateProvider';
+export * from './ToolbarUIProvider';