@kiteapps/lite-ui 0.1.0 → 0.1.1

package/dist/types/admin/screens.d.ts

@@ -0,0 +1,13 @@
+export function AdminScreen({ screen, screens, renderScreen, screenProps }: {
+    screen: any;
+    screens?: {} | undefined;
+    renderScreen: any;
+    screenProps?: {} | undefined;
+}): any;
+export const ADMIN_GROUPS: {
+    label: string;
+    items: {
+        id: string;
+        label: string;
+    }[];
+}[];

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

@@ -0,0 +1,2 @@
+export * from '../widgets';
+export * from '../pages';

package/dist/types/pages/AdminScreen.d.ts

@@ -0,0 +1,10 @@
+import type * as React from 'react';
+import type { NavigationGroup } from '../widgets';
+export declare const ADMIN_GROUPS: NavigationGroup[];
+export interface AdminScreenProps {
+    screen: string;
+    screens?: Record<string, React.ComponentType<any>>;
+    renderScreen?: (screen: string) => React.ReactNode;
+    screenProps?: Record<string, unknown>;
+}
+export declare function AdminScreen(props: AdminScreenProps): React.JSX.Element;

package/dist/types/pages/ConfigurationPage.d.ts

@@ -0,0 +1,46 @@
+import type * as React from 'react';
+import { type NavigationGroup, type NavigationItem, type PolicyRecord, type PolicyFeature, type PolicyColumn, type ConfigurationHeaderProps, type PolicyFeatureStripProps, type PolicyToolbarProps, type PolicyTableProps } from '../widgets';
+export interface ConfigurationPageLabels {
+    title?: string;
+    copySuffix?: string;
+    featuresTitle?: string;
+    instruction?: React.ReactNode;
+    policiesTitle?: string;
+    add?: string;
+    domain?: string;
+    enable?: string;
+    sectionDescription?: (title: string) => string;
+    editTitle?: string;
+    addTitle?: string;
+    cancel?: string;
+    save?: string;
+    policyName?: string;
+}
+export interface ConfigurationPageProps {
+    selected?: string;
+    policyId?: string;
+    groups?: NavigationGroup[];
+    policies?: PolicyRecord[];
+    initialPolicies?: PolicyRecord[];
+    onPoliciesChange?: (policies: PolicyRecord[]) => void;
+    features?: PolicyFeature[];
+    columns?: PolicyColumn[];
+    labels?: ConfigurationPageLabels;
+    defaultDomain?: string;
+    onSavePolicy?: (saved: PolicyRecord, previous: PolicyRecord) => void;
+    onDeletePolicy?: (policy: PolicyRecord) => void;
+    onCopyPolicy?: (copy: PolicyRecord, source: PolicyRecord) => void;
+    onFeatureSelect?: (id: string, item: PolicyFeature) => void;
+    createPolicy?: (name: string) => PolicyRecord;
+    renderSection?: (selected: string, item?: NavigationItem) => React.ReactNode;
+    renderPolicyForm?: (context: {
+        policy: PolicyRecord | null;
+        name: string;
+        setName: React.Dispatch<React.SetStateAction<string>>;
+    }) => React.ReactNode;
+    headerProps?: Partial<ConfigurationHeaderProps>;
+    featureProps?: PolicyFeatureStripProps;
+    toolbarProps?: PolicyToolbarProps;
+    tableProps?: PolicyTableProps;
+}
+export declare function ConfigurationPage({ selected, policyId, groups, policies, initialPolicies, onPoliciesChange, features, columns, labels, defaultDomain, onSavePolicy, onDeletePolicy, onCopyPolicy, onFeatureSelect, createPolicy, renderSection, renderPolicyForm, headerProps, featureProps, toolbarProps, tableProps }: ConfigurationPageProps): React.JSX.Element;

package/dist/types/pages/DashboardPage.d.ts

