prometeo-design-system 3.1.5 → 3.1.6

package/dist/components/Image/LightBox.d.ts

@@ -0,0 +1,14 @@
+import { ImageProps } from './Image';
+interface LightBoxProps {
+    images: ImageProps[];
+    lightboxClassName?: string;
+    closeLightbox: () => void;
+    showThumbnails?: boolean;
+    thumbnailsClassName?: string;
+    currentIndex: number;
+    goToNext: () => void;
+    goToPrevious: () => void;
+    goToIndex: (index: number) => void;
+}
+declare const LightBox: import('react').MemoExoticComponent<({ images, lightboxClassName, closeLightbox, showThumbnails, thumbnailsClassName, currentIndex, goToNext, goToPrevious, goToIndex }: LightBoxProps) => import("react/jsx-runtime").JSX.Element | null>;
+export default LightBox;

package/dist/components/Image/index.d.ts

@@ -0,0 +1,5 @@
+export { default as Image } from './Image';
+export { default as ImageGallery } from './ImageGallery';
+export { useImageGallery } from './useImageGallery';
+export type { ImageProps } from './Image';
+export type { ImageGalleryHandle } from './ImageGallery';

package/dist/components/Image/useImageGallery.d.ts

@@ -0,0 +1,10 @@
+import { ImageGalleryHandle } from './ImageGallery';
+import { ImageProps } from './Image';
+export declare const useImageGallery: () => {
+    isOpen: () => boolean;
+    openLightbox: () => void;
+    closeLightbox: () => void;
+    galleryRef: import('react').RefObject<ImageGalleryHandle | null>;
+    addImage: (image: ImageProps) => void;
+    images: () => ImageProps[];
+};

package/dist/components/Input/Input.d.ts

@@ -0,0 +1,34 @@
+export type InputVariant = "default" | "error" | "success";
+export type InputSize = "small" | "medium" | "large";
+export type LabelVariant = "default" | "static";
+export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size" | "onChange"> {
+    label: string;
+    icon?: React.ReactNode;
+    iconPosition?: "left" | "right";
+    isFetching?: boolean;
+    id?: string;
+    value?: string;
+    width?: string;
+    height?: string;
+    name?: string;
+    variant?: InputVariant;
+    labelVariant?: LabelVariant;
+    size?: InputSize;
+    disabled?: boolean;
+    type?: "text" | "email" | "password" | "number" | "tel" | "url";
+    errorComponent?: React.ReactNode | string;
+    helperComponent?: React.ReactNode | string;
+    placeholder?: string;
+    required?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    readOnly?: boolean;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    onClear?: () => void;
+    onFocus?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+    onKeyUp?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+}
+declare const _default: import('react').NamedExoticComponent<InputProps & import('react').RefAttributes<HTMLInputElement>>;
+export default _default;

package/dist/components/InputMultiple/InputMultiple.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+export interface InputMultipleProps {
+    label: string;
+    name: string;
+    onChange: (value: string[]) => void;
+    value: string[];
+    icon?: React.ReactNode;
+    valueSeparator?: ',' | ';';
+    variant?: 'default' | 'error' | 'success' | 'warning';
+    placeholder?: string;
+    itemClassName?: string;
+    itemIcon?: React.ComponentType<{
+        size: number;
+        className: string;
+    }>;
+    helperText?: string | React.ReactNode;
+    errorText?: string | React.ReactNode;
+    disabled?: boolean;
+    onClick?: (e: React.MouseEvent) => void;
+    className?: string;
+    readonly?: boolean;
+    onValueDelete?: (value: string) => void;
+}
+declare const _default: React.MemoExoticComponent<({ label, name, onChange, value, icon, valueSeparator, variant, placeholder, itemClassName, itemIcon, helperText, errorText, disabled, onClick, className, readonly, onValueDelete, ...rest }: InputMultipleProps) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

package/dist/components/Layout/LayoutGeneric.d.ts

@@ -0,0 +1,6 @@
+export interface LayoutGenericProps {
+    children: React.ReactNode;
+    sidebar?: React.ReactNode;
+}
+declare const _default: import('react').MemoExoticComponent<({ children, sidebar }: LayoutGenericProps) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

package/dist/components/Logo/Logo.d.ts

