@b1-road/react 0.1.0-alpha.0

package/dist/api/errors.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Road API error taxonomy. Every non-OK HTTP response from the Road API is
+ * mapped to one of these classes so integrators can branch on
+ * `instanceof` rather than reading raw HTTP status codes.
+ *
+ * All errors carry the originating HTTP status, the parsed error body
+ * (when the response was a Problem-Details JSON document), the
+ * `x-request-id` response header, and the `traceparent` trace id when the
+ * API emits one — the values the API logs against the request, so an
+ * integrator opening a support ticket has something Road on-call can grep
+ * for.
+ *
+ * Inheritance: every specific class extends `RoadApiError`, so existing
+ * `catch (e) { if (e instanceof RoadApiError) … }` blocks still catch
+ * every Road error.
+ */
+/**
+ * Shape of the API's RFC 7807 Problem Details body. Road's
+ * GlobalExceptionFilter emits this for every error response — see
+ * `apps/api/src/common/filters/http-exception.filter.ts`.
+ */
+export interface RoadProblemDetails {
+    type?: string;
+    title?: string;
+    status?: number;
+    detail?: string;
+    instance?: string;
+    errors?: Array<{
+        field: string;
+        code: string;
+        message: string;
+    }>;
+    meta?: {
+        requestId?: string | null;
+        timestamp?: string;
+        [k: string]: unknown;
+    };
+    [k: string]: unknown;
+}
+export interface RoadApiErrorInit {
+    status: number;
+    statusText: string;
+    body: string;
+    problem?: RoadProblemDetails;
+    requestId?: string;
+    traceId?: string;
+}
+/**
+ * Base class for every Road SDK HTTP error. Specific status codes get
+ * subclasses (see below) — integrators should usually branch on those.
+ */
+export declare class RoadApiError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: string;
+    readonly problem?: RoadProblemDetails;
+    readonly requestId?: string;
+    readonly traceId?: string;
+    constructor(init: RoadApiErrorInit);
+}
+/** 401 — JWT missing, expired, or rejected by the API. Host should refresh and retry. */
+export declare class RoadAuthError extends RoadApiError {
+    constructor(init: RoadApiErrorInit);
+}
+/** 403 — authenticated but not authorized for this resource. */
+export declare class RoadForbiddenError extends RoadApiError {
+    constructor(init: RoadApiErrorInit);
+}
+/** 404 — resource doesn't exist (or caller can't see it). */
+export declare class RoadNotFoundError extends RoadApiError {
+    constructor(init: RoadApiErrorInit);
+}
+/** 409 — request conflicts with current state (duplicate, version skew, …). */
+export declare class RoadConflictError extends RoadApiError {
+    constructor(init: RoadApiErrorInit);
+}
+/**
+ * 400 / 422 — request payload failed validation. `fieldErrors` is keyed
+ * by the request field name; values are the list of validator messages
+ * for that field. Empty when the API returns a non-field-shaped error.
+ */
+export declare class RoadValidationError extends RoadApiError {
+    readonly fieldErrors: Record<string, string[]>;
+    constructor(init: RoadApiErrorInit);
+}
+/**
+ * 429 — caller is rate-limited. `retryAfter` (seconds) is parsed from
+ * the `Retry-After` response header when present.
+ */
+export declare class RoadRateLimitError extends RoadApiError {
+    readonly retryAfter?: number;
+    constructor(init: RoadApiErrorInit & {
+        retryAfter?: number;
+    });
+}
+/** 5xx — server-side failure. The SDK's retry loop targets this class + network errors. */
+export declare class RoadServerError extends RoadApiError {
+    constructor(init: RoadApiErrorInit);
+}
+/** Network failure before/while reading the response (fetch threw). */
+export declare class RoadNetworkError extends RoadApiError {
+    readonly cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+export declare function mapStatusToError(init: RoadApiErrorInit & {
+    retryAfter?: number;
+}): RoadApiError;

package/dist/api/errors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/hooks.d.ts

@@ -0,0 +1,126 @@
+import { InfiniteData } from '@tanstack/react-query';
+import { RoadClient } from './client';
+import { BusinessUnitDetail, CreateBusinessUnitInput, CreateInvitationInput, CreateRoleInput, CurrentUser, Invitation, Member, MyBusinessUnits, MyPermissions, PaginatedList, Permission, RoadPermission, Role, UpdateBusinessUnitInput, UpdateRoleInput } from './types';
+/**
+ * Action argument accepted by useCan(). Autocompletes Road's core permission
+ * set (read/manage × the four built-in subjects, plus "*"), and accepts any
+ * other string for platform-specific permissions.
+ */
+type PermissionInput = RoadPermission | (string & {});
+export declare function useCurrentUser(): import('@tanstack/react-query').UseQueryResult<NoInfer<CurrentUser>, Error>;
+export declare function useMyBusinessUnits(): import('@tanstack/react-query').UseQueryResult<NoInfer<MyBusinessUnits>, Error>;
+export declare function useMyPermissions(): import('@tanstack/react-query').UseQueryResult<NoInfer<MyPermissions>, Error>;
+/**
+ * Permission check for the current user inside a business unit.
+ *
+ * Returns a callable that resolves the action against the user's effective
+ * permissions for the given BU. A role with `["*"]` short-circuits to true.
+ * While permissions are still loading, returns `false` (deny by default).
+ *
+ * Called with no arguments, reads the current BU from CurrentBusinessUnitContext
+ * (set by <BusinessUnitSwitcher /> or useSetCurrentBusinessUnit). Pass an
+ * explicit buId — or `null` to denote "no BU" — to bypass the context lookup.
+ */
+export declare function useCan(): (action: PermissionInput) => boolean;
+export declare function useCan(buId: string | null | undefined): (action: PermissionInput) => boolean;
+/**
+ * Returns the raw RoadClient. Escape hatch for one-off calls or custom
+ * queries the typed hooks don't cover (Storybook, integration tests,
+ * extending the toolkit).
+ */
+export declare function useRoadClient(): RoadClient;
+export interface CanManyResult<P extends string> {
+    /** Per-permission result keyed by the input string. */
+    permissions: Record<P, boolean>;
+    /** True iff every permission in the list is granted. Empty list ⇒ true (vacuous). */
+    canAll: boolean;
+    /** True iff at least one permission in the list is granted. Empty list ⇒ false. */
+    canAny: boolean;
+}
+/**
+ * Batch permission check — convenient for pages that gate behavior on
+ * multiple actions at once. Returns a result with per-permission booleans
+ * plus canAll / canAny convenience flags.
+ *
+ * Calls Road's POST /iam/authorization/authorize/batch endpoint in one
+ * round-trip — the engine evaluates every permission with full semantics
+ * (manage → CRUD expansion, wildcards, scope inheritance), so this is
+ * strictly more accurate than useCan, which does in-memory string-match
+ * against the cached useMyPermissions list. React Query caches the
+ * result keyed by (buId, permissions), so repeated calls with the same
+ * list reuse the cache.
+ *
+ * Pass an `as const` array to get typed keys on the returned `permissions`
+ * record:
+ *
+ *   const { permissions, canAll } = useCanMany([
+ *     "manage:Role",
+ *     "manage:Member",
+ *     "manage:Invitation",
+ *   ] as const);
+ *   if (!canAll) return <ReadOnlyView />;
+ *   permissions["manage:Role"]; // typed string literal
+ *
+ * Reads the current BU from CurrentBusinessUnitContext when buId is
+ * omitted. Pass an explicit buId — or `null` — to bypass the context;
+ * with no effective BU, every permission resolves to false (deny-by-
+ * default), matching useCan's behavior.
+ *
+ * While the batch query is loading, every permission also reads false —
+ * gated UI hides rather than flashes-visible-then-hidden, same trade-off
+ * useCan makes.
+ */
+export declare function useCanMany<P extends RoadPermission | (string & {})>(actions: readonly P[]): CanManyResult<P>;
+export declare function useCanMany<P extends RoadPermission | (string & {})>(actions: readonly P[], buId: string | null | undefined): CanManyResult<P>;
+export declare function useBusinessUnit(buId: string | null): import('@tanstack/react-query').UseQueryResult<NoInfer<BusinessUnitDetail>, Error>;
+/**
+ * Convenience hook that returns the first page of members for a BU
+ * unwrapped as `Member[]`. For BUs with thousands of members, prefer
+ * {@link useInfiniteMembers} and `loadMore`. With no buId the hook is
+ * disabled and `data` stays undefined (same as before pagination).
+ */
+export declare function useMembers(buId: string | null): import('@tanstack/react-query').UseQueryResult<NoInfer<Member[]>, Error>;
+/**
+ * Cursor-paginated members list. Wraps React Query's useInfiniteQuery so
+ * callers can flatten across pages or call `fetchNextPage()` from a
+ * "load more" button. `pagination.cursor` is the cursor for the next page
+ * — falsy when the last page has loaded.
+ */
+export declare function useInfiniteMembers(buId: string | null, limit?: number): import('@tanstack/react-query').UseInfiniteQueryResult<InfiniteData<PaginatedList<Member>, unknown>, Error>;
+/**
+ * Convenience hook that returns the first page of invitations for a BU
+ * unwrapped as `Invitation[]`. Prefer {@link useInfiniteInvitations}
+ * for BUs that may have many pending invitations historically.
+ */
+export declare function useInvitations(buId: string | null): import('@tanstack/react-query').UseQueryResult<NoInfer<Invitation[]>, Error>;
+/** Cursor-paginated invitations list (see {@link useInfiniteMembers}). */
+export declare function useInfiniteInvitations(buId: string | null, limit?: number): import('@tanstack/react-query').UseInfiniteQueryResult<InfiniteData<PaginatedList<Invitation>, unknown>, Error>;
+export declare function useCreateBusinessUnit(): import('@tanstack/react-query').UseMutationResult<BusinessUnitDetail, Error, CreateBusinessUnitInput, unknown>;
+export declare function useUpdateBusinessUnit(buId: string): import('@tanstack/react-query').UseMutationResult<BusinessUnitDetail, Error, UpdateBusinessUnitInput, unknown>;
+export declare function useSuspendMember(buId: string): import('@tanstack/react-query').UseMutationResult<void, Error, string, unknown>;
+export declare function useReinstateMember(buId: string): import('@tanstack/react-query').UseMutationResult<void, Error, string, unknown>;
+export declare function useRemoveMember(buId: string): import('@tanstack/react-query').UseMutationResult<void, Error, string, unknown>;
+export declare function useCreateInvitation(buId: string): import('@tanstack/react-query').UseMutationResult<Invitation, Error, CreateInvitationInput, unknown>;
+export declare function useCancelInvitation(buId: string): import('@tanstack/react-query').UseMutationResult<void, Error, string, unknown>;
+export declare function useResendInvitation(buId: string): import('@tanstack/react-query').UseMutationResult<void, Error, string, unknown>;
+export declare function useAcceptInvitation(): import('@tanstack/react-query').UseMutationResult<void, Error, string, unknown>;
+export declare function useRejectInvitation(): import('@tanstack/react-query').UseMutationResult<void, Error, string, unknown>;
+/**
+ * First page of roles for a BU, unwrapped to `Role[]`. The role catalog
+ * is typically small (≤ a few dozen) so most callers don't need
+ * pagination — when they do, switch to {@link useInfiniteRoles}.
+ *
+ * Pass `limit` (up to 100, the API's max) to bump the first-page size
+ * when the caller needs all roles in one shot — eg. a picker that has
+ * to render every available role. For BUs with > 100 roles, use the
+ * infinite variant instead.
+ */
+export declare function useRoles(buId: string | null, limit?: number): import('@tanstack/react-query').UseQueryResult<NoInfer<Role[]>, Error>;
+/** Cursor-paginated roles list (see {@link useInfiniteMembers}). */
+export declare function useInfiniteRoles(buId: string | null, limit?: number): import('@tanstack/react-query').UseInfiniteQueryResult<InfiniteData<PaginatedList<Role>, unknown>, Error>;
+export declare function useRole(buId: string | null, roleId: string | null): import('@tanstack/react-query').UseQueryResult<NoInfer<Role>, Error>;
+export declare function usePermissions(buId: string | null): import('@tanstack/react-query').UseQueryResult<NoInfer<Permission[]>, Error>;
+export declare function useCreateRole(buId: string): import('@tanstack/react-query').UseMutationResult<Role, Error, CreateRoleInput, unknown>;
+export declare function useUpdateRole(buId: string, roleId: string): import('@tanstack/react-query').UseMutationResult<Role, Error, UpdateRoleInput, unknown>;
+export declare function useDeleteRole(buId: string): import('@tanstack/react-query').UseMutationResult<void, Error, string, unknown>;
+export {};

package/dist/api/hooks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/mock-client.d.ts

@@ -0,0 +1,121 @@
+import { RoadClient } from './client';
+import { Member } from './types';
+export interface MockClientOptions {
+    /** Artificial network delay in ms. Default 350. */
+    latency?: number;
+    /** Force every call to fail with this error. Useful for testing error states. */
+    failWith?: string;
+    /** Seed with no BUs to demonstrate the empty state. */
+    empty?: boolean;
+}
+export declare function createMockClient(options?: MockClientOptions): RoadClient;
+/** Failure scenarios that flip the mock into a known failure mode. */
+export type MockScenario = "network-error" | "auth-error" | "rate-limit" | "server-error";
+/**
+ * Fluent builder for `RoadClient` mocks. Each `with*` call mutates the
+ * draft state and returns `this` so chains compose. Call `.build()` to
+ * materialize a `RoadClient` bound to the assembled state.
+ *
+ * Defaults: starts empty (no BUs), latency 0ms, no scenario.
+ *
+ * ```ts
+ * const client = mockClientBuilder()
+ *   .withLatency(50)
+ *   .withBusinessUnit({ name: "Acme", role: "Owner" })
+ *   .withMember("Acme", { name: "Alex", email: "alex@x.com", role: "Admin" })
+ *   .withInvitation("Acme", { email: "pending@x.com", roleName: "Member" })
+ *   .build();
+ * ```
+ */
+export declare class MockClientBuilder {
+    private readonly draft;
+    constructor();
+    /** Set artificial network latency in ms. */
+    withLatency(ms: number): this;
+    /**
+     * Seed with the rich playground data (3 BUs with members, roles, an
+     * invitation, a pending cross-BU invitation). Replaces any prior
+     * `withBusinessUnit` calls in the chain.
+     */
+    withRichSeed(): this;
+    /**
+     * Add a business unit. `name` is required; everything else is derived
+     * with sensible defaults. `role` declares the current user's role
+     * within this BU — defaults to "Owner" with wildcard permissions.
+     */
+    withBusinessUnit(spec: {
+        id?: string;
+        name: string;
+        slug?: string;
+        role?: string;
+        memberLimit?: number | null;
+        /** Wildcard-grant the user — defaults to true for Owner / false otherwise. */
+        wildcard?: boolean;
+    }): this;
+    /** Add a member to an existing BU. `buName` matches `BusinessUnit.name`. */
+    withMember(buName: string, spec: {
+        name: string;
+        email: string;
+        role?: string;
+        status?: Member["status"];
+    }): this;
+    /** Add a custom role to a BU. The role does NOT auto-assign to anyone. */
+    withRole(buName: string, spec: {
+        name: string;
+        description?: string;
+        permissions: string[];
+        isSystem?: boolean;
+    }): this;
+    /** Add a pending invitation to a BU. */
+    withInvitation(buName: string, spec: {
+        email: string;
+        roleName: string;
+        expiresInDays?: number;
+    }): this;
+    /** Add a cross-BU pending invitation visible on the current user's surface. */
+    withPendingInvitation(spec: {
+        businessUnit: {
+            id?: string;
+            name: string;
+            slug?: string;
+        };
+        roleName: string;
+        expiresInDays?: number;
+    }): this;
+    /**
+     * Flip the mock into a failure scenario. Every call rejects with a
+     * shape matching the scenario (Error message keyed for assertions).
+     */
+    withScenario(scenario: MockScenario): this;
+    /**
+     * Wire an `onUnauthenticated` handler that the `auth-error`
+     * scenario fires (with the same 1s debounce HttpRoadClient uses).
+     * Lets tests assert the cookie-mode redirect path without standing
+     * up an HTTP fixture.
+     *
+     * ## Scope — what this does and does not do
+     *
+     * ✓ **Does**: fire `onUnauthenticated` on `withScenario("auth-error")`,
+     *   debounced to once per 1s window, with handler-exception safety
+     *   matching the production HttpRoadClient.
+     *
+     * ✗ **Does not** simulate cookie-mode transport behavior. The
+     *   in-memory mock has no fetch, no `credentials: 'include'`, no
+     *   `XSRF-TOKEN` echo, no `Authorization` header omission. Those are
+     *   transport concerns and need an HTTP-level fixture to test
+     *   honestly.
+     *
+     * For tests that need to assert HTTP-level cookie-mode behavior
+     * (CSRF echo, credentials, no Authorization), mock `globalThis.fetch`
+     * directly against `HttpRoadClient` — see
+     * `src/api/cookie-mode.test.ts` for the canonical pattern.
+     */
+    withCookieMode(opts?: {
+        onUnauthenticated?: () => void;
+    }): this;
+    /** Materialize the assembled state into a RoadClient. */
+    build(): RoadClient;
+    private requireBu;
+}
+/** Entry point for the fluent mock-client builder. See {@link MockClientBuilder}. */
+export declare function mockClientBuilder(): MockClientBuilder;

package/dist/api/mock-client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Type re-export shim. The canonical definitions live in @b1-road/types so
+ * every Road SDK reads from a single source of truth. Importing from here
+ * still works for backward-compat — new code should import directly from
+ * "@b1-road/types".
+ */
+export * from '@b1-road/types';

package/dist/appearance/appearance.d.ts

@@ -0,0 +1,19 @@
+import { CSSProperties } from 'react';
+export interface AppearanceVariables {
+    colorPrimary?: string;
+    colorPrimaryForeground?: string;
+    colorBackground?: string;
+    colorForeground?: string;
+    colorMuted?: string;
+    colorAccent?: string;
+    colorDanger?: string;
+    colorBorder?: string;
+    borderRadius?: string;
+    fontFamily?: string;
+}
+export interface Appearance {
+    variables?: AppearanceVariables;
+    colorScheme?: "light" | "dark" | "auto";
+}
+export declare function appearanceToStyle(appearance?: Appearance): CSSProperties;
+export declare function resolveColorScheme(scheme?: Appearance["colorScheme"]): "light" | "dark";

package/dist/components/BusinessUnitSwitcher.d.ts

@@ -0,0 +1,15 @@
+export interface BusinessUnitSwitcherProps {
+    /**
+     * Force the trigger into collapsed (true) or expanded (false) mode. When
+     * unset (default), the component auto-detects via ResizeObserver on its
+     * own container — under 180px wide it shows the compact icon-only trigger
+     * with a tooltip; at or above 180px it shows the expanded trigger (avatar
+     * + name + role + chevron). Hosts whose sidebar collapse state lives in
+     * app state pass the prop explicitly; hosts using a fluid container can
+     * leave it unset and let the switcher react to width.
+     */
+    collapsed?: boolean;
+    /** Additional class on the trigger button — useful for sidebar layout. */
+    className?: string;
+}
+export declare function BusinessUnitSwitcher({ collapsed, className }: BusinessUnitSwitcherProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/BusinessUnitsMgmt.d.ts

@@ -0,0 +1,35 @@
+import { ReactNode } from 'react';
+export type BusinessUnitsMgmtTab = "business-units" | "roles";
+interface BusinessUnitsMgmtCommonProps {
+    /** Tab to show on each open. Defaults to "business-units". */
+    initialTab?: BusinessUnitsMgmtTab;
+    /**
+     * Deep-link into a specific business unit on each open — routes the Business
+     * Units tab to that BU's detail view instead of the list.
+     */
+    initialBusinessUnitId?: string;
+}
+/**
+ * Uncontrolled mode — component owns the open-state and renders a
+ * trigger (default or the one passed via `trigger`). `open` and
+ * `onOpenChange` MUST NOT be provided.
+ */
+interface BusinessUnitsMgmtUncontrolledProps extends BusinessUnitsMgmtCommonProps {
+    trigger?: ReactNode;
+    open?: never;
+    onOpenChange?: never;
+}
+/**
+ * Controlled mode — host owns the open-state and provides BOTH `open`
+ * and `onOpenChange`. The discriminated union enforces this pairing at
+ * compile time: `{ open: true }` without `onOpenChange` is a type
+ * error.
+ */
+interface BusinessUnitsMgmtControlledProps extends BusinessUnitsMgmtCommonProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    trigger?: never;
+}
+export type BusinessUnitsMgmtProps = BusinessUnitsMgmtUncontrolledProps | BusinessUnitsMgmtControlledProps;
+export declare function BusinessUnitsMgmt({ trigger, open, onOpenChange, initialTab, initialBusinessUnitId, }: BusinessUnitsMgmtProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/business-units/BusinessUnitDetail.d.ts

@@ -0,0 +1,6 @@
+interface Props {
+    buId: string;
+    onBack: () => void;
+}
+export declare function BusinessUnitDetail({ buId, onBack }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/business-units/BusinessUnitList.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    onSelect: (buId: string) => void;
+}
+export declare function BusinessUnitList({ onSelect }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/business-units/BusinessUnitRow.d.ts

@@ -0,0 +1,7 @@
+import { Membership } from '../../api/types';
+interface Props {
+    membership: Membership;
+    onSelect: (buId: string) => void;
+}
+export declare function BusinessUnitRow({ membership, onSelect }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/business-units/BusinessUnitSettings.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    buId: string;
+}
+export declare function BusinessUnitSettings({ buId }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/business-units/BusinessUnitsTab.d.ts

@@ -0,0 +1,5 @@
+export interface BusinessUnitsTabProps {
+    /** Initial BU to deep-link into — opens the detail view instead of the list. */
+    initialBuId?: string | null;
+}
+export declare function BusinessUnitsTab({ initialBuId }?: BusinessUnitsTabProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/business-units/CreateBusinessUnitForm.d.ts

@@ -0,0 +1,6 @@
+interface Props {
+    onCancel: () => void;
+    onCreated: (buId: string) => void;
+}
+export declare function CreateBusinessUnitForm({ onCancel, onCreated }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/business-units/MembersList.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    buId: string;
+}
+export declare function MembersList({ buId }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/business-units/PendingInvitations.d.ts

@@ -0,0 +1,15 @@
+import { PendingInvitation } from '../../api/types';
+/**
+ * The "invitation inbox" — pending BU invitations surfaced at the top of the
+ * business-units tab (and as the hero for a freshly-invited user who has no
+ * memberships yet). Each card shows the business unit, the offered role, and a
+ * humanized expiry, with one-click Accept / Decline.
+ *
+ * Data + actions come from {@link useAcceptInvitation} / {@link useRejectInvitation},
+ * which invalidate the my-business-units query on success — so an accepted BU
+ * slides into the list below and a declined one disappears, with no manual
+ * refetch wiring at the call site.
+ */
+export declare function PendingInvitations({ invitations, }: {
+    invitations: PendingInvitation[];
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/invitations/InvitationsList.d.ts

@@ -0,0 +1,7 @@
+import { Invitation } from '../../api/types';
+interface Props {
+    buId: string;
+    invitations: Invitation[];
+}
+export declare function InvitationsList({ buId, invitations }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/invitations/InvitationsTab.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    buId: string;
+}
+export declare function InvitationsTab({ buId }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/invitations/InviteForm.d.ts

@@ -0,0 +1,7 @@
+interface Props {
+    buId: string;
+    onCancel: () => void;
+    onInvited: () => void;
+}
+export declare function InviteForm({ buId, onCancel, onInvited }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/roles/BUSelector.d.ts

@@ -0,0 +1,8 @@
+import { BusinessUnitSummary } from '../../api/types';
+interface Props {
+    businessUnits: BusinessUnitSummary[];
+    value: string;
+    onChange: (buId: string) => void;
+}
+export declare function BUSelector({ businessUnits, value, onChange }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/roles/CreateRoleDialog.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    buId: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onCreated: (roleId: string) => void;
+}
+export declare function CreateRoleDialog({ buId, open, onOpenChange, onCreated }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/roles/PermissionPicker.d.ts

@@ -0,0 +1,10 @@
+import { Permission } from '../../api/types';
+interface Props {
+    permissions: Permission[];
+    /** Currently selected permission codes. Use ["*"] to indicate wildcard (all). */
+    value: string[];
+    onChange: (next: string[]) => void;
+    disabled?: boolean;
+}
+export declare function PermissionPicker({ permissions, value, onChange, disabled }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/roles/RoleEditor.d.ts

@@ -0,0 +1,7 @@
+interface Props {
+    buId: string;
+    roleId: string;
+    onBack: () => void;
+}
+export declare function RoleEditor({ buId, roleId, onBack }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/roles/RoleRow.d.ts

@@ -0,0 +1,7 @@
+import { Role } from '../../api/types';
+interface Props {
+    role: Role;
+    onSelect: (roleId: string) => void;
+}
+export declare function RoleRow({ role, onSelect }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/roles/RolesList.d.ts

@@ -0,0 +1,7 @@
+interface Props {
+    buId: string;
+    onSelect: (roleId: string) => void;
+    onCreate: () => void;
+}
+export declare function RolesList({ buId, onSelect, onCreate }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/roles/RolesTab.d.ts

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

package/dist/components/shared/Avatar.d.ts

@@ -0,0 +1,7 @@
+interface AvatarProps {
+    name: string;
+    size?: "sm" | "md" | "lg";
+    className?: string;
+}
+export declare function Avatar({ name, size, className }: AvatarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/shared/EmptyState.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+interface EmptyStateProps {
+    icon?: ReactNode;
+    title: string;
+    description?: string;
+    action?: ReactNode;
+    className?: string;
+}
+export declare function EmptyState({ icon, title, description, action, className }: EmptyStateProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/shared/LoadMoreFooter.d.ts

@@ -0,0 +1,18 @@
+interface Props {
+    /** Number of items already rendered across all loaded pages. */
+    shown: number;
+    /** Total row count from `pagination.totalCount`. */
+    total: number;
+    hasNextPage: boolean;
+    isFetchingNextPage: boolean;
+    /** Bound to `useInfiniteQuery().fetchNextPage`. */
+    onLoadMore: () => void;
+}
+/**
+ * Shared footer for paginated lists. Renders nothing when total is 0,
+ * shows a "X of Y" count, and renders a "Load more" button when more
+ * pages remain. Hides the button (but keeps the count) once the last
+ * page has loaded.
+ */
+export declare function LoadMoreFooter({ shown, total, hasNextPage, isFetchingNextPage, onLoadMore, }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};