@@ -0,0 +1,30 @@
+import type * as React from 'react';
+import { type DashboardMetric, type ChartDatum, type ShortcutGroup, type ShortcutItem, type ColumnChartProps, type MfaChartProps, type WidgetFrameProps, type DashboardToolbarProps, type DashboardMenuItem } from '../widgets';
+import type { DirectoryOption } from '../widgets';
+type ChartKey = 'directory' | 'mfa' | 'selfService';
+export interface DashboardPageProps {
+    metrics?: DashboardMetric[];
+    directoryData?: ChartDatum[];
+    mfaData?: ChartDatum[];
+    selfServiceData?: ChartDatum[];
+    shortcuts?: ShortcutGroup[];
+    domains?: DirectoryOption[];
+    domain?: string;
+    onDomainChange?: (value: string, item?: DirectoryOption) => void;
+    chartTitles?: Partial<Record<ChartKey, string>>;
+    chartProps?: {
+        directory?: ColumnChartProps;
+        mfa?: MfaChartProps;
+        selfService?: ColumnChartProps;
+    };
+    widgetProps?: Partial<Record<ChartKey, Partial<WidgetFrameProps>>>;
+    toolbarProps?: DashboardToolbarProps;
+    onMetricSelect?: (item: DashboardMetric) => void;
+    onReportSelect?: (id: string, item: DashboardMetric | ChartDatum) => void;
+    onShortcutSelect?: (id: string, item: ShortcutItem) => void;
+    onToolbarAction?: (id: string, item: DashboardMenuItem) => void;
+    renderMetric?: (item: DashboardMetric, index: number) => React.ReactNode;
+    renderShortcuts?: (groups: ShortcutGroup[]) => React.ReactNode;
+}
+export declare function DashboardPage({ metrics, directoryData, mfaData, selfServiceData, shortcuts, domains, domain, onDomainChange, chartTitles, chartProps, widgetProps, toolbarProps, onMetricSelect, onReportSelect, onShortcutSelect, onToolbarAction, renderMetric, renderShortcuts }: DashboardPageProps): React.JSX.Element;
+export {};

package/dist/types/pages/ReportsPage.d.ts

@@ -0,0 +1,30 @@
+import type * as React from 'react';
+import { type ReportGroup, type ReportItem, type ReportFiltersProps } from '../widgets';
+export interface ReportGenerationContext {
+    selected?: string;
+    report?: ReportItem;
+    domain?: string;
+    ou?: string;
+}
+export interface ReportsPageLabels {
+    untitled?: string;
+    schedule?: string;
+    help?: string | null;
+    scheduleNote?: string;
+    empty?: string;
+    loading?: string;
+}
+export interface ReportsPageProps {
+    groups?: ReportGroup[];
+    selected?: string;
+    defaultSelected?: string;
+    onSelect?: (id: string, item: ReportItem) => void;
+    filtersProps?: ReportFiltersProps;
+    labels?: ReportsPageLabels;
+    status?: 'empty' | 'loading' | (string & {});
+    onGenerate?: (context: ReportGenerationContext) => void;
+    onStop?: () => void;
+    onSchedule?: (report?: ReportItem) => void;
+    results?: React.ReactNode;
+}
+export declare function ReportsPage({ groups, selected, defaultSelected, onSelect, filtersProps, labels, status: controlledStatus, onGenerate, onStop, onSchedule, results }: ReportsPageProps): React.JSX.Element;

package/dist/types/pages/index.d.ts

@@ -0,0 +1,4 @@
+export * from './DashboardPage';
+export * from './ReportsPage';
+export * from './ConfigurationPage';
+export * from './AdminScreen';

package/dist/types/widgets/ConfigurationWidgets.d.ts