@@ -0,0 +1,2 @@
+declare const Logo: () => import("react/jsx-runtime").JSX.Element;
+export default Logo;

package/dist/components/Menu/MenuComposable.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+export interface IMenuRoot {
+    menuRef: React.RefObject<HTMLDivElement | null>;
+    children: ReactNode;
+    className?: string;
+}
+export interface IMenuItems {
+    onClick?: () => void;
+    children: ReactNode;
+    className?: string;
+}
+export declare const Menu: (({ menuRef, children, className }: IMenuRoot) => import("react/jsx-runtime").JSX.Element) & {
+    Divider: () => import("react/jsx-runtime").JSX.Element;
+    Items: ({ onClick, children, className }: IMenuItems) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/components/NavigationDrawer/NavItemSecondary.d.ts

@@ -0,0 +1,10 @@
+export interface NavItemSecondaryProps {
+    title: string;
+    path: string;
+    parentPath?: string;
+    className?: string;
+    isSelected?: boolean;
+    onClick?: (path: string) => void;
+}
+declare const NavItemSecondary: import('react').MemoExoticComponent<(props: NavItemSecondaryProps) => import("react/jsx-runtime").JSX.Element>;
+export default NavItemSecondary;

package/dist/components/NavigationDrawer/NavigationDrawer.d.ts

@@ -0,0 +1,49 @@
+import { default as React, ReactNode } from 'react';
+type NavigationDrawerRenderContext = {
+    toggleCollapse: () => void;
+    getIsCollapsed: () => boolean;
+    subscribeToCollapse: (listener: (collapsed: boolean) => void) => () => void;
+    openSidebar: () => void;
+    closeSidebar: () => void;
+    toggleSidebar: () => void;
+    getIsSidebarOpen: () => boolean;
+    subscribeToSidebarOpen: (listener: (open: boolean) => void) => () => void;
+};
+type NavigationDrawerSlotChildren = ReactNode | ((context: NavigationDrawerRenderContext) => ReactNode);
+export interface NavigationDrawerProps {
+    children?: NavigationDrawerSlotChildren;
+    classNameDrawer?: string;
+    classNameSidebar?: string;
+}
+type SlotBaseProps = {
+    children?: NavigationDrawerSlotChildren;
+    className?: string;
+    context?: NavigationDrawerRenderContext;
+};
+type ContentProps = SlotBaseProps & Omit<React.AllHTMLAttributes<HTMLDivElement>, "children">;
+export type NavigationDrawerSidebarProps = {
+    children?: NavigationDrawerSlotChildren;
+    className?: string;
+    context?: NavigationDrawerRenderContext;
+    modal?: boolean;
+    closeOnOverlayClick?: boolean;
+    unmountChildrenOnClose?: boolean;
+};
+declare const NavigationDrawer: React.NamedExoticComponent<NavigationDrawerProps> & {
+    readonly type: (props: NavigationDrawerProps) => import("react/jsx-runtime").JSX.Element;
+} & {
+    Root: React.MemoExoticComponent<(props: NavigationDrawerProps) => import("react/jsx-runtime").JSX.Element>;
+    Header: React.MemoExoticComponent<({ children, className, context }: SlotBaseProps) => import("react/jsx-runtime").JSX.Element>;
+    Content: React.MemoExoticComponent<({ children, className, context, ...props }: ContentProps) => import("react/jsx-runtime").JSX.Element>;
+    Footer: React.MemoExoticComponent<({ children, className, context }: SlotBaseProps) => import("react/jsx-runtime").JSX.Element>;
+    Spacer: React.MemoExoticComponent<({ className }: {
+        className?: string;
+    }) => import("react/jsx-runtime").JSX.Element>;
+    Outlet: React.NamedExoticComponent<{
+        children?: NavigationDrawerSlotChildren;
+        className?: string;
+        context?: NavigationDrawerRenderContext;
+    } & React.RefAttributes<HTMLDivElement>>;
+    Sidebar: React.NamedExoticComponent<NavigationDrawerSidebarProps & React.RefAttributes<HTMLDivElement>>;
+};
+export default NavigationDrawer;

package/dist/components/NavigationDrawer/NavigationDrawerActionItem.d.ts

@@ -0,0 +1,16 @@
+import { IconComponent } from '../../Icons/types';
+export interface NavigationDrawerActionItemProps {
+    id: string;
+    title: string;
+    icon?: IconComponent;
+    count?: number;
+    className?: string;
+    isActive?: boolean;
+    disabled?: boolean;
+    onClick?: () => void;
+    isView?: boolean | (() => boolean);
+    order?: number;
+}
+declare const NavigationDrawerActionItem: import('react').MemoExoticComponent<(props: NavigationDrawerActionItemProps) => import("react/jsx-runtime").JSX.Element | null>;
+export default NavigationDrawerActionItem;
+export type { NavigationDrawerActionItemProps as NavigationDrawerActionItemPropsType };

package/dist/components/NavigationDrawer/NavigationDrawerActions.d.ts

@@ -0,0 +1,9 @@
+import { NavigationDrawerActionItemProps } from './NavigationDrawerActionItem';
+export interface NavigationDrawerActionsProps {
+    actions?: NavigationDrawerActionItemProps[];
+    activeActionId?: string;
+    onActionClick?: (id: string) => void;
+    className?: string;
+}
+declare const NavigationDrawerActions: import('react').MemoExoticComponent<({ actions, activeActionId, onActionClick, className }: NavigationDrawerActionsProps) => import("react/jsx-runtime").JSX.Element>;
+export default NavigationDrawerActions;

package/dist/components/NavigationDrawer/NavigationDrawerItemBase.d.ts

@@ -0,0 +1,18 @@
+import { IconComponent } from '../../Icons/types';
+import { default as React } from 'react';
+export interface NavigationDrawerItemBaseProps {
+    title: string;
+    icon?: IconComponent;
+    count?: number;
+    className?: string;
+    isSelected?: boolean;
+    hasSublinks?: boolean;
+    subLinksCollapsed?: boolean;
+    onToggleSublinks?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+    as?: "a" | "button" | "div";
+    onClick?: React.MouseEventHandler;
+    onAuxClick?: React.MouseEventHandler;
+    disabled?: boolean;
+}
+declare const NavigationDrawerItemBase: React.MemoExoticComponent<(props: NavigationDrawerItemBaseProps) => import("react/jsx-runtime").JSX.Element>;
+export default NavigationDrawerItemBase;

package/dist/components/NavigationDrawer/NavigationDrawerLinkItem.d.ts

@@ -0,0 +1,30 @@
+import { IconComponent } from '../../Icons/types';
+import { ReactNode } from 'react';
+import { NavItemSecondaryProps } from './NavItemSecondary';
+export interface NavigationDrawerLinkItemProps {
+    path: string;
+    title: string;
+    icon?: IconComponent;
+    isView?: boolean | (() => boolean);
+    relatedPaths?: string[];
+    count?: number;
+    className?: string;
+    disabled?: boolean;
+    isSelected?: boolean;
+    toggleCollapse?: () => void;
+    getIsCollapsed?: () => boolean;
+    subscribeToCollapse?: (listener: (collapsed: boolean) => void) => () => void;
+    onClick?: (path: string) => void;
+    sublinks?: NavItemSecondaryProps[];
+    subLinksRender?: (sublinks: NavItemSecondaryProps[], controls: NavItemHandler) => ReactNode;
+}
+interface NavItemHandler {
+    toggle: () => void;
+    setIsCollapsed: (collapsed: boolean) => void;
+    isCollapsed: boolean;
+    isDrawerCollapsed: boolean;
+    toggleDrawerCollapse?: () => void;
+    subscribeToCollapse?: (listener: (collapsed: boolean) => void) => () => void;
+}
+declare const NavigationDrawerLinkItem: import('react').NamedExoticComponent<NavigationDrawerLinkItemProps & import('react').RefAttributes<NavItemHandler>>;
+export default NavigationDrawerLinkItem;

package/dist/components/NavigationDrawer/NavigationDrawerNavlinks.d.ts

@@ -0,0 +1,11 @@
+import { NavigationDrawerLinkItemProps } from './NavigationDrawerLinkItem';
+export interface NavigationDrawerNavlinksProps {
+    navlinks?: NavigationDrawerLinkItemProps[];
+    handleNavigation: (path: string) => void;
+    className?: string;
+    getIsCollapsed?: () => boolean;
+    toggleCollapse?: () => void;
+    subscribeToCollapse?: (listener: (collapsed: boolean) => void) => () => void;
+}
+declare const NavigationDrawerNavlinks: import('react').MemoExoticComponent<({ navlinks, handleNavigation, className, getIsCollapsed, toggleCollapse, subscribeToCollapse }: NavigationDrawerNavlinksProps) => import("react/jsx-runtime").JSX.Element>;
+export default NavigationDrawerNavlinks;

package/dist/components/NavigationDrawer/index.d.ts

@@ -0,0 +1,2 @@
+import { default as NavigationDrawer } from './NavigationDrawer';
+export default NavigationDrawer;

package/dist/components/NotificationCard/NotificationCard.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+import { ButtonVariant } from '../Shared/types';
+export interface NotificationAction<NotificationMetadata = unknown> {
+    label: string;
+    onClick: (metadata?: NotificationMetadata) => void;
+    variant?: ButtonVariant;
+    disabled?: boolean;
+    hidden?: boolean;
+}
+export interface NoitificationUser {
+    name: string;
+    profile_picture?: string;
+}
+export interface NotificationCardProps<NotificationMetadata = unknown> {
+    user: NoitificationUser;
+    body: string | React.ReactNode | ((metadata?: NotificationMetadata) => React.ReactNode);
+    date: string | Date;
+    actions?: [NotificationAction<NotificationMetadata>, NotificationAction<NotificationMetadata>] | [NotificationAction<NotificationMetadata>];
+    isNew?: boolean;
+    className?: string;
+    metadata?: NotificationMetadata;
+}
+declare const NotificationCard: <NotificationMetadata = unknown>({ user, body, date, actions, isNew, className, metadata }: NotificationCardProps<NotificationMetadata>) => import("react/jsx-runtime").JSX.Element;
+export default NotificationCard;
+export type NotificationCardComponent = typeof NotificationCard;

package/dist/components/NotificationCard/index.d.ts

@@ -0,0 +1,3 @@
+import { default as NotificationCard, NotificationCardProps } from './NotificationCard';
+export default NotificationCard;
+export type { NotificationCardProps };

package/dist/components/OtpInput/OtpInput.d.ts

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+export interface OtpInputProps {
+    value?: string;
+    onChange?: (value: string, name?: string) => void;
+    onComplete?: (value: string) => void;
+    onBlur?: () => void;
+    maxLength?: number;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    autoFocus?: boolean;
+    pasteTransformer?: (pasted: string) => string;
+    errorComponent?: React.ReactElement<{
+        className?: string;
+    }> | string;
+    hasError?: boolean;
+    helperComponent?: React.ReactElement<{
+        className?: string;
+    }> | string;
+    helperAlignment?: 'left' | 'center' | 'right';
+    slotClassName?: string;
+    hideSlotsMiddleSeparator?: boolean;
+    name?: string;
+    variant?: 'default' | 'error' | 'success';
+}
+declare const OtpInputComponent: {
+    ({ value, name, onChange, onComplete, onBlur, maxLength, placeholder, disabled, className, autoFocus, pasteTransformer, errorComponent, hasError, helperComponent, helperAlignment, slotClassName, variant, hideSlotsMiddleSeparator }: OtpInputProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default OtpInputComponent;

package/dist/components/Pagination/Pagination.d.ts

@@ -0,0 +1,6 @@
+export interface PaginationProps {
+    currentPage?: number;
+    totalPages?: number;
+    onPageChange?: (page: number) => void;
+}
+export default function Pagination({ currentPage, totalPages, onPageChange, }: PaginationProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ProfilePictureUpload/ProfilePictureUpload.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+export interface ProfilePictureUploadProps {
+    imageUrl?: string;
+    fallbackText?: string;
+    onFileSelect?: (file: File) => void;
+    onEditClick?: () => void;
+    onRemoveClick?: () => void;
+    size?: "sm" | "md" | "lg" | "xl";
+    className?: string;
+    disabled?: boolean;
+    showRemoveButton?: boolean;
+    acceptedTypes?: string;
+    maxFileSize?: number;
+    onError?: (error: string) => void;
+    disableEntryAnimation?: boolean;
+}
+declare function ProfilePictureUploadComponent({ imageUrl, fallbackText, onFileSelect, onEditClick, onRemoveClick, size, className, disabled, showRemoveButton, acceptedTypes, maxFileSize, onError, }: ProfilePictureUploadProps): import("react/jsx-runtime").JSX.Element;
+export declare const ProfilePictureUpload: React.MemoExoticComponent<typeof ProfilePictureUploadComponent>;
+export {};

package/dist/components/ProgressBar/ProgressBar.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+interface BaseProgressProps extends React.HTMLAttributes<HTMLDivElement> {
+    label?: string;
+}
+interface DateProgressProps extends BaseProgressProps {
+    variant: 'date';
+    startDate: string | Date;
+    endDate: string | Date;
+}
+interface QuantityProgressProps extends BaseProgressProps {
+    variant: 'quantity';
+    current: number;
+    total: number;
+    unit?: string;
+}
+export type ProgressBarProps = DateProgressProps | QuantityProgressProps;
+declare const ProgressBar: React.ForwardRefExoticComponent<ProgressBarProps & React.RefAttributes<HTMLDivElement>>;
+export default ProgressBar;

package/dist/components/PyrionNavigationDrawer/PyrionHelpSection.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+interface PyrionHelpSectionProps {
+    onCloseClick?: VoidFunction;
+    children?: ReactNode;
+    title?: string;
+}
+declare const PyrionHelpSection: ({ onCloseClick, children, title }: PyrionHelpSectionProps) => import("react/jsx-runtime").JSX.Element;
+export default PyrionHelpSection;

package/dist/components/PyrionNavigationDrawer/PyrionNavigationDrawer.d.ts

@@ -0,0 +1,130 @@
+import { ReactNode } from 'react';
+import { NavigationDrawerSidebarProps } from '../NavigationDrawer/NavigationDrawer';
+import { NavigationDrawerActionItemProps } from '../NavigationDrawer/NavigationDrawerActionItem';
+import { NavigationDrawerLinkItemProps } from '../NavigationDrawer/NavigationDrawerLinkItem';
+import { NotificationCardProps } from '../NotificationCard/NotificationCard';
+import { AllOptionAccessor } from '../Shared/types';
+import { TabSwitchElement } from '../TabSwitch/TabSwitch';
+import { subImageUrlAccessor } from './SystemSessions';
+type TProduct = {
+    name: string;
+    domain: string;
+    active: boolean;
+    coverImage?: string;
+    thumbnail?: string;
+};
+type TCompany = {
+    name: string;
+    products?: TProduct[];
+    icon?: string;
+};
+type TUser = {
+    auth_id: string;
+    name: string;
+    surname?: string;
+    email?: string;
+    profile_picture?: string;
+};
+export type TSystem = {
+    name: string;
+    url: string;
+    coverImage?: string;
+    thumbnail?: string;
+    system_id: string;
+};
+type TSystemSession<TSystemMetadata> = TSystem & {
+    metadata?: TSystemMetadata;
+};
+export interface AuthSession<TSystemMetadata> {
+    token: string;
+    expires_at: string;
+    logoutDate?: string;
+    userHub: TUser;
+    systems: TSystemSession<TSystemMetadata>[];
+}
+export interface NavigationDrawerTabsProps {
+    currentTabName?: string;
+    customTabs?: TabSwitchElement[];
+    onTabClick?: (name: string) => void;
+}
+type AvailableData<TSystemMetadata> = {
+    company: TCompany;
+    user: TUser;
+    system?: TSystem;
+    metadata?: TSystemMetadata;
+};
+type SessionAvailableData<TSystemMetadata> = {
+    company: TCompany;
+    user: TUser;
+    system?: TSystemSession<TSystemMetadata>;
+    metadata?: TSystemMetadata;
+};
+type UserCardAccesors<TSystemMetadata> = AllOptionAccessor<AvailableData<TSystemMetadata>, string>;
+type SessionCardAccesors<TSystemMetadata> = AllOptionAccessor<SessionAvailableData<TSystemMetadata>, string>;
+interface UserCardOptions<TSystemMetadata> {
+    secondarySlot: UserCardAccesors<TSystemMetadata> | [UserCardAccesors<TSystemMetadata>, UserCardAccesors<TSystemMetadata>] | ((data: AvailableData<TSystemMetadata>) => React.ReactNode);
+}
+interface SessionCardOptions<TSystemMetadata> {
+    secondarySlot: SessionCardAccesors<TSystemMetadata> | [SessionCardAccesors<TSystemMetadata>, SessionCardAccesors<TSystemMetadata>] | ((data: SessionAvailableData<TSystemMetadata>) => React.ReactNode);
+    subImageUrlAccessor?: subImageUrlAccessor<TSystemMetadata>;
+}
+export interface NotificationsDrawerOptions {
+    hide?: boolean;
+    hideActionButton?: boolean;
+    onMarkAllAsRead?: () => void;
+}
+export interface HelpSectionDrawerOptions {
+    hide?: boolean;
+    hideActionButton?: boolean;
+}
+export interface ConfigurationActionOptions {
+    hideActionButton?: boolean;
+    onClick: VoidFunction;
+}
+export interface PyrionNavigationDrawerOptions<TSystemMetadata> {
+    userCardOptions?: UserCardOptions<TSystemMetadata>;
+    sessionCardOptions?: SessionCardOptions<TSystemMetadata>;
+    notificationsDrawerOptions?: NotificationsDrawerOptions;
+    helpSectionDrawerOptions?: HelpSectionDrawerOptions;
+    configurationActionOptions?: ConfigurationActionOptions;
+    sidebarOptions: Pick<NavigationDrawerSidebarProps, 'modal' | 'closeOnOverlayClick'>;
+}
+export interface PyrionNavigationDrawerProps<TSystemMetadata, NotificationMetadata = unknown> {
+    links?: NavigationDrawerLinkItemProps[];
+    actions?: NavigationDrawerActionItemProps[];
+    tabsProps?: NavigationDrawerTabsProps;
+    activeActionId?: string;
+    currentSystemId: string;
+    helpSection?: ReactNode | (() => ReactNode);
+    children?: ReactNode;
+    state: {
+        company: TCompany;
+        enabled_systems: TSystem[];
+        user: TUser;
+        sessions?: AuthSession<TSystemMetadata>[];
+        metadata?: TSystemMetadata;
+        notifications?: NotificationCardProps<NotificationMetadata>[];
+    };
+    options?: PyrionNavigationDrawerOptions<TSystemMetadata>;
+    onActionClick?: (id: string) => void;
+    onLinkClick?: (path: string) => void;
+    onSessionClick?: (session: AuthSession<TSystemMetadata>) => void;
+    onNavigate?: (from: string, to: string) => void;
+    onSystemLogoClick?: (collapsed?: boolean) => void;
+    onLogoutClick?: () => void;
+}
+type PyrionNavigationControls = {
+    toggleCollapse?: () => void;
+    getIsCollapsed?: () => boolean;
+    subscribeToCollapse?: (listener: (collapsed: boolean) => void) => () => void;
+    openSidebar?: () => void;
+    closeSidebar?: () => void;
+    toggleSidebar?: () => void;
+    getIsSidebarOpen?: () => boolean;
+    subscribeToSidebarOpen?: (listener: (open: boolean) => void) => () => void;
+    openNotifications?: () => void;
+    openHelp?: () => void;
+};
+export declare const usePyrionNavigation: () => PyrionNavigationControls;
+declare const PyrionNavigationDrawer: <TAppMetadata = unknown, NotificationMetadata = unknown>({ children, helpSection, state, links: navlinks, onLinkClick, onNavigate, onLogoutClick, actions, activeActionId, onActionClick, tabsProps, currentSystemId, onSessionClick, options, onSystemLogoClick }: PyrionNavigationDrawerProps<TAppMetadata, NotificationMetadata>) => import("react/jsx-runtime").JSX.Element;
+export default PyrionNavigationDrawer;

package/dist/components/PyrionNavigationDrawer/PyrionNavigationDrawerMobileAppSwitcher.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { TabSwitchElement } from '../TabSwitch/TabSwitch';
+import { TicketCardHandlerProps } from '../TicketCard/TicketCard';
+export interface PyrionNavigationDrawerMobileAppSwitcherProps {
+    tabs: TabSwitchElement[];
+    content: React.ReactNode | (() => React.ReactNode);
+    controls?: React.RefObject<TicketCardHandlerProps | null>;
+}
+declare const PyrionNavigationDrawerMobileAppSwitcher: ({ tabs, content, controls }: PyrionNavigationDrawerMobileAppSwitcherProps) => import("react/jsx-runtime").JSX.Element;
+export default PyrionNavigationDrawerMobileAppSwitcher;

package/dist/components/PyrionNavigationDrawer/PyrionNavigationDrawerSystemLogo.d.ts

@@ -0,0 +1,7 @@
+import { TSystem } from './PyrionNavigationDrawer';
+declare const SystemLogo: import('react').MemoExoticComponent<({ enabled_systems, onClick, currentSystemId }: {
+    enabled_systems?: TSystem[];
+    onClick?: () => void;
+    currentSystemId?: string;
+}) => import("react/jsx-runtime").JSX.Element>;
+export default SystemLogo;

package/dist/components/PyrionNavigationDrawer/PyrionNotificationsList.d.ts

@@ -0,0 +1,8 @@
+import { NotificationCardProps } from '../NotificationCard/NotificationCard';
+interface PyrionNotificationsDrawerProps<NotificationMetadata> {
+    onCloseClick?: VoidFunction;
+    onMarkAllAsRead?: () => void;
+    notifications?: NotificationCardProps<NotificationMetadata>[];
+}
+declare const PyrionNotificationsList: <NotificationMetadata = unknown>({ onCloseClick, onMarkAllAsRead, notifications }: PyrionNotificationsDrawerProps<NotificationMetadata>) => import("react/jsx-runtime").JSX.Element;
+export default PyrionNotificationsList;

package/dist/components/PyrionNavigationDrawer/SidebarContent.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { PyrionNavigationDrawerOptions, PyrionNavigationDrawerProps } from './PyrionNavigationDrawer';
+export type SidebarContentHandle = {
+    setActiveSection: (section: 'notifications' | 'help') => void;
+};
+declare const SidebarContent: import('react').ForwardRefExoticComponent<{
+    closeSidebar: () => void;
+    options?: PyrionNavigationDrawerOptions<any>;
+    state: PyrionNavigationDrawerProps<any, any>["state"];
+    helpSection?: ReactNode | (() => ReactNode);
+    initialSection?: "notifications" | "help";
+} & import('react').RefAttributes<SidebarContentHandle>>;
+export default SidebarContent;

package/dist/components/PyrionNavigationDrawer/SystemSessions.d.ts

@@ -0,0 +1,12 @@
+import { AllOptionAccessor } from '../Shared/types';
+import { AuthSession } from './PyrionNavigationDrawer';
+export interface SystemSessionsProps<TSystemMetadata> {
+    sessions?: AuthSession<TSystemMetadata>[];
+    onSessionClick?: (session: AuthSession<TSystemMetadata>) => void;
+    secondarySlot?: React.ReactNode | string | ((session: AuthSession<TSystemMetadata>) => React.ReactNode | string | null) | null;
+    subImageUrlAccessor?: subImageUrlAccessor<TSystemMetadata>;
+    currentSystemId: string;
+}
+export type subImageUrlAccessor<TSystemMetadata> = AllOptionAccessor<TSystemMetadata, string>;
+declare const SystemSessions: <TSystemMetadata = unknown>(props: SystemSessionsProps<TSystemMetadata>) => import("react/jsx-runtime").JSX.Element | null;
+export default SystemSessions;

package/dist/components/PyrionNavigationDrawer/index.d.ts

@@ -0,0 +1,3 @@
+import { default as PyrionNavigationDrawer, PyrionNavigationDrawerProps, PyrionNavigationDrawerOptions, NavigationDrawerTabsProps, AuthSession } from './PyrionNavigationDrawer';
+export { type PyrionNavigationDrawerProps, type PyrionNavigationDrawerOptions, type NavigationDrawerTabsProps, type AuthSession };
+export default PyrionNavigationDrawer;

package/dist/components/RadioButton/RadioButton.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { ComponentVariant } from '../Shared/types';
+export interface RadioButtonProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    label?: string;
+    disabled?: boolean;
+    errorComponent?: React.ReactNode | string;
+    helperComponent?: React.ReactNode | string;
+    required?: boolean;
+    variant?: ComponentVariant;
+    className?: string;
+    labelClassName?: string;
+}
+declare const RadioButton: React.NamedExoticComponent<RadioButtonProps & React.RefAttributes<HTMLInputElement>>;
+export default RadioButton;