import * as react_jsx_runtime from 'react/jsx-runtime';
import { ReactElement, ReactNode } from 'react';

interface Tab<TabName extends string = string> {
    name: TabName;
    Component: () => ReactElement;
    CustomHeader?: () => ReactElement;
    TabIcon: () => ReactElement;
}

interface OnCallbackSet {
    id: string;
    unsubscribe: () => void;
}
interface Callback<T> {
    id: string;
    callback: T;
}

/** Function signature for when active tab changes */
type OnActiveTabChangedCallback<TabName, TController> = (to: TabName, from: TabName | undefined, controller: TController) => void;
/** Function signature for when sidesheet opens or closes */
type OnSidesheetOpenOrClosedCallback<TController> = (isOpen: boolean, controller: TController) => void;
/** Function signature for when filter opens or closes */
type OnFilterOpenOrClosedCallback<TController> = (isOpen: boolean, controller: TController) => void;
/** Function signature for when isLoading changes */
type OnIsLoadingChangedCallback<TController> = (isLoading: boolean, controller: TController) => void;
/** Function signature for when sidesheet width changes */
type OnWidthChange = (newWidth: number) => void;

type Provider = {
    name: string;
    Component: React.FC<{
        children: ReactNode;
    }>;
};

type WorkspaceEvents = {
    onTabChange?: (newTab: string, tabs: Tab[]) => void;
};
interface WorkspaceProps {
    defaultTab?: string;
    tabs: Tab[];
    Sidesheet?: () => ReactElement;
    providers: Provider[];
    events?: WorkspaceEvents;
}
type TabController$1 = {
    activeTab: string;
    setActiveTab: (name: string) => void;
};
declare function Workspace({ tabs, defaultTab, Sidesheet, providers, events }: WorkspaceProps): react_jsx_runtime.JSX.Element;

type OnchangeCallback<TValue> = (newValue: TValue, oldValue?: TValue) => void;

declare class StateController {
    isLoading: boolean | undefined;
    setIsLoading: (value: boolean) => void;
    onIsLoadingChanged: (callback: OnchangeCallback<boolean>) => () => void;
    constructor();
}

declare class TabController<TabNames extends string> {
    activeTab: TabNames | undefined;
    setActiveTab: (value: TabNames) => void;
    onActiveTabChanged: (callback: OnchangeCallback<TabNames>) => () => void;
    tabs: Tab<TabNames>[];
    addTab(tab: Tab<TabNames>): this;
    constructor();
}

declare class WorkspaceViewController<TTabNames extends string, TError> {
    appKey?: string;
    appColor?: string;
    viewState: StateController;
    tabController: TabController<TTabNames>;
    providers: Provider[];
    Sidesheet: (() => ReactElement) | undefined;
    addProvider: (provider: Provider) => void;
    addSidesheetComponent: (comp: () => ReactElement) => void;
    constructor(defaultTab?: TTabNames);
    error?: TError;
    setError: (value: TError | undefined) => void;
    onError: (callback: OnchangeCallback<TError | undefined>) => () => void;
    /** Component for handling errors */
    ErrorComponent?: (error: ErrorProps<TError>) => ReactElement;
    /** Function for refetching data */
    refetchData?: () => Promise<void> | null;
    destroy: () => void;
}
type ErrorProps<TError> = {
    error: TError;
};

declare const useTabContext: <U>(selector: (s: TabController$1) => U) => U;
declare const useTabs: () => Tab<string>[];
declare const useSetActiveTab: () => (name: string) => void;
declare const useActiveTab: () => Tab<string> | undefined;

export { type Callback, type OnActiveTabChangedCallback, type OnCallbackSet, type OnFilterOpenOrClosedCallback, type OnIsLoadingChangedCallback, type OnSidesheetOpenOrClosedCallback, type OnWidthChange, type Provider, type Tab, Workspace, WorkspaceViewController, useActiveTab, useSetActiveTab, useTabContext, useTabs };