@@ -0,0 +1,90 @@
+import type * as React from 'react';
+import { type LucideIcon } from 'lucide-react';
+import { type NavigationGroup, type NavigationItem } from './Shell';
+import '../configuration/configuration.css';
+export interface PolicyFeature {
+    id?: string;
+    label: string;
+    icon?: LucideIcon;
+}
+export interface PolicyRecord {
+    id?: string;
+    name: string;
+    domain?: string;
+    permissions?: string;
+    modifiedBy?: string;
+    modified?: string;
+    [key: string]: any;
+}
+export interface PolicyColumn {
+    key: string;
+    label: string;
+}
+export declare const CONFIG_GROUPS: NavigationGroup[];
+export declare const POLICY_FEATURES: PolicyFeature[];
+export declare const DEMO_POLICIES: PolicyRecord[];
+export declare const POLICY_COLUMNS: PolicyColumn[];
+export interface ConfigurationSidebarProps {
+    groups?: NavigationGroup[];
+    selected?: string;
+    defaultSelected?: string;
+    onSelect?: (id: string, item: NavigationItem) => void;
+    initialOpen?: string;
+}
+export declare function ConfigurationSidebar({ groups, selected, defaultSelected, onSelect, initialOpen }: ConfigurationSidebarProps): React.JSX.Element;
+export interface ConfigurationHeaderProps {
+    title: string;
+    mode?: string;
+    onModeChange?: (mode: string) => void;
+    helpText?: string | null;
+    action?: React.ReactNode;
+}
+export declare function ConfigurationHeader({ title, mode, onModeChange, helpText, action }: ConfigurationHeaderProps): React.JSX.Element;
+export interface PolicyFeatureStripProps {
+    title?: string;
+    features?: PolicyFeature[];
+    instruction?: React.ReactNode;
+    onFeatureSelect?: (id: string, item: PolicyFeature) => void;
+}
+export declare function PolicyFeatureStrip({ title, features, instruction, onFeatureSelect }: PolicyFeatureStripProps): React.JSX.Element;
+export interface PolicyToolbarLabels {
+    first?: string;
+    previous?: string;
+    next?: string;
+    last?: string;
+    range?: (first: number, last: number, total: number) => string;
+}
+export interface PolicyToolbarProps {
+    title?: string;
+    addLabel?: string;
+    searchLabel?: string;
+    count?: number;
+    page?: number;
+    defaultPage?: number;
+    pageSize?: number;
+    onPageChange?: (page: number) => void;
+    onAdd?: () => void;
+    query?: string;
+    defaultQuery?: string;
+    onQueryChange?: (value: string) => void;
+    labels?: PolicyToolbarLabels;
+}
+export declare function PolicyToolbar({ title, addLabel, searchLabel, count, page, defaultPage, pageSize, onPageChange, onAdd, query, defaultQuery, onQueryChange, labels }: PolicyToolbarProps): React.JSX.Element;
+export interface PolicyTableProps {
+    policies?: PolicyRecord[];
+    columns?: PolicyColumn[];
+    defaultDomain?: string;
+    emptyMessage?: React.ReactNode;
+    actionLabels?: {
+        edit?: string;
+        delete?: string;
+        copy?: string;
+        advanced?: string;
+    };
+    onEdit?: (policy: PolicyRecord) => void;
+    onDelete?: (policy: PolicyRecord) => void;
+    onCopy?: (policy: PolicyRecord) => void;
+    renderCell?: (policy: PolicyRecord, key: string) => React.ReactNode | undefined;
+    getRowId?: (policy: PolicyRecord) => React.Key;
+}
+export declare function PolicyTable({ policies, columns, defaultDomain, emptyMessage, actionLabels, onEdit, onDelete, onCopy, renderCell, getRowId }: PolicyTableProps): React.JSX.Element;

package/dist/types/widgets/DashboardWidgets.d.ts

