@vertesia/ui 0.56.0 → 0.58.0

package/lib/types/core/components/table/index.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+export declare function Table({ className, children, ...others }: React.HTMLProps<HTMLTableElement>): import("react/jsx-runtime").JSX.Element;
+export declare function RowSkeleton({ columns }: {
+    columns: number;
+}): import("react/jsx-runtime").JSX.Element;
+interface TBodySkeletonProps {
+    isLoading?: boolean;
+    columns: number;
+    rows?: number;
+    children: React.ReactNode;
+}
+export declare function TBody({ isLoading, columns, rows, children }: TBodySkeletonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/tabs/Tabs.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+import { Tab } from './TabsContext.js';
+interface TabsProps {
+    current?: string | (() => string);
+    /**
+     * Return false to prevent the tab from being selected
+     * @param tab
+     * @returns
+     */
+    onSelect?: (tab: Tab) => void | boolean;
+    tabs: Tab[];
+    children: ReactNode | ReactNode[];
+    navigate?: (path: string) => void;
+}
+export declare function Tabs({ current, onSelect, tabs, children, navigate }: TabsProps): import("react/jsx-runtime").JSX.Element;
+interface TabsBarProps {
+    actions?: ReactNode | ReactNode[];
+    className?: string;
+}
+export declare function TabsBar({ actions, className }: TabsBarProps): import("react/jsx-runtime").JSX.Element;
+interface TabsPanelProps {
+}
+export declare function TabsPanel({}: TabsPanelProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/lib/types/core/components/tabs/TabsContext.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from "react";
+export interface Tab {
+    name: string;
+    current?: boolean;
+    href?: string;
+    label: ReactNode;
+    content: ReactNode;
+    disabled?: boolean;
+}
+export interface TabsContextProps {
+    tabs: Tab[];
+    select: (tab: Tab) => void;
+}
+export declare function useTabs(): TabsContextProps;
+declare const TabsContext: import("react").Context<TabsContextProps>;
+export { TabsContext };

package/lib/types/core/components/tabs/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Tabs.js";
+export * from "./TabsContext.js";

package/lib/types/core/components/toast/NotificationPanel.d.ts

@@ -0,0 +1,7 @@
+import { ToastProps } from "./ToastProps.js";
+interface NotificationPanelProps {
+    data: ToastProps;
+    onClose: () => void;
+}
+export declare function NotificationPanel({ data, onClose }: NotificationPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/toast/ToastContext.d.ts

@@ -0,0 +1,5 @@
+import { ToastProps } from "./ToastProps.js";
+export declare function useToast(): ToastFn;
+export type ToastFn = (data: ToastProps) => void;
+declare const ToastContext: import("react").Context<ToastFn>;
+export { ToastContext };

package/lib/types/core/components/toast/ToastProps.d.ts

@@ -0,0 +1,6 @@
+export interface ToastProps {
+    status: 'success' | 'error' | 'warning' | 'info';
+    title: string;
+    description?: string;
+    duration?: number;
+}

package/lib/types/core/components/toast/ToastProvider.d.ts

@@ -0,0 +1,5 @@
+interface ToastProviderProps {
+    children: React.ReactNode | React.ReactNode[];
+}
+export declare function ToastProvider({ children }: ToastProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/toast/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ToastContext.js";
+export * from "./ToastProvider.js";

package/lib/types/core/hooks/CompositeState.d.ts

@@ -0,0 +1,27 @@
+import React, { ReactNode } from "react";
+export declare class Property<V = any> {
+    _value?: V;
+    watchers: ((value: V) => void)[];
+    constructor(value?: V);
+    get value(): any;
+    set value(value: any);
+    watch(watcher: (value: any) => void): () => void;
+}
+type ConstructorOf<T = any> = new (...args: any[]) => T;
+export declare function createCompositeStateProvider<T>(StateClass: ConstructorOf<T>): React.Provider<T>;
+export declare class Slot {
+    private consume;
+    private _current;
+    constructor(content?: ReactNode);
+    set current(content: ReactNode);
+    get current(): ReactNode;
+    withConsumer(consume: ((content: ReactNode) => void) | undefined): this;
+}
+export declare function useCompositeState<T>(StateClass: ConstructorOf<T>): T;
+export declare function useGetCompositeStateProperty<V>(property: Property<V>): V;
+export declare function useSetCompositeStateProperty<V>(property: Property<V>, value: V | undefined): V | undefined;
+export declare function useWatchCompositeStateProperty<V>(property: Property<V>, watcher: (value: V | undefined) => void): void;
+export declare function useSlot(slot: Slot): string | number | bigint | boolean | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | React.ReactPortal | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
+export declare function useWatchSlot(slot: Slot, watcher: (value: ReactNode | undefined) => void): void;
+export declare function useDefineSlot(slot: Slot, value: ReactNode | undefined): void;
+export {};

package/lib/types/core/hooks/SharedState.d.ts

@@ -0,0 +1,9 @@
+export declare class SharedState<V = any> {
+    _value: V;
+    watchers: ((value: V) => void)[];
+    constructor(value: V);
+    get value(): V;
+    set value(value: V);
+    addWatcher(watcher: (value: V) => void): () => void;
+}
+export declare function useWatchSharedState<T>(state: SharedState<T>): T;

package/lib/types/core/hooks/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./CompositeState.js";
+export * from "./SharedState.js";
+export * from "./useClickOutside.js";
+export * from "./useCopyToClipboard.js";
+export * from "./useDarkMode.js";
+export * from "./useDebounce";
+export * from "./useEventSource.js";
+export * from "./useFetch.js";
+export * from "./useFlag.js";
+export * from "./useIntersectionObserver.js";
+export * from "./useIsFistRendering.js";
+export * from "./useSafeLayoutEffect.js";
+export * from "./useSharedValue.js";

package/lib/types/core/hooks/useClickOutside.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param callback
+ * @param skipFn an optional function to skip the callback if the event matches some condition. Return true to skip
+ * @returns
+ */
+export declare function useClickOutside<T extends HTMLElement>(callback: (e: MouseEvent) => void, skipFn?: (e: MouseEvent) => boolean): import("react").RefObject<T | null>;

package/lib/types/core/hooks/useCopyToClipboard.d.ts

@@ -0,0 +1,4 @@
+type CopiedValue = string | null;
+type CopyFn = (text: string) => Promise<boolean>;
+export declare function useCopyToClipboard(): [CopiedValue, CopyFn];
+export {};

package/lib/types/core/hooks/useDarkMode.d.ts

@@ -0,0 +1 @@
+export declare function useDarkMode(cb: (isDarkMode: boolean) => unknown): void;

package/lib/types/core/hooks/useDebounce.d.ts

@@ -0,0 +1 @@
+export declare function useDebounce(value: string, delay: number): string;

package/lib/types/core/hooks/useEventSource.d.ts

@@ -0,0 +1 @@
+export declare function useEventSource<T>(url: string | (() => Promise<string>), onMessage: (content: string) => void, onCompleted: (payload: T) => void): void;

package/lib/types/core/hooks/useFetch.d.ts

@@ -0,0 +1,23 @@
+export interface FetchOpts<T> {
+    start?: () => void;
+    end?: () => void;
+    defaultValue?: T | (() => T);
+    deps?: any[] | undefined;
+    condition?: () => boolean;
+    onSuccess?: (data: T) => void;
+    onError?: (err: any) => void;
+}
+export declare function useFetch<T = any>(fetcher: () => Promise<T>, opts?: FetchOpts<T> | any[] | undefined | null): {
+    data: T | undefined;
+    isLoading: boolean;
+    error: any;
+    setData: import("react").Dispatch<import("react").SetStateAction<T | undefined>>;
+    refetch: () => Promise<void>;
+};
+export declare function useFetchOnce<T>(fetcher: () => Promise<T>, opts?: FetchOpts<T> | any[] | undefined | null): {
+    data: T | undefined;
+    isLoading: boolean;
+    error: any;
+    setData: import("react").Dispatch<import("react").SetStateAction<T | undefined>>;
+    refetch: () => Promise<void>;
+};

package/lib/types/core/hooks/useFlag.d.ts

@@ -0,0 +1,8 @@
+export declare function useFlag(isOn?: boolean): {
+    isOn: boolean;
+    isOff: boolean;
+    set: (value: boolean) => void;
+    on: () => void;
+    off: () => void;
+    toggle: () => void;
+};

package/lib/types/core/hooks/useIntersectionObserver.d.ts

@@ -0,0 +1,13 @@
+import { RefObject } from "react";
+/**
+ * if leave option is true then callback will be called when the target leaves the viewport
+ * otherwise when it enters the viewport
+ * @param target
+ * @param cb
+ * @param opts
+ */
+export declare function useIntersectionObserver(target: RefObject<HTMLElement | null | undefined>, cb: (entry: IntersectionObserverEntry) => void, opts?: {
+    leave?: boolean;
+    threshold?: number;
+    deps?: any[];
+}): void;

package/lib/types/core/hooks/useIsFistRendering.d.ts

@@ -0,0 +1 @@
+export declare function useIsFirstRendering(): boolean;

package/lib/types/core/hooks/useSafeLayoutEffect.d.ts

@@ -0,0 +1,3 @@
+import { useEffect } from "react";
+declare const useSafeLayoutEffect: typeof useEffect;
+export { useSafeLayoutEffect };

package/lib/types/core/hooks/useSharedValue.d.ts

@@ -0,0 +1,11 @@
+import { Dispatch, SetStateAction } from "react";
+export declare class SharedValue<T> {
+    private state;
+    constructor(state: [T, Dispatch<SetStateAction<T>>]);
+    get(): T;
+    set(value: T): void;
+}
+/**
+ * Share a stateful value
+ */
+export declare function useSharedValue<T>(initialValue: T | (() => T)): SharedValue<T>;

package/lib/types/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./hooks/index.js";
+export * from "./components/index.js";

package/lib/types/env/index.d.ts

@@ -0,0 +1,70 @@
+import { AuthTokenPayload } from "@vertesia/common";
+export interface EnvProps {
+    name: string;
+    version: string;
+    isLocalDev: boolean;
+    isDocker: boolean;
+    type: "production" | "staging" | "preview" | "development" | string;
+    endpoints: {
+        zeno: string;
+        studio: string;
+    };
+    firebase: {
+        apiKey: string;
+        authDomain: string;
+        projectId: string;
+        appId?: string;
+        providerType?: string;
+    };
+    datadog: boolean;
+    logger?: {
+        info: (msg: string, ...args: any) => void;
+        warn: (msg: string, ...args: any) => void;
+        error: (msg: string, ...args: any) => void;
+        debug: (msg: string, ...args: any) => void;
+    };
+    onLogin?: (token: AuthTokenPayload) => void;
+    onLogout?: () => void;
+}
+export declare class VertesiaEnvironment implements Readonly<EnvProps> {
+    private _props?;
+    constructor(_props?: EnvProps | undefined);
+    init(props?: EnvProps): this;
+    private prop;
+    get version(): string;
+    get name(): string;
+    get type(): string;
+    get isProd(): boolean;
+    get isDev(): boolean;
+    get isPreview(): boolean;
+    get isLocalDev(): boolean;
+    get isDocker(): boolean;
+    get endpoints(): {
+        zeno: string;
+        studio: string;
+    };
+    get firebase(): {
+        apiKey: string;
+        authDomain: string;
+        projectId: string;
+        appId?: string;
+        providerType?: string;
+    };
+    get datadog(): boolean;
+    get logger(): {
+        info: (msg: string, ...args: any) => void;
+        warn: (msg: string, ...args: any) => void;
+        error: (msg: string, ...args: any) => void;
+        debug: (msg: string, ...args: any) => void;
+    };
+    /**
+     * Callback to notify the host app when the user logs in.
+     */
+    onLogin(token: AuthTokenPayload): void;
+    /**
+     * Callback to notify the host app when the user logs out
+     */
+    onLogout(): void;
+}
+declare const Env: VertesiaEnvironment;
+export { Env };

package/lib/types/features/activity-doc/ActivityDoc.d.ts

@@ -0,0 +1,13 @@
+import { ActivityDefinition } from "@vertesia/common";
+import React from "react";
+interface ActivitiesDocProps {
+    activities: ActivityDefinition[];
+}
+export declare function ActivitiesDoc({ activities }: ActivitiesDocProps): import("react/jsx-runtime").JSX.Element;
+interface ActivityDocProps {
+    activity: ActivityDefinition;
+    headingRef?: React.RefObject<HTMLDivElement>;
+    headingClass?: string;
+}
+export declare function ActivityDoc({ activity, headingClass, headingRef }: ActivityDocProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/activity-doc/index.d.ts

@@ -0,0 +1 @@
+export * from "./ActivityDoc";

package/lib/types/features/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./permissions/index.js";
+export * from "./activity-doc/index.js";

package/lib/types/features/permissions/SecureButton.d.ts

@@ -0,0 +1,7 @@
+import { Permission } from "@vertesia/common";
+import { ButtonProps } from "@vertesia/ui/core";
+interface SecureButtonProps extends ButtonProps {
+    permission: Permission | Permission[];
+}
+export declare function SecureButton({ permission, isDisabled, title, children, ...others }: SecureButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/features/permissions/SecureSidebarItem.d.ts

@@ -0,0 +1,7 @@
+import { Permission } from "@vertesia/common";
+import { SidebarItemProps } from "@vertesia/ui/layout";
+interface SecureSidebarItemProps extends SidebarItemProps {
+    permission: Permission | Permission[];
+}
+export declare function SecureSidebarItem({ permission, ...others }: SecureSidebarItemProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/lib/types/features/permissions/UserPermissionsProvider.d.ts

@@ -0,0 +1,19 @@
+import { Permission, ProjectRoles } from "@vertesia/common";
+import { UserSession } from "@vertesia/ui/session";
+type ListRolesResponse = {
+    name: ProjectRoles;
+    permissions: Permission[];
+}[];
+export declare class UserPermissions {
+    system_roles: ListRolesResponse;
+    roles: Set<string>;
+    permissions: Set<string>;
+    constructor(session: UserSession, roles: ListRolesResponse);
+    hasPermission(permission: string | string[]): boolean;
+}
+export declare function useUserPermissions(): UserPermissions;
+interface UserPermissionProviderProps {
+    children: React.ReactNode;
+}
+export declare function UserPermissionProvider({ children }: UserPermissionProviderProps): import("react/jsx-runtime").JSX.Element | undefined;
+export {};

package/lib/types/features/permissions/helpers.d.ts

@@ -0,0 +1,4 @@
+import { Permission } from "@vertesia/common";
+export declare function AnyOf(...permissions: Permission[]): Permission[];
+export declare function AllOf(...permissions: Permission[]): Permission[];
+export declare function isAnyOf(permissions: Permission[]): boolean;

package/lib/types/features/permissions/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./SecureButton";
+export * from "./SecureSidebarItem";
+export * from "./UserPermissionsProvider";
+export * from "./helpers";

package/lib/types/layout/AppLayout.d.ts

@@ -0,0 +1,12 @@
+interface AppLayoutProps {
+    title?: string;
+    children: React.ReactNode | React.ReactNode[];
+    logo?: React.ReactNode;
+    navbar?: React.ReactNode | React.ReactNode[];
+    sidebar?: React.ReactNode | React.ReactNode[];
+    mainNav?: React.ReactNode;
+    className?: string;
+    sidebarClassName?: string;
+}
+export declare function AppLayout({ sidebarClassName, className, title, children, logo, navbar, sidebar, mainNav }: AppLayoutProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/layout/FullHeightLayout.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+interface FlexibleHeightLayoutProps {
+    children: (React.ReactElement | undefined | null) | (React.ReactElement | undefined | null)[];
+    className?: string;
+}
+export declare function FullHeightLayout({ className, children }: FlexibleHeightLayoutProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace FullHeightLayout {
+    var Fixed: ({ heightClass, className, children }: FixedProps) => import("react/jsx-runtime").JSX.Element;
+    var Body: ({ className, children }: BodyProps) => import("react/jsx-runtime").JSX.Element;
+    var VR: ({}: VDividerProps) => import("react/jsx-runtime").JSX.Element;
+    var HR: ({}: HDividerProps) => import("react/jsx-runtime").JSX.Element;
+}
+interface FixedProps {
+    children: React.ReactNode;
+    heightClass: string;
+    className?: string;
+}
+interface BodyProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface VDividerProps {
+}
+interface HDividerProps {
+}
+export {};

package/lib/types/layout/Navbar.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import { HeroIcon } from '@vertesia/ui/core';
+interface NavbarProps {
+    title?: string;
+    onSearch?: (query: string) => void;
+    logo?: React.ReactNode;
+    children: React.ReactNode | React.ReactNode[];
+}
+export declare function Navbar({ children, logo, onSearch, title }: NavbarProps): import("react/jsx-runtime").JSX.Element;
+export declare function HamburgerButton(): import("react/jsx-runtime").JSX.Element;
+interface NavbarSeparatorProps {
+    visible?: "mobile" | "desktop";
+}
+export declare function NavbarSeparator({ visible }: NavbarSeparatorProps): import("react/jsx-runtime").JSX.Element;
+interface NavbarIconButtonProps {
+    title: string;
+    icon: HeroIcon;
+    onClick?: (ev: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+}
+export declare function NavbarIconButton({ title, icon: Icon, onClick }: NavbarIconButtonProps): import("react/jsx-runtime").JSX.Element;
+interface NavbarButtonProps {
+    children: React.ReactNode | React.ReactNode[];
+    onClick?: (ev: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+}
+export declare function NavbarButton({ children, onClick }: NavbarButtonProps): import("react/jsx-runtime").JSX.Element;
+interface NavbarLinkProps {
+    href: string;
+    children: React.ReactNode | React.ReactNode[];
+    onClick?: (ev: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => void;
+}
+export declare function NavbarLink({ href, onClick, children }: NavbarLinkProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/layout/Sidebar.d.ts

@@ -0,0 +1,29 @@
+interface SidebarProps {
+    children: React.ReactNode | React.ReactNode[];
+    logo?: React.ReactNode;
+    className?: string;
+}
+export declare function Sidebar({ children, logo, className }: SidebarProps): import("react/jsx-runtime").JSX.Element;
+interface SidebarSectionProps {
+    children: React.ReactNode | React.ReactNode[];
+    title?: React.ReactNode;
+    action?: React.ReactNode;
+    isFooter?: boolean;
+}
+export declare function SidebarSection({ children, title, action, isFooter }: SidebarSectionProps): import("react/jsx-runtime").JSX.Element;
+export declare function SidebarTooltip({ children, text }: {
+    children: React.ReactNode;
+    text?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export interface SidebarItemProps {
+    href: string;
+    icon?: React.ComponentType<React.HTMLAttributes<Element>>;
+    current?: boolean;
+    onClick?: (event: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => void;
+    children: React.ReactNode | React.ReactNode[];
+    tools?: React.ReactNode;
+    className?: string;
+    id?: string;
+}
+export declare function SidebarItem({ className, tools, children, icon: Icon, href, current, onClick }: SidebarItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/layout/SidebarContext.d.ts

@@ -0,0 +1,8 @@
+interface SidebarContextType {
+    isOpen: boolean;
+    toggleMobile: (isOpen?: boolean) => void;
+    toggleDesktop: (isOpen?: boolean) => void;
+}
+export declare const SidebarContext: import("react").Context<SidebarContextType>;
+export declare function useSidebarToggle(): SidebarContextType;
+export {};

package/lib/types/layout/TitleBar.d.ts

@@ -0,0 +1,5 @@
+interface TitleBarProps {
+    title?: string;
+}
+export declare function TitleBar({ title }: TitleBarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/layout/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./FullHeightLayout.js";
+export * from "./AppLayout.js";
+export * from "./Navbar.js";
+export * from "./Sidebar.js";
+export * from "./SidebarContext.js";
+export * from "./TitleBar.js";

package/lib/types/router/FixLinks.d.ts

@@ -0,0 +1,6 @@
+interface FixLinksProps {
+    basePath: string;
+    children: React.ReactNode | React.ReactNode[];
+}
+export declare function FixLinks({ basePath, children }: FixLinksProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/router/HistoryNavigator.d.ts

@@ -0,0 +1,55 @@
+declare const BASE_PATH: unique symbol;
+export { BASE_PATH };
+export type LocationChangeEventName = 'beforeChange' | 'afterChange';
+export type LocationChangeType = 'initial' | 'popState' | 'linkClick' | 'navigate';
+export declare class LocationChangeEvent {
+    name: LocationChangeEventName;
+    type: LocationChangeType;
+    location: URL;
+    state?: any | undefined;
+    _canceled: boolean;
+    constructor(name: LocationChangeEventName, type: LocationChangeType, location: URL, state?: any | undefined);
+    get isPageLoad(): boolean;
+    get isBackForward(): boolean;
+    get isLinkClick(): boolean;
+    get isNavigation(): boolean;
+    get isCancelable(): boolean;
+    cancel(): void;
+}
+export declare class BeforeLocationChangeEvent extends LocationChangeEvent {
+    constructor(type: LocationChangeType, location: URL, state?: any);
+}
+export declare class AfterLocationChangeEvent extends LocationChangeEvent {
+    constructor(type: LocationChangeType, location: URL, state?: any);
+}
+export interface NavigateOptions {
+    replace?: boolean;
+    state?: any;
+    /**
+     * if defined prepend the basePath to the `to` argument
+     */
+    basePath?: string;
+    /**
+     * if defined, indicate whether the basePath will be used as a top-level base path or a nested base path.
+     */
+    isBasePathNested?: boolean;
+}
+export declare class HistoryNavigator {
+    stickyParams?: Record<string, string>;
+    _popStateListener?: (ev: PopStateEvent) => void;
+    _linkNavListener?: (ev: MouseEvent) => void;
+    _listeners: ((event: LocationChangeEvent) => void)[];
+    constructor();
+    addListener(listener: (event: LocationChangeEvent) => void): void;
+    fireLocationChange(event: LocationChangeEvent): void;
+    /**
+     * Should be called when the page is first loaded.
+     * It will fire a location change event with type `initial` and the current window.location as the location
+     */
+    firePageLoad(): void;
+    addStickyParams(path: string): string;
+    navigate(to: string, options?: NavigateOptions): void;
+    _navigate(to: URL, type: LocationChangeType, options: NavigateOptions): void;
+    start(): void;
+    stop(): void;
+}

package/lib/types/router/Nav.d.ts

@@ -0,0 +1,28 @@
+import { SyntheticEvent } from "react";
+/**
+ * Wraps a <a href="..."> and perform the navigation to href through the router.
+ */
+interface NavProps {
+    children: React.ReactNode | React.ReactNode[];
+    /**
+     * A click was intercepted
+     * @param ev
+     * @returns
+     */
+    onClick?: (ev: SyntheticEvent) => void;
+}
+export declare function Nav({ children, onClick }: NavProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * A anchor tag that performs navigation through the router.
+ */
+interface NavLinkProps {
+    children: React.ReactNode | React.ReactNode[];
+    href: string;
+    className?: string;
+    /**
+     * use the root router to navigate
+     */
+    topLevelNav?: boolean;
+}
+export declare function NavLink({ children, href, className, topLevelNav }: NavLinkProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/router/NestedNavigationContext.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+interface NestedNavigationContextProps {
+    basePath: string;
+    fixLinks?: boolean;
+    children: React.ReactNode | React.ReactNode[];
+}
+export declare function NestedNavigationContext({ basePath, fixLinks, children }: NestedNavigationContextProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/router/NestedRouterProvider.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { Route } from "./Router";
+interface RouterProviderProps {
+    routes: Route[];
+    /**
+     * The path to use for the root resource. Defaults to '/'. Cannot contains path variables or wildcards
+     */
+    index?: string;
+    children?: React.ReactNode;
+    fixLinks?: boolean;
+}
+export declare function NestedRouterProvider({ routes, index, children, fixLinks }: RouterProviderProps): import("react/jsx-runtime").JSX.Element | undefined;
+export {};