@@ -0,0 +1,113 @@
+import type * as React from 'react';
+import { type LucideIcon } from 'lucide-react';
+import type { DirectoryOption } from './Shell';
+import '../dashboard/dashboard.css';
+export interface MetricWidgetProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'value' | 'title'> {
+    title: string;
+    value: React.ReactNode;
+    caption?: string;
+    icon?: LucideIcon | null;
+    tone?: string;
+    iconSize?: number;
+}
+export interface DashboardMetric extends Omit<MetricWidgetProps, 'onClick'> {
+    id?: string;
+    report?: string;
+    onClick?: (item: DashboardMetric) => void;
+}
+export interface ChartDatum {
+    id: string;
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface ShortcutItem {
+    id: string;
+    label: string;
+    href?: string;
+}
+export type ShortcutLink = string | ShortcutItem;
+export interface ShortcutGroup {
+    id?: string;
+    title: string;
+    links: ShortcutLink[];
+}
+export interface DashboardMenuItem {
+    id: string;
+    label: string;
+    onClick?: (item: DashboardMenuItem) => void;
+}
+export declare const DASHBOARD_METRICS: DashboardMetric[];
+export declare const DASHBOARD_SHORTCUTS: ShortcutGroup[];
+export declare const DIRECTORY_REPORT_DATA: ChartDatum[];
+export declare const MFA_REPORT_DATA: ChartDatum[];
+export declare const SELF_SERVICE_REPORT_DATA: ChartDatum[];
+export declare function MetricWidget({ title, value, caption, icon: Icon, tone, iconSize, onClick, className, ...props }: MetricWidgetProps): React.JSX.Element;
+export interface WidgetFrameProps {
+    title: string;
+    children?: React.ReactNode;
+    onExpand?: () => void;
+    onRefresh?: () => void;
+    onMore?: () => void;
+    tools?: React.ReactNode;
+    showTools?: boolean;
+    labels?: {
+        maximize?: string;
+        refresh?: string;
+        more?: string;
+    };
+    className?: string;
+}
+export declare function WidgetFrame({ title, children, onExpand, onRefresh, onMore, tools, showTools, labels, className }: WidgetFrameProps): React.JSX.Element;
+export interface ColumnChartProps {
+    data?: ChartDatum[];
+    max?: number;
+    ticks?: number[];
+    axisLabel?: string;
+    unit?: string;
+    color?: string;
+    onSelect?: (id: string, item: ChartDatum) => void;
+}
+export declare function ActiveDirectoryChart({ data, max, ticks, axisLabel, unit, color, onSelect }: ColumnChartProps): React.JSX.Element;
+export interface MfaChartProps {
+    data?: ChartDatum[];
+    onSelect?: (id: string, item: ChartDatum) => void;
+    ariaLabel?: string;
+}
+export declare function MfaChart({ data, onSelect, ariaLabel }: MfaChartProps): React.JSX.Element;
+export declare function SelfServiceChart({ data, max, ticks, axisLabel, unit, color, onSelect }: ColumnChartProps): React.JSX.Element;
+export interface ShortcutRailProps {
+    groups?: ShortcutGroup[];
+    onSelect?: (id: string, item: ShortcutItem) => void;
+    ariaLabel?: string;
+}
+export declare function ShortcutRail({ groups, onSelect, ariaLabel }: ShortcutRailProps): React.JSX.Element;
+export interface DashboardToolbarProps {
+    domains?: DirectoryOption[];
+    domain?: string;
+    defaultDomain?: string;
+    onDomainChange?: (value: string, item?: DirectoryOption) => void;
+    domainLabel?: string;
+    showShortcuts?: boolean;
+    onToggleShortcuts?: (show?: boolean) => void;
+    onExpand?: () => void;
+    settingsLabel?: string;
+    expandLabel?: string;
+    menuItems?: DashboardMenuItem[];
+    onMenuAction?: (id: string, item: DashboardMenuItem) => void;
+}
+export declare function DashboardToolbar({ domains, domain, defaultDomain, onDomainChange, domainLabel, showShortcuts, onToggleShortcuts, onExpand, settingsLabel, expandLabel, menuItems, onMenuAction }: DashboardToolbarProps): React.JSX.Element;
+export interface DashboardLayoutProps {
+    metrics?: React.ReactNode;
+    charts?: React.ReactNode;
+    shortcuts?: React.ReactNode;
+    showShortcuts?: boolean;
+}
+export declare function DashboardLayout({ metrics, charts, shortcuts, showShortcuts }: DashboardLayoutProps): React.JSX.Element;
+export interface ExpandedWidgetProps {
+    title?: string | null;
+    onClose: () => void;
+    children?: React.ReactNode;
+    closeLabel?: string;
+}
+export declare function ExpandedWidget({ title, onClose, children, closeLabel }: ExpandedWidgetProps): React.JSX.Element | null;

package/dist/types/widgets/Primitives.d.ts

@@ -0,0 +1,119 @@
+import type * as React from 'react';
+import { type LucideIcon } from 'lucide-react';
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: 'neutral' | 'primary' | 'outline' | 'download' | (string & {});
+    icon?: LucideIcon;
+}
+export declare function Button({ children, variant, icon: Icon, className, ...props }: ButtonProps): React.JSX.Element;
+export interface IconButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    icon: LucideIcon;
+    label: string;
+}
+export declare function IconButton({ icon: Icon, label, ...props }: IconButtonProps): React.JSX.Element;
+export interface TextFieldProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    label?: string;
+    hint?: React.ReactNode;
+}
+export declare function TextField({ label, hint, id, className, ...props }: TextFieldProps): React.JSX.Element;
+export type SelectOption = string | {
+    value: string;
+    label: string;
+};
+export interface SelectFieldProps extends React.SelectHTMLAttributes<HTMLSelectElement> {
+    label?: string;
+    options?: SelectOption[];
+}
+export declare function SelectField({ label, options, value, onChange, className, ...props }: SelectFieldProps): React.JSX.Element;
+export interface CheckRowProps {
+    children?: React.ReactNode;
+    defaultChecked?: boolean;
+    checked?: boolean;
+    onChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    help?: string;
+    className?: string;
+}
+export declare function CheckRow({ children, defaultChecked, checked, onChange, disabled, help, className }: CheckRowProps): React.JSX.Element;
+export interface RadioRowProps {
+    name: string;
+    value: string;
+    checked?: boolean;
+    onChange?: (value: string) => void;
+    children?: React.ReactNode;
+    disabled?: boolean;
+}
+export declare function RadioRow({ name, value, checked, onChange, children, disabled }: RadioRowProps): React.JSX.Element;
+export declare function HelpTip({ text }: {
+    text: string;
+}): React.JSX.Element;
+export interface TextLinkProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+}
+export declare function TextLink({ children, onClick, ...props }: TextLinkProps): React.JSX.Element;
+export type TabItem = string | {
+    id: string;
+    label: string;
+};
+export interface TabsProps {
+    tabs?: TabItem[];
+    active?: string;
+    onChange?: (id: string, item: {
+        id: string;
+        label: string;
+    }) => void;
+    ariaLabel?: string;
+}
+export declare function Tabs({ tabs, active, onChange, ariaLabel }: TabsProps): React.JSX.Element;
+export interface PageHeaderProps {
+    title: React.ReactNode;
+    action?: React.ReactNode;
+    help?: string;
+}
+export declare function PageHeader({ title, action, help }: PageHeaderProps): React.JSX.Element;
+export declare function Panel({ children, className }: {
+    children?: React.ReactNode;
+    className?: string;
+}): React.JSX.Element;
+export declare function SectionTitle({ children }: {
+    children?: React.ReactNode;
+}): React.JSX.Element;
+export declare function FormRow({ label, children, required, hint }: {
+    label: React.ReactNode;
+    children?: React.ReactNode;
+    required?: boolean;
+    hint?: React.ReactNode;
+}): React.JSX.Element;
+export interface ActionBarProps {
+    onSave?: () => void;
+    onCancel?: () => void;
+    saveLabel?: string;
+    cancelLabel?: string;
+    status?: React.ReactNode;
+}
+export declare function ActionBar({ onSave, onCancel, saveLabel, cancelLabel, status }: ActionBarProps): React.JSX.Element;
+export declare function Notice({ children, tone }: {
+    children?: React.ReactNode;
+    tone?: 'info' | 'warning' | 'error' | (string & {});
+}): React.JSX.Element;
+export type DataRow = Record<string, any> | React.ReactNode[];
+export type DataColumn<Row extends DataRow = DataRow> = string | {
+    key: string;
+    label: string;
+    render?: (row: Row, index: number) => React.ReactNode;
+};
+export interface DataTableProps<Row extends DataRow = DataRow> {
+    columns?: DataColumn<Row>[];
+    rows?: Row[];
+    empty?: React.ReactNode;
+    onRowClick?: (row: Row, index: number) => void;
+    getRowId?: (row: Row, index: number) => React.Key;
+}
+export declare function DataTable<Row extends DataRow = DataRow>({ columns, rows, empty, onRowClick, getRowId }: DataTableProps<Row>): React.JSX.Element;
+export interface ModalProps {
+    title: string;
+    children?: React.ReactNode;
+    open?: boolean;
+    onClose?: () => void;
+    footer?: React.ReactNode;
+    closeLabel?: string;
+}
+export declare function Modal({ title, children, open, onClose, footer, closeLabel }: ModalProps): React.JSX.Element | null;

package/dist/types/widgets/ReportWidgets.d.ts

@@ -0,0 +1,71 @@
+import type * as React from 'react';
+import type { DirectoryOption } from './Shell';
+import '../reports/reports.css';
+export interface ReportItem {
+    id: string;
+    label: string;
+}
+export type ReportEntry = ReportItem | readonly [string, string];
+export interface ReportGroup {
+    id?: string;
+    label: string;
+    items: ReportEntry[];
+}
+export interface ReportFilterLabels {
+    domain?: string;
+    selectOu?: string;
+    generate?: string;
+    stop?: string;
+}
+export declare const REPORT_GROUPS: ReportGroup[];
+export declare const normalizeReport: (item: ReportEntry) => ReportItem;
+export interface ReportNavigationProps {
+    groups?: ReportGroup[];
+    selected?: string;
+    defaultSelected?: string;
+    onSelect?: (id: string, item: ReportItem) => void;
+    searchPlaceholder?: string;
+    searchLabel?: string;
+    emptyLabel?: string;
+    ariaLabel?: string;
+    onSearchChange?: (value: string) => void;
+}
+export declare function ReportNavigation({ groups, selected, defaultSelected, onSelect, searchPlaceholder, searchLabel, emptyLabel, ariaLabel, onSearchChange }: ReportNavigationProps): React.JSX.Element;
+export interface ReportCategoryBarProps {
+    groups?: ReportGroup[];
+    selected?: string;
+    defaultSelected?: string;
+    onSelect?: (id: string, item: ReportItem) => void;
+    ariaLabel?: string;
+}
+export declare function ReportCategoryBar({ groups, selected, defaultSelected, onSelect, ariaLabel }: ReportCategoryBarProps): React.JSX.Element;
+export interface ReportFiltersProps {
+    domains?: DirectoryOption[];
+    domain?: string;
+    defaultDomain?: string;
+    onDomainChange?: (value: string, item?: DirectoryOption) => void;
+    ouOptions?: DirectoryOption[];
+    ou?: string;
+    defaultOu?: string;
+    onOuChange?: (value: string, item: DirectoryOption) => void;
+    labels?: ReportFilterLabels;
+    onGenerate?: () => void;
+    onStop?: () => void;
+    generating?: boolean;
+}
+export declare function ReportFilters({ domains, domain, defaultDomain, onDomainChange, ouOptions, ou, defaultOu, onOuChange, labels, onGenerate, onStop, generating }: ReportFiltersProps): React.JSX.Element;
+export interface ReportResultsProps {
+    status?: 'empty' | 'loading' | (string & {});
+    emptyMessage?: React.ReactNode;
+    loadingMessage?: React.ReactNode;
+    children?: React.ReactNode;
+}
+export declare function ReportResults({ status, emptyMessage, loadingMessage, children }: ReportResultsProps): React.JSX.Element;
+export interface ReportPageHeadingProps {
+    title: string;
+    onSchedule?: () => void;
+    scheduleLabel?: string;
+    helpText?: string | null;
+    action?: React.ReactNode;
+}
+export declare function ReportPageHeading({ title, onSchedule, scheduleLabel, helpText, action }: ReportPageHeadingProps): React.JSX.Element;

package/dist/types/widgets/SettingsWidgets.d.ts

@@ -0,0 +1,32 @@
+import type * as React from 'react';
+import { type SelectOption, type TabItem } from './Primitives';
+export interface FrameProps {
+    title: string;
+    tabs?: TabItem[];
+    activeTab?: string;
+    defaultTab?: string;
+    onTabChange?: (id: string) => void;
+    children?: React.ReactNode | ((active: string | undefined) => React.ReactNode);
+    action?: React.ReactNode;
+    help?: string;
+    className?: string;
+}
+export declare function Frame({ title, tabs, activeTab, defaultTab, onTabChange, children, action, help, className }: FrameProps): React.JSX.Element;
+export interface SaveBarProps {
+    saveLabel?: string;
+    cancel?: boolean;
+    cancelLabel?: string;
+    successMessage?: string;
+    onSave?: () => void;
+    onCancel?: () => void;
+    status?: string;
+}
+export declare function SaveBar({ saveLabel, cancel, cancelLabel, successMessage, onSave, onCancel, status: controlledStatus }: SaveBarProps): React.JSX.Element;
+export interface InlineSelectProps extends Omit<React.SelectHTMLAttributes<HTMLSelectElement>, 'value' | 'onChange'> {
+    options?: SelectOption[];
+    initial?: string;
+    value?: string;
+    onChange?: (value: string) => void;
+    width?: React.CSSProperties['width'];
+}
+export declare function InlineSelect({ options, initial, value, onChange, width, ...props }: InlineSelectProps): React.JSX.Element;

package/dist/types/widgets/Shell.d.ts

@@ -0,0 +1,112 @@
+import type * as React from 'react';
+export type NavigationSection = string | {
+    id: string;
+    label: string;
+};
+export interface NavigationItem {
+    id: string;
+    label: string;
+}
+export interface NavigationGroup {
+    id?: string;
+    label: string;
+    items: NavigationItem[];
+}
+export type DirectoryOption = string | {
+    value: string;
+    label: string;
+};
+export type UtilityItem = string | {
+    id?: string;
+    label: string;
+    onClick?: (item: Exclude<UtilityItem, string>) => void;
+};
+export type FooterItem = string | {
+    id: string;
+    label: string;
+    href?: string;
+};
+export declare const MAIN_SECTIONS: NavigationSection[];
+export declare const FOOTER_LINKS: FooterItem[];
+export interface TopNavigationProps {
+    sections?: NavigationSection[];
+    active?: string;
+    onChange?: (id: string, item: NavigationItem) => void;
+    ariaLabel?: string;
+}
+export declare function TopNavigation({ sections, active, onChange, ariaLabel }: TopNavigationProps): React.JSX.Element;
+export interface ShellHeaderProps {
+    brand?: string;
+    brandIcon?: React.ReactNode;
+    showBrandOrbit?: boolean;
+    sections?: NavigationSection[];
+    navigationLabel?: string;
+    activeSection?: string;
+    onSectionChange?: (id: string, item: NavigationItem) => void;
+    directories?: DirectoryOption[];
+    directory?: string;
+    defaultDirectory?: string;
+    onDirectoryChange?: (value: string, item: DirectoryOption) => void;
+    showDownload?: boolean;
+    downloadLabel?: string;
+    onDownload?: () => void;
+    utilityItems?: UtilityItem[];
+    showNotifications?: boolean;
+    notifications?: number;
+    notificationLabel?: string;
+    onNotificationsClick?: () => void;
+    showUserMenu?: boolean;
+    userMenuLabel?: string;
+    onUserClick?: () => void;
+    showSearch?: boolean;
+    searchPlaceholder?: string;
+    searchLabel?: string;
+    searchValue?: string;
+    onSearchChange?: (value: string) => void;
+    showSettings?: boolean;
+    settingsLabel?: string;
+    onSettingsClick?: () => void;
+    rightContent?: React.ReactNode;
+}
+export declare function ShellHeader({ brand, brandIcon, showBrandOrbit, sections, navigationLabel, activeSection, onSectionChange, directories, directory, defaultDirectory, onDirectoryChange, showDownload, downloadLabel, onDownload, utilityItems, showNotifications, notifications, notificationLabel, onNotificationsClick, showUserMenu, userMenuLabel, onUserClick, showSearch, searchPlaceholder, searchLabel, searchValue, onSearchChange, showSettings, settingsLabel, onSettingsClick, rightContent }: ShellHeaderProps): React.JSX.Element;
+export interface CollapsibleSidebarProps {
+    groups?: NavigationGroup[];
+    selected?: string;
+    defaultSelected?: string;
+    onSelect?: (id: string, item: NavigationItem) => void;
+    initialOpen?: string;
+    open?: string;
+    onOpenChange?: (label: string, group: NavigationGroup) => void;
+    ariaLabel?: string;
+}
+export declare function CollapsibleSidebar({ groups, selected, defaultSelected, onSelect, initialOpen, open, onOpenChange, ariaLabel }: CollapsibleSidebarProps): React.JSX.Element;
+export interface ShellFooterProps {
+    items?: FooterItem[];
+    onItemSelect?: (id: string, item: {
+        id: string;
+        label: string;
+        href?: string;
+    }) => void;
+    children?: React.ReactNode;
+}
+export declare function ShellFooter({ items, onItemSelect, children }: ShellFooterProps): React.JSX.Element;
+export interface AppShellProps {
+    activeSection?: string;
+    onSectionChange?: (id: string, item: NavigationItem) => void;
+    sidebar?: React.ReactNode;
+    sidebarLabel?: string;
+    hideSidebar?: boolean;
+    mainClassName?: string;
+    headerProps?: ShellHeaderProps;
+    footerProps?: ShellFooterProps;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    children?: React.ReactNode;
+}
+export declare function AppShell({ activeSection, onSectionChange, sidebar, sidebarLabel, hideSidebar, mainClassName, headerProps, footerProps, header, footer, children }: AppShellProps): React.JSX.Element;
+export interface AdminShellProps extends AppShellProps {
+    groups?: NavigationGroup[];
+    screen?: string;
+    onScreenChange?: (id: string, item: NavigationItem) => void;
+}
+export declare function AdminShell({ groups, screen, onScreenChange, children, activeSection, onSectionChange, sidebar, hideSidebar, mainClassName, ...shellProps }: AdminShellProps): React.JSX.Element;