@ai4b-team/fsaos-gateway-sdk 1.0.1

package/dist/index.d.cts

@@ -0,0 +1,1806 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { QueryClient } from '@tanstack/react-query';
+export { QueryClientProvider } from '@tanstack/react-query';
+import * as _supabase_supabase_js from '@supabase/supabase-js';
+import react__default from 'react';
+
+/**
+ * @fsaos/gateway — Type Definitions
+ *
+ * All types used by the gateway SDK. These are inferred from the deployed
+ * gateway.js bundle and the VFS data structures it operates on.
+ */
+/** A normalized VFS item as returned by all gateway read operations. */
+interface VFSItem {
+    id: string;
+    name: string;
+    item_type: string;
+    path: string;
+    parent_path: string;
+    is_active: boolean;
+    has_children: boolean;
+    created_at: string;
+    updated_at: string;
+    visibility?: string;
+    type_data: Record<string, any>;
+    scope_item_id?: string;
+    fractal_id?: string;
+    parent_instance_id?: string;
+    owner_principal_id?: string;
+    created_by_principal_id?: string;
+    parent_id?: string;
+}
+/** A type definition from the os_item_types registry. */
+interface TypeDefinition {
+    type_key: string;
+    display_name: string;
+    display_name_plural: string;
+    icon: string;
+    color: string;
+    description: string;
+    /** User-editable fields schema (JSON Schema). */
+    input_schema: Record<string, any>;
+    /** System-managed fields schema (JSON Schema). */
+    system_schema: Record<string, any>;
+    /** @deprecated Use input_schema/system_schema instead. */
+    json_schema: Record<string, any>;
+    default_data: Record<string, any>;
+    field_defaults: Record<string, any>;
+    renderer_config: Record<string, any>;
+    is_system: boolean;
+    is_active: boolean;
+    is_container: boolean;
+    is_scope: boolean;
+    render_mode: string;
+    placement_mode?: string;
+    direct_parent_types?: string[];
+    allowed_parent_types?: string[];
+    governed_create?: boolean;
+    create_method?: string;
+    dedup?: Record<string, any>;
+    edges?: any[];
+    events?: Record<string, any>;
+}
+/** A VFS edge (relationship between two items). */
+interface VFSEdge {
+    id: string;
+    source_item_id: string;
+    target_item_id: string;
+    edge_type: string;
+    weight: number;
+    context: Record<string, any>;
+    is_active: boolean;
+    is_bidirectional?: boolean;
+}
+/** The session entry returned by initSession (domain-scoped). */
+interface SessionEntry {
+    scope_id: string;
+    scope_path: string;
+    instance_path: string;
+    fractal_id: string | null;
+    instance_name: string | null;
+    display_name: string | null;
+}
+/** Raw error payload from the gateway when enforcement denies a request. */
+interface EnforcementPayload {
+    success: false;
+    error?: string;
+    message?: string;
+    denied_by?: string;
+    error_type?: string;
+    enforcement?: {
+        rule_key?: string;
+        display_name?: string;
+    };
+}
+/** Parameters for a gateway RPC call. */
+type GatewayParams = Record<string, unknown>;
+/** Raw response from the gateway (success path). */
+interface GatewayResponse {
+    success?: boolean;
+    content?: {
+        items?: any[];
+        type_data?: Record<string, any>;
+        [key: string]: any;
+    };
+    items?: any[];
+    item?: any;
+    outgoing?: any[];
+    incoming?: any[];
+    [key: string]: any;
+}
+interface CreateParams {
+    parent_path: string;
+    name?: string;
+    item_type?: string;
+    type_data?: Record<string, any>;
+    [key: string]: unknown;
+}
+interface UpdateParams {
+    path: string;
+    name?: string;
+    type_data?: Record<string, any>;
+    [key: string]: unknown;
+}
+interface DeleteParams {
+    path: string;
+    [key: string]: unknown;
+}
+interface MoveParams {
+    path: string;
+    new_parent_path: string;
+    [key: string]: unknown;
+}
+interface LinkParams {
+    /** Optional — if omitted, the kernel auto-resolves the caller's member item in the current scope. */
+    source_id?: string;
+    target_id: string;
+    edge_type?: string;
+    weight?: number;
+    context?: Record<string, any>;
+    [key: string]: unknown;
+}
+/**
+ * A compatible component opener returned by the CCM resolution pipeline.
+ *
+ * Each entry represents a component that has registered an `opens` edge
+ * targeting the item's type. The array is sorted by priority (highest first).
+ * The first entry with `is_default: true` is the one the kernel selected as
+ * the primary opener (reflected in `render.view_component_id`).
+ */
+interface ComponentOpener {
+    /** UUID of the component item in the VFS. */
+    component_id: string;
+    /** Short name of the component (e.g. "asset-viewer", "chat", "folder"). */
+    name: string;
+    /** VFS path of the component item. */
+    path: string;
+    /** Human-readable label for UI display (e.g. "Asset Viewer"). */
+    display_name: string;
+    /** Whether this is the default opener for the target type. */
+    is_default: boolean;
+    /** Priority weight (higher = preferred). */
+    priority: number;
+    /** UI framework the component is built with (e.g. "react"). */
+    framework: string;
+    /** Where the component runs: "client" (bundled) or "remote" (URL-loaded). */
+    host: string;
+    /** Remote bundle URL (null for client-hosted components). */
+    url: string | null;
+}
+/**
+ * The kernel's `open` syscall response — the unified envelope for rendering
+ * and content extraction.
+ *
+ * This is the primary interface between the kernel and any client that wants
+ * to display or process an item. The envelope carries:
+ *
+ * 1. **Item identity** — id, path, name, type (always present).
+ * 2. **CCM render block** — which component should render this item, resolved
+ *    via the Compatible Component Model (opens graph + entitlements).
+ * 3. **Compatible components** — all registered openers for "Open With" UX.
+ * 4. **Content** — extracted content for AI/programmatic consumers.
+ * 5. **Metadata** — additional item metadata when requested.
+ *
+ * The gateway processes `read_url_instructions` before returning, so
+ * storage-backed items arrive with `render.props.url` already populated.
+ *
+ * When `render.view_component_id` is null, no CCM opener is registered for
+ * this item type — the client should fall back to a system action (e.g.
+ * item-detail / inspector). This is a valid state, not an error.
+ */
+interface OpenEnvelope {
+    /** UUID of the opened item. */
+    item_id: string;
+    /** Full VFS path of the opened item. */
+    item_path: string;
+    /** Display name of the opened item. */
+    item_name: string;
+    /** Type key of the opened item (e.g. "file", "channel", "task"). */
+    item_type: string;
+    /** Render directives from the CCM resolution pipeline. */
+    render?: {
+        /** Always "ccm" when the open pipeline runs. */
+        render_mode: string;
+        /** UUID of the resolved component (null = no CCM opener registered). */
+        view_component_id: string | null;
+        /** VFS path of the resolved component (null = no CCM opener registered). */
+        view_component_path: string | null;
+        /** UI framework (e.g. "react"). Null when no opener. */
+        framework: string | null;
+        /** Execution host: "client" or "remote". Null when no opener. */
+        host: string | null;
+        /** Remote bundle URL (populated by gateway for storage-backed items). */
+        url: string | null;
+        /** Render props passed to the component (label, path, url, mime, etc.). */
+        props?: Record<string, unknown>;
+    };
+    /** All registered openers for this item's type, sorted by priority desc. */
+    compatible_components: ComponentOpener[];
+    /** Extracted content payload (type_data, inline text, structured data). */
+    content?: Record<string, unknown>;
+    /** Additional item metadata when requested. */
+    metadata?: Record<string, unknown>;
+    /** @internal Raw instructions — usually already processed by the gateway. */
+    instructions?: Array<Record<string, unknown>>;
+}
+/**
+ * Options for the `open` syscall.
+ *
+ * Controls what the kernel returns in the envelope:
+ * - `mode` determines whether to run the CCM render pipeline, content
+ *   extraction, or both.
+ * - `strategy` selects a non-default extraction strategy (e.g. "rows",
+ *   "symbol", "heading" for files).
+ * - `arguments` passes strategy-specific parameters.
+ *
+ * When omitted, defaults to `mode: "render"` for human callers.
+ */
+interface OpenOptions {
+    /**
+     * What to include in the envelope.
+     * - "render" — CCM resolution + render props (default for UI).
+     * - "extract" — Content extraction only (for AI/scripts).
+     * - "both" — Full envelope with render + content.
+     */
+    mode?: 'render' | 'extract' | 'both';
+    /** Strategy name from the type's open_config.strategies list. */
+    strategy?: string;
+    /** Strategy-specific arguments (e.g. { start: 0, end: 100 } for `rows`). */
+    arguments?: Record<string, unknown>;
+}
+
+/**
+ * @fsaos/gateway — Enforcement Error
+ *
+ * Thrown when a gateway call is denied by the enforcement layer
+ * (rules, access control, or entitlement checks).
+ */
+
+declare class EnforcementDeniedError extends Error {
+    readonly name = "EnforcementDeniedError";
+    readonly deniedBy: string;
+    readonly ruleKey?: string;
+    readonly displayName?: string;
+    constructor(payload: EnforcementPayload);
+    static fallbackMessage(payload: EnforcementPayload): string;
+    get isRuleDenial(): boolean;
+    get isAccessDenial(): boolean;
+    get isEntitlementDenial(): boolean;
+}
+
+/**
+ * @fsaos/gateway — Session Management
+ *
+ * Manages the auth token lifecycle, reactive scope state, and domain-scoped
+ * session initialization.
+ *
+ * Token flow:
+ *   1. Supabase auth fires onAuthStateChange → we cache the access_token
+ *   2. A one-shot Promise (`tokenReady`) gates all gateway calls until the
+ *      first auth event fires (or a 5 s timeout elapses)
+ *   3. initSession() calls GET /d/{hostname}/init to resolve the domain's
+ *      scope, fractal, and instance metadata
+ *
+ * Scope flow:
+ *   1. useAccounts() fetches memberships → auto-selects or user picks an account
+ *   2. setScope(accountPath) is called → sets the active scope path
+ *   3. `scopeReady` promise resolves → all gated queries begin executing
+ *   4. Scope subscribers are notified → React hooks re-render with new scope key
+ *   5. On account switch, setScope(newPath) fires subscribers again →
+ *      query keys change → React Query renders from new namespace (old cache stays warm)
+ */
+
+/**
+ * Manually set the cached access token.
+ * Useful when the token is obtained out-of-band (e.g. embed token injection).
+ */
+declare function setCachedToken(token: string, expiresAt?: number): void;
+/**
+ * Clear the cached access token.
+ * Called during sign-out to prevent stale tokens from leaking to the next session.
+ */
+declare function clearCachedToken(): void;
+/**
+ * Returns the current access token, waiting for the first auth event if needed.
+ */
+declare function getAccessToken(): Promise<string | null>;
+/** Subscriber set for reactive scope updates. */
+type ScopeListener = () => void;
+/**
+ * Set the active scope path (e.g. after account selection or account switch).
+ *
+ * Once set, every gatewayCall() automatically injects `_scope_path` into
+ * the request params so kernel_auth can validate membership at the correct
+ * account scope instead of falling back to the domain root.
+ *
+ * Setting scope also:
+ * - Resolves the `scopeReady` gate (unblocking all scope-dependent queries)
+ * - Increments the scope version counter
+ * - Notifies all scope subscribers (triggering React hook re-renders)
+ *
+ * @param scopePath  The VFS path of the selected account/scope
+ *                   (e.g. "/root/accounts/joel-rowland")
+ */
+declare function setScope(scopePath: string): void;
+/**
+ * Returns the currently active scope path, or null if not yet set.
+ */
+declare function getScope(): string | null;
+/**
+ * Returns the current scope version (monotonically increasing on each scope change).
+ * Used by useSyncExternalStore in React hooks.
+ */
+declare function getScopeVersion(): number;
+/**
+ * Subscribe to scope changes. Returns an unsubscribe function.
+ * Compatible with React's useSyncExternalStore pattern.
+ */
+declare function subscribeScope(listener: ScopeListener): () => void;
+/**
+ * Returns a promise that resolves when scope is first set.
+ * Used by gatewayCall to gate scope-dependent requests.
+ */
+declare function awaitScopeReady(): Promise<void>;
+/**
+ * Returns whether scope has been set at least once.
+ */
+declare function isScopeReady(): boolean;
+/**
+ * Initialize the domain-scoped session by calling the gateway's /init endpoint.
+ * Returns the cached session if already initialized.
+ *
+ * The gateway resolves the hostname → scope mapping and returns metadata about
+ * the fractal instance, scope path, and display name.
+ */
+declare function initSession(): Promise<SessionEntry>;
+/**
+ * Returns the current session entry, or null if not yet initialized.
+ */
+declare function getSessionEntry(): SessionEntry | null;
+/**
+ * Clears the cached session, forcing a fresh /init call on next access.
+ */
+declare function clearSession(): void;
+type CleanupFn = () => void;
+/**
+ * Register a cleanup function to be called during resetAllSdkState().
+ * Modules call this at import time to register their own cache-clearing logic.
+ */
+declare function registerCleanup(fn: CleanupFn): void;
+/**
+ * Reset ALL SDK module-level state.
+ *
+ * Called by signOut() to ensure no cached identity, session, scope, principal,
+ * query data, SSE connections, or realtime channels leak between user sessions.
+ *
+ * This is the single source of truth for auth cleanup. After this call,
+ * the SDK is in the same state as a fresh page load (minus the Supabase
+ * onAuthStateChange listener, which will re-populate the token on next sign-in).
+ */
+declare function resetAllSdkState(): void;
+
+/**
+ * @fsaos/gateway — Gateway Call (RPC Dispatcher)
+ *
+ * The single function that all VFS operations go through.
+ *
+ * Protocol:
+ *   POST https://{gatewayUrl}/d/{hostname}
+ *   Body: { method: string, params: Record<string, unknown> }
+ *
+ * The gateway resolves the hostname to a domain scope, authenticates via
+ * the Bearer token, and dispatches the method to the appropriate handler.
+ *
+ * If the domain scope is already known (from initSession), it is injected
+ * as `domain_scope_id` into the params automatically.
+ *
+ * SCOPE GATING:
+ * gatewayCall awaits `scopeReady` before sending any request that doesn't
+ * already have an explicit `_scope_path`. This prevents race conditions where
+ * hooks fire before account selection completes, sending relative paths that
+ * the kernel can't resolve.
+ *
+ * Methods that are inherently scope-independent (list-memberships, auth-related)
+ * bypass the scope gate because they're needed BEFORE scope is established.
+ */
+
+/**
+ * Call a gateway method.
+ *
+ * @param method  The RPC method name (e.g. "read", "list", "create", "update",
+ *                "delete", "tree", "search", "edges", "move", "link",
+ *                "types-list", "member-focus")
+ * @param params  Method-specific parameters
+ * @returns       The raw gateway response
+ *
+ * @throws {EnforcementDeniedError} When denied by rules, access, or entitlement
+ * @throws {Error}                  On HTTP errors or gateway-level failures
+ */
+declare function gatewayCall(method: string, params?: GatewayParams): Promise<GatewayResponse>;
+
+/**
+ * @fsaos/gateway — Query Client
+ *
+ * Creates and exports the shared TanStack QueryClient instance used by all
+ * VFS hooks. The default options are tuned for VFS data:
+ *
+ *   - staleTime: 2 minutes (VFS data doesn't change that often)
+ *   - gcTime: 10 minutes (keep unused data around for a while)
+ *   - refetchOnWindowFocus: false (we use Supabase Realtime instead)
+ *   - retry: 1 (one retry on failure)
+ */
+
+declare const queryClient: QueryClient;
+
+/**
+ * @fsaos/gateway — VFS Query Key Factory
+ *
+ * Deterministic query key factory used by TanStack Query for all VFS data.
+ * Every hook and cache invalidation function references these keys to ensure
+ * consistent cache identity.
+ *
+ * SCOPE-KEYED CACHING:
+ * All scope-dependent queries include the current scope path in their key.
+ * This means switching accounts creates a new cache namespace automatically —
+ * the old account's data stays warm for instant switch-back, while the new
+ * account's data is fetched fresh (or served from its own warm cache).
+ *
+ * Queries that are NOT scope-dependent (memberships, item-by-id) use keys
+ * without the scope prefix.
+ */
+declare const vfsKeys: {
+    /** Root key for all VFS queries (scope-aware). */
+    all: () => readonly ["vfs", string];
+    /** Single item by path (scope-aware — relative paths resolve per-scope). */
+    item: (path: string) => readonly ["vfs", string, "item", string];
+    /** Single item by UUID (scope-independent — UUIDs are globally unique). */
+    itemById: (id: string) => readonly ["vfs", "item-by-id", string];
+    /** Children of a path (scope-aware). */
+    children: (path: string) => readonly ["vfs", string, "children", string];
+    /** All children queries for current scope (for broad invalidation). */
+    allChildren: () => readonly ["vfs", string, "children"];
+    /** Type definitions for a scope (or default). */
+    types: (scopeId?: string) => readonly ["vfs", "types", string];
+    /** Edges for an item (scope-independent — edges are by item UUID). */
+    edges: (itemId: string) => readonly ["vfs", "edges", string];
+    /** Search results (scope-aware — search is scoped). */
+    search: (query: string, types?: string[]) => readonly ["vfs", string, "search", string, ...string[]];
+    /** Items query (type-based listing with filters, scope-aware). */
+    items: (type: string, filters?: Record<string, unknown>) => readonly ["vfs", string, "items", string, string];
+    /** All items queries for current scope (for broad invalidation). */
+    allItems: () => readonly ["vfs", string, "items"];
+    /** Recursive tree at a path + depth (scope-aware). */
+    tree: (path: string, depth?: number) => readonly ["vfs", string, "tree", string, number];
+    /** Open envelope for a path (scope-aware). */
+    openEnvelope: (path: string, strategy?: string) => readonly ["vfs", string, "open", string, string];
+    /** All open-envelope queries for current scope (for broad invalidation). */
+    allOpenEnvelopes: () => readonly ["vfs", string, "open"];
+    /** Member focus for a scope. */
+    memberFocus: (scopeId: string) => readonly ["vfs", "member-focus", string];
+    /** Fractal instances (scope-independent). */
+    fractalInstances: () => readonly ["vfs", "fractal-instances"];
+    /** Recent activity (scope-aware). */
+    recentActivity: (a: string, b: string, c: string) => readonly ["vfs", string, "recent-activity", string, string, string];
+    /** Item history (scope-independent — by item UUID). */
+    itemHistory: (a: string, b: string, c: string) => readonly ["vfs", "item-history", string, string, string];
+    /** Channel messages (scope-aware — channels are scoped). */
+    channelMessages: (channelPath: string, parentMessageId?: string) => readonly ["vfs", string, "channel-messages", string, string];
+    /** All channel-messages queries for current scope (for broad invalidation). */
+    allChannelMessages: () => readonly ["vfs", string, "channel-messages"];
+    /** Channels listing (scope-aware). */
+    channels: (filter?: string) => readonly ["vfs", string, "channels", string];
+    /** All channels queries for current scope (for broad invalidation). */
+    allChannels: () => readonly ["vfs", string, "channels"];
+    /** Notifications listing (scope-aware). */
+    notifications: (filter?: string, limit?: number) => readonly ["vfs", string, "notifications", string, number];
+    /** All notification queries for current scope (for broad invalidation). */
+    allNotifications: () => readonly ["vfs", string, "notifications"];
+    /** Unread counts (scope-aware). */
+    unreadCounts: () => readonly ["vfs", string, "unread-counts"];
+    /** Membership graph for a principal (scope-independent). */
+    memberships: (principalId: string) => readonly ["memberships", string];
+};
+
+/**
+ * @fsaos/gateway — VFS Operations
+ *
+ * Pure async functions that call the gateway and return normalized VFS data.
+ * These are the building blocks used by the React hooks — they can also be
+ * called directly for non-React use cases.
+ */
+
+/**
+ * Normalize a raw gateway item response into a clean VFSItem.
+ * Handles the various shapes the gateway can return (flat fields, nested
+ * content.type_data, etc.).
+ */
+declare function normalizeItem(raw: any): VFSItem;
+declare function fetchVfsItemById(id: string): Promise<VFSItem | null>;
+declare function fetchVfsItem(path: string): Promise<VFSItem | null>;
+declare function fetchVfsChildren(path: string): Promise<VFSItem[]>;
+/**
+ * Paginated directory listing. Returns a page of children at `path`
+ * with the given `limit` and `offset`. Used by `useInfiniteChildren`.
+ */
+declare function fetchVfsChildrenPage(path: string, limit: number, offset: number): Promise<{
+    items: VFSItem[];
+    total_hint: number;
+}>;
+declare function fetchTypeDefinitions(scopeId?: string): Promise<Map<string, TypeDefinition>>;
+declare function fetchEdgesForItem(itemId: string): Promise<VFSEdge[]>;
+declare function fetchVfsTree(path: string, maxDepth?: number, itemTypes?: string[], limit?: number): Promise<VFSItem[]>;
+declare function fetchRecentActivity(scopePath: string, limit?: number, offset?: number): Promise<any[]>;
+declare function fetchItemHistory(itemId: string, limit?: number, offset?: number): Promise<any>;
+declare function fetchMemberFocus(scopeId: string, itemTypes?: string[], limit?: number): Promise<VFSItem[]>;
+/**
+ * Fetch the kernel's open envelope for an item.
+ *
+ * This is the primary way to open an item — it invokes the kernel's `open`
+ * syscall which runs the CCM resolution pipeline and returns:
+ * - Item identity (id, path, name, type)
+ * - Render directives (which component to mount, with what props)
+ * - Compatible components list (for "Open With" UX)
+ * - Content extraction (for AI/programmatic consumers)
+ *
+ * The gateway processes `read_url_instructions` before returning, so
+ * storage-backed items arrive with `render.props.url` already populated.
+ *
+ * Most consumers should use the `useOpen` hook instead. This function
+ * exists for non-React contexts (Fractals, scripts, imperative code).
+ *
+ * @param path     VFS path of the item to open.
+ * @param options  Optional mode, strategy, and arguments.
+ */
+declare function fetchOpenEnvelope(path: string, options?: OpenOptions): Promise<OpenEnvelope>;
+/** Filters for useItems / fetchItems. */
+interface ItemsFilter {
+    /** Item type to query (required). */
+    type: string;
+    /** Scope path boundary. Defaults to session scope. */
+    scope?: string;
+    /** Direct parent_id filter. */
+    parent_id?: string;
+    /** Name ILIKE filter (partial match). */
+    name?: string;
+    /** Tag containment filter. */
+    tag?: string;
+    /** type_data field filters. Keys are field names, values are exact match. */
+    fields?: Record<string, string | number | boolean>;
+    /** Sort field. Default: 'updated_at'. */
+    sort_by?: string;
+    /** Sort direction. Default: 'desc'. */
+    sort_dir?: 'asc' | 'desc';
+    /** Max items to return. Default: 50. */
+    limit?: number;
+    /** Offset for pagination. Default: 0. */
+    offset?: number;
+}
+/**
+ * Fetch items by type with structured filters.
+ * Calls kernel_query (gateway 'search' method) with the extended filter support.
+ */
+declare function fetchItems(filter: ItemsFilter): Promise<{
+    items: VFSItem[];
+    total_hint?: number;
+}>;
+/** A parsed channel message with computed thread metadata from the kernel. */
+interface ChannelMessage {
+    id: string;
+    path: string;
+    content: string;
+    created_at: string;
+    role: 'user' | 'assistant' | 'system';
+    seq: number;
+    principal_id?: string;
+    reply_count: number;
+    parent_message_id?: string;
+    intent_card?: Record<string, unknown>;
+    thread_summary?: Array<Record<string, unknown>>;
+}
+/**
+ * Fetch channel messages via the kernel's `get-channel-messages` method.
+ *
+ * Unlike `fetchVfsChildren` (which returns raw VFS items without computed
+ * fields), this calls the kernel method that computes `reply_count` and
+ * `thread_summary` on each message — the metadata needed for thread UX.
+ *
+ * @param channelPath   VFS path of the channel
+ * @param parentMessageId  If set, returns thread replies for that parent.
+ *                         If omitted, returns top-level messages.
+ */
+declare function fetchChannelMessages(channelPath: string, parentMessageId?: string): Promise<ChannelMessage[]>;
+/** Response shape from fetchChannelMessagesPage. */
+interface ChannelMessagesPage {
+    messages: ChannelMessage[];
+    /** Mode returned by kernel: 'top_level' or 'thread'. */
+    mode: 'top_level' | 'thread';
+}
+/**
+ * Fetch a single page of channel messages with cursor-based pagination.
+ *
+ * Calls `get-channel-messages` which dispatches to `kernel_get_channel_messages_v2`.
+ * The kernel supports:
+ *   - `limit` (default 50, max 200)
+ *   - `before_seq` — fetch messages with seq < value (for backward/older pagination)
+ *   - `after_seq` — fetch messages with seq > value (for forward/newer pagination)
+ *
+ * @param channelPath       VFS path of the channel
+ * @param parentMessageId   If set, fetches thread replies (uses after_seq for forward paging)
+ * @param limit             Number of messages per page (default 50)
+ * @param before_seq        Cursor for backward pagination (top-level: load older)
+ * @param after_seq         Cursor for forward pagination (thread: load newer)
+ */
+declare function fetchChannelMessagesPage(channelPath: string, options?: {
+    parentMessageId?: string;
+    limit?: number;
+    before_seq?: number;
+    after_seq?: number;
+}): Promise<ChannelMessagesPage>;
+declare function invalidateChildren(path: string): void;
+declare function invalidateItem(path: string): void;
+declare function invalidatePathAndParent(path: string, fallbackParent?: string): void;
+declare function invalidateSubtree(path: string): void;
+declare function invalidateAllVfs(): void;
+declare function invalidateTypes(scopeId?: string): void;
+/**
+ * Invalidate cached channel messages.
+ * If channelPath is provided, invalidates that channel's messages.
+ * If not, invalidates all channel-messages queries.
+ */
+declare function invalidateChannelMessages(channelPath?: string, parentMessageId?: string): void;
+/**
+ * Invalidate cached open envelopes.
+ * If path is provided, invalidates that path's envelope (all strategies).
+ * If not, invalidates all open-envelope queries.
+ */
+declare function invalidateOpenEnvelope(path?: string, strategy?: string): void;
+
+/**
+ * @fsaos/gateway — VFS Realtime (WebSocket Transport)
+ *
+ * Subscribes to VFS change events via the gateway WebSocket and invalidates
+ * the corresponding TanStack Query caches.
+ *
+ * Subscription model:
+ *   - At login: subscribe to the logged-in account's item ID
+ *   - On mount: subscribe to additional account/space item IDs
+ *   - On unmount: unsubscribe from those IDs
+ *
+ * The gateway routes vfs_change events by account_item_id and space_item_id.
+ * The client subscribes to account IDs and receives all VFS changes for items
+ * belonging to those accounts.
+ *
+ * Lifecycle:
+ *   1. initVfsRealtimeWs(accountId) — subscribe to account's vfs_change events
+ *   2. mountRealtimeScope(id) — subscribe to an additional account/space
+ *   3. unmountRealtimeScope(id) — unsubscribe from a mounted scope
+ *   4. disposeVfsRealtimeWs() — unsubscribe all and clear timers
+ *
+ * Invalidation strategy:
+ *   - INSERT/UPDATE: set item data directly + invalidate parent's children list
+ *   - DELETE: remove item queries + invalidate parent's children list
+ *   - Tree queries: invalidate any tree whose root is an ancestor of the changed path
+ */
+/**
+ * Subscribe to VFS realtime events for the primary account via the gateway WebSocket.
+ * Automatically invalidates TanStack Query caches when items change.
+ *
+ * @param accountId - The account_item_id (primary logged-in account UUID)
+ */
+declare function initVfsRealtimeWs(accountId: string): void;
+/**
+ * Mount an additional scope (account or space) for realtime events.
+ * Call this when the user mounts a new account or space.
+ *
+ * @param scopeId - The account_item_id or space_item_id to subscribe to
+ */
+declare function mountRealtimeScope(scopeId: string): void;
+/**
+ * Unmount a scope (account or space) from realtime events.
+ * Call this when the user unmounts an account or space.
+ *
+ * @param scopeId - The account_item_id or space_item_id to unsubscribe from
+ */
+declare function unmountRealtimeScope(scopeId: string): void;
+/**
+ * Tear down all VFS realtime WebSocket subscriptions.
+ */
+declare function disposeVfsRealtimeWs(): void;
+
+/**
+ * @fsaos/gateway — WebSocket Transport Layer
+ *
+ * Replaces the SSE transport with a bidirectional WebSocket connection.
+ * Provides per-scope subscription routing (fixing the cross-account data leak)
+ * and supports upstream events (presence, typing, edits).
+ *
+ * Public API:
+ *   - subscribeToPath(path, callback) → unsubscribe
+ *   - subscribeToEvents(eventType, callback, filter?) → unsubscribe
+ *   - disconnectSSE() — tear down connection and clear all state
+ *
+ * Additionally exposes:
+ *   - emitEvent(scopeId, eventType, payload) — upstream events
+ *   - subscribeToScope(scopeId, eventTypes) — explicit scope subscription
+ *
+ * Lifecycle:
+ *   - Connection is only opened when there are active scope or path subscriptions
+ *   - While the browser tab is visible, a 30s ping keeps the connection alive
+ *   - When the tab is hidden, pings stop and the connection is allowed to die
+ *   - When the tab becomes visible again, the connection is re-established
+ *   - Connection attempts have a 10s timeout to prevent stuck promises
+ */
+/**
+ * Subscribe to events for a specific VFS path (token_stream routing).
+ * Lazily connects to the gateway's /ws endpoint on first subscription.
+ * Returns an unsubscribe function.
+ */
+declare function subscribeToPath(path: string, callback: (data: any) => void): () => void;
+/**
+ * Subscribe to events by type with optional filter predicate.
+ * The WebSocket connection is shared — one connection, many consumers.
+ *
+ * NOTE: This does NOT open a connection by itself. A scope or path subscription
+ * must exist for the connection to be established.
+ */
+declare function subscribeToEvents(eventType: string | string[], callback: (data: any) => void, filter?: (data: any) => boolean): () => void;
+/**
+ * Subscribe to a scope for VFS/CCM change events.
+ * This is the primary subscription mechanism for per-account isolation.
+ * Opening a scope subscription is what triggers the WebSocket connection.
+ */
+declare function subscribeToScope(scopeId: string, eventTypes?: string[]): () => void;
+/**
+ * Emit an upstream event to other clients subscribed to the same scope.
+ * Used for presence, typing indicators, cursor positions, etc.
+ */
+declare function emitEvent(scopeId: string, eventType: string, payload?: Record<string, unknown>): void;
+/**
+ * Disconnect the WebSocket and clear all listeners.
+ * Backward-compatible name with sse.ts.
+ */
+declare function disconnectSSE(): void;
+/**
+ * Send a ping to keep the connection alive.
+ * Normally handled automatically by the visibility-aware lifecycle,
+ * but exposed for manual use if needed.
+ */
+declare function ping(): void;
+
+declare function readItem(path: string): Promise<GatewayResponse>;
+declare function listChildren(path: string, options?: Record<string, unknown>): Promise<GatewayResponse>;
+declare function createItem(params: Record<string, unknown>): Promise<GatewayResponse>;
+declare function updateItem(params: Record<string, unknown>): Promise<GatewayResponse>;
+declare function pushChanges(params: Record<string, unknown>): Promise<GatewayResponse>;
+declare function callTool(toolName: string, params?: Record<string, unknown>): Promise<GatewayResponse>;
+declare function signal(targetId: string, eventName: string, payload?: Record<string, unknown>): Promise<GatewayResponse>;
+declare function getAssetUrl(path: string): string;
+declare const auth: {
+    signIn: (opts: any) => Promise<_supabase_supabase_js.OAuthResponse> | Promise<_supabase_supabase_js.AuthTokenResponsePassword>;
+    signUp: (opts: any) => Promise<_supabase_supabase_js.AuthResponse>;
+    signOut: () => Promise<void>;
+    getSession: () => Promise<any>;
+    getUser: () => Promise<any>;
+    onAuthStateChange: (callback: (data: any) => void) => () => void;
+    resetPassword: (email: string) => Promise<{
+        data: {};
+        error: null;
+    } | {
+        data: null;
+        error: _supabase_supabase_js.AuthError;
+    }>;
+    signInWithMagicLink: (email: string, redirectTo?: string) => Promise<_supabase_supabase_js.AuthOtpResponse>;
+};
+
+/**
+ * Mount the root component into #root.
+ * Reads window.__FSAOS_COMPONENT__, wraps in QueryClientProvider,
+ * and renders via React 18+ createRoot.
+ */
+declare function mount(): void;
+/**
+ * Set up the require() shim and window globals.
+ * Called by the build script's footer after the IIFE assigns window.__FSAOS_GATEWAY__.
+ */
+declare function setupRequireShim(): void;
+
+/**
+ * Returns whether scope has been established. Useful for gating UI that
+ * depends on scope-aware data.
+ */
+declare function useScopeReady(): boolean;
+/** Fetch a single VFS item by path. Disabled when path is falsy. */
+declare function useItem(path: string | undefined | null): _tanstack_react_query.UseQueryResult<VFSItem | null, Error>;
+/** Fetch a single VFS item by its UUID. Disabled when id is falsy. */
+declare function useItemById(id: string | undefined | null): _tanstack_react_query.UseQueryResult<VFSItem | null, Error>;
+/** Fetch children of a VFS path. Disabled when path is falsy. */
+declare function useList(path: string | undefined | null): _tanstack_react_query.UseQueryResult<VFSItem[], Error>;
+/**
+ * Fetch children of a VFS path. Returns { children, ...queryResult }.
+ * Convenience wrapper around useList that renames `data` to `children`.
+ */
+declare function useChildren(path: string | undefined | null): {
+    children: VFSItem[];
+    data: VFSItem[];
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<VFSItem[], Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<VFSItem[]>;
+} | {
+    children: VFSItem[];
+    data: VFSItem[];
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<VFSItem[], Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<VFSItem[]>;
+} | {
+    children: VFSItem[];
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<VFSItem[], Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<VFSItem[]>;
+} | {
+    children: VFSItem[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<VFSItem[], Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<VFSItem[]>;
+} | {
+    children: VFSItem[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<VFSItem[], Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<VFSItem[]>;
+} | {
+    children: VFSItem[];
+    data: VFSItem[];
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<VFSItem[], Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<VFSItem[]>;
+};
+/** Fetch a recursive tree starting at a path. */
+declare function useTree(path: string | undefined | null, depth?: number): _tanstack_react_query.UseQueryResult<VFSItem[], Error>;
+/** Search VFS items by query string, optionally filtered by item types. */
+declare function useSearch(query: string | undefined | null, itemTypes?: string[]): _tanstack_react_query.UseQueryResult<VFSItem[], Error>;
+/** Fetch items by type with structured filters. */
+declare function useItems(filter: ItemsFilter | null | undefined): _tanstack_react_query.UseQueryResult<VFSItem[], Error>;
+/** Infinite-scroll item fetching by type. */
+declare function useInfiniteItems(filter: ItemsFilter | null | undefined): {
+    allItems: VFSItem[];
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: VFSItem[];
+        total_hint?: number;
+    }, unknown>, Error>>;
+    isFetchingNextPage: boolean;
+    isExhausted: boolean;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    totalHint: number | undefined;
+};
+/** Infinite-scroll directory listing (children of a path). */
+declare function useInfiniteChildren(path: string | undefined | null): {
+    allItems: VFSItem[];
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
+        items: VFSItem[];
+        total_hint: number;
+    }, unknown>, Error>>;
+    isFetchingNextPage: boolean;
+    isExhausted: boolean;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    totalHint: number | undefined;
+};
+/** Fetch edges for an item by its ID. */
+declare function useEdges(itemId: string | undefined | null): _tanstack_react_query.UseQueryResult<VFSEdge[], Error>;
+/** Fetch all type definitions for a scope. */
+declare function useTypes(scopeId?: string): _tanstack_react_query.UseQueryResult<Map<string, TypeDefinition>, Error>;
+/** Fetch a single type definition by type_key. */
+declare function useType(typeKey: string, scopeId?: string): {
+    data: TypeDefinition | undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Map<string, TypeDefinition>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Map<string, TypeDefinition>>;
+} | {
+    data: TypeDefinition | undefined;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Map<string, TypeDefinition>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Map<string, TypeDefinition>>;
+} | {
+    data: TypeDefinition | undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Map<string, TypeDefinition>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Map<string, TypeDefinition>>;
+} | {
+    data: TypeDefinition | undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Map<string, TypeDefinition>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Map<string, TypeDefinition>>;
+} | {
+    data: TypeDefinition | undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Map<string, TypeDefinition>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Map<string, TypeDefinition>>;
+} | {
+    data: TypeDefinition | undefined;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Map<string, TypeDefinition>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Map<string, TypeDefinition>>;
+};
+/**
+ * Open a VFS item — the primary hook for rendering any item.
+ *
+ * Calls the kernel's `open` syscall which runs the CCM resolution pipeline
+ * and returns the full OpenEnvelope:
+ * - Item identity (id, path, name, type)
+ * - Render directives (view_component_id, props, url)
+ * - Compatible components (for "Open With" menus)
+ * - Content extraction (for AI/programmatic consumers)
+ *
+ * The gateway mints signed URLs for storage-backed items before returning,
+ * so `render.props.url` is ready to use immediately.
+ *
+ * When `render.view_component_id` is null, no CCM opener is registered —
+ * the client should fall back to a system action (item-detail/inspector).
+ *
+ * @example
+ * // Default open — render mode, kernel resolves the component.
+ * const { data: envelope, isLoading } = useOpen(path);
+ * if (!envelope?.render?.view_component_id) {
+ *   return <ItemDetailView />; // system action fallback
+ * }
+ * // Mount the resolved component...
+ *
+ * @example
+ * // Open with content extraction for AI
+ * const { data } = useOpen(path, { mode: 'extract' });
+ * // data.content contains extracted text/structured data
+ *
+ * @example
+ * // "Open With" menu — read compatible_components
+ * const { data } = useOpen(path);
+ * data?.compatible_components.map(c => c.display_name);
+ */
+declare function useOpen(path: string | undefined | null, options?: OpenOptions): _tanstack_react_query.UseQueryResult<OpenEnvelope, Error>;
+interface TypeHelpers {
+    canHaveChildren: (item: VFSItem) => boolean;
+    isScope: (item: VFSItem) => boolean;
+    isScopeType: (typeKey: string) => boolean;
+    isContainerType: (typeKey: string) => boolean;
+    getTypeDefinition: (typeKey: string) => TypeDefinition | undefined;
+    getTypeColor: (typeKey: string) => string;
+    getTypeIcon: (typeKey: string) => string;
+    getTypeDisplayName: (typeKey: string) => string;
+    getKnownEdgeTypes: () => {
+        key: string;
+        label: string;
+    }[];
+    getEdgeTypeLabel: (edgeType: string) => string;
+    allTypes: Map<string, TypeDefinition>;
+    loading: boolean;
+}
+/**
+ * Convenience hook that derives type-system helper functions from useTypes().
+ */
+declare function useTypeHelpers(scopeId?: string): TypeHelpers;
+/** Fetch items assigned/relevant to the current user within a scope. */
+declare function useMemberFocus(scopeId: string | undefined | null, itemTypes?: string[], limit?: number): _tanstack_react_query.UseQueryResult<VFSItem[], Error>;
+/** Fetch the version history of a VFS item. */
+declare function useItemHistory(itemId: string | undefined | null, limit?: number, offset?: number): _tanstack_react_query.UseQueryResult<any, Error>;
+/** Fetch recent activity (audit log) for a scope. */
+declare function useRecentActivity(scopePath: string | undefined | null, limit?: number, offset?: number): _tanstack_react_query.UseQueryResult<any[], Error>;
+interface ScopeData {
+    path: string;
+    scope_id: string;
+    fractal_id: string | null;
+    instance_name: string | null;
+    display_name: string | null;
+    componentPath?: string;
+    isEmbed?: boolean;
+}
+interface ScopeResult {
+    data: ScopeData | null;
+    loading: boolean;
+    error: Error | null;
+}
+/** Returns the current scope session via initSession(). */
+declare function useScope(): ScopeResult;
+interface AccountInfo {
+    accountId: string;
+    path: string;
+    name: string;
+    role: string;
+    typeData: Record<string, unknown>;
+    joinedAt: string;
+    via?: 'direct' | 'cascade';
+    placement?: 'switcher_entry' | 'mount_only';
+    subordinateTo?: string | null;
+    cascadeAnchorId?: string | null;
+    isAccount?: boolean;
+    isSpace?: boolean;
+    isOwner?: boolean;
+    billingResponsible?: boolean;
+    grantedVia?: 'self_provisioned' | 'invitation' | 'purchase' | 'seat_assignment' | null;
+    grantedUnderAccountId?: string | null;
+    personalSpaceId?: string | null;
+    personalSpacePath?: string | null;
+}
+interface AccountsState {
+    /** Switcher-eligible accounts — billing-responsible accounts the user can operate AS. */
+    accounts: AccountInfo[];
+    /** Full membership list including mounts, spaces, cascade entries. Used for sidebar mount tree. */
+    allMemberships: AccountInfo[];
+    /** Currently active billing-responsible account (auto-selected if single, or after switchAccount). */
+    currentAccount: AccountInfo | null;
+    /** The currently mounted scope path (may differ from currentAccount.path when navigating subaccounts). */
+    mountedScope: string | null;
+    /** Switch the billing-responsible account context. Only for switcher entries. */
+    switchAccount: (accountPath: string) => void;
+    /** Mount a scope within the current billing context (e.g., navigate into a subaccount). Does NOT change currentAccount. */
+    mountScope: (scopePath: string) => void;
+    loading: boolean;
+    error: Error | null;
+}
+/** Returns the user's account memberships and provides account switching. */
+declare function useAccounts(): AccountsState;
+interface AuthState {
+    user: any | null;
+    session: any | null;
+    loading: boolean;
+    signIn: (params: {
+        email?: string;
+        password?: string;
+        provider?: string;
+        redirectTo?: string;
+    }) => Promise<any>;
+    signUp: (params: {
+        email: string;
+        password: string;
+        metadata?: Record<string, any>;
+    }) => Promise<any>;
+    signOut: () => Promise<void>;
+    resetPassword: (email: string) => Promise<void>;
+    signInWithMagicLink: (email: string, redirectTo?: string) => Promise<void>;
+}
+/** Reactive auth hook backed by Supabase auth. */
+declare function useAuth(): AuthState;
+interface AssetData {
+    url: string;
+    id?: string;
+    name?: string;
+    mimeType?: string;
+    width?: number;
+    height?: number;
+    sizeBytes?: number;
+}
+/** Resolve an asset by UUID or path. */
+declare function useAsset(idOrPath: string | undefined | null): {
+    data: AssetData | null;
+    loading: boolean;
+    error: Error | null;
+};
+/** Dynamically load a component from the edge. */
+declare function useComponent(path: string | undefined | null): {
+    Component: any;
+    loading: boolean;
+    error: Error | null;
+};
+/** Read CSS custom properties from the document root. */
+declare function useTheme(): {
+    data: {
+        tokens: Record<string, string>;
+    };
+    loading: boolean;
+    error: null;
+};
+/** Check permission for an action on a path. */
+declare function usePermission(_action?: string, _path?: string): {
+    data: {
+        allowed: boolean;
+    };
+    loading: boolean;
+    error: null;
+};
+/** Check multiple permissions at once. */
+declare function usePermissions(_path?: string, actions?: string[]): {
+    data: Record<string, boolean>;
+    loading: boolean;
+    error: null;
+};
+interface PrincipalData {
+    id: string;
+    principalId: string | null;
+    email?: string;
+    role: string;
+    authenticated: boolean;
+    metadata?: Record<string, any>;
+}
+/** Resolve current user's FSAOS os_principals.id from auth ID. */
+declare function resolvePrincipalId(authUserId?: string): Promise<string | null>;
+/** Returns the current principal (user identity). */
+declare function usePrincipal(): {
+    data: PrincipalData | null;
+    loading: boolean;
+    error: null;
+};
+/** Stub: useTool — returns null tool data. */
+declare function useTool(): {
+    data: null;
+    loading: boolean;
+    error: null;
+};
+/** <ComponentRenderer path="..." /> — runtime composition primitive. */
+declare function ComponentRenderer(props: {
+    path: string;
+    [key: string]: any;
+}): react__default.DetailedReactHTMLElement<{
+    className: string;
+}, HTMLElement> | react__default.DetailedReactHTMLElement<react__default.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> | null;
+/** Passthrough wrapper for backward compatibility. */
+declare function KernelProvider(props: {
+    children: any;
+}): any;
+interface ChannelMessagesOptions {
+    channelPath: string | undefined | null;
+    parentMessageId?: string;
+    realtime?: boolean;
+    enabled?: boolean;
+}
+/** Fetch channel messages via the kernel's `get-channel-messages` method. */
+declare function useChannelMessages(options: ChannelMessagesOptions): {
+    messages: ChannelMessage[];
+    threads: ChannelMessage[];
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<ChannelMessage[], Error>>;
+};
+/** Options for useInfiniteChannelMessages. */
+interface InfiniteChannelMessagesOptions {
+    /** VFS path of the channel. Required. */
+    channelPath: string | undefined | null;
+    /**
+     * If set, fetches thread replies (forward pagination with after_seq).
+     * If omitted, fetches top-level messages (backward pagination with before_seq).
+     */
+    parentMessageId?: string;
+    /** Messages per page. Default 50, max 200. */
+    limit?: number;
+    /** Enable SSE-driven auto-refresh. Default: true. */
+    realtime?: boolean;
+    /** Standard useQuery enabled flag. Default: true (when channelPath is truthy). */
+    enabled?: boolean;
+}
+/**
+ * Infinite-scroll hook for channel messages.
+ *
+ * - **Top-level mode** (no parentMessageId): backward pagination.
+ *   Initial fetch returns the N most recent messages. `fetchPreviousPage`
+ *   loads older messages using `before_seq` = lowest seq in current data.
+ *
+ * - **Thread mode** (parentMessageId set): forward pagination.
+ *   Initial fetch returns the first N replies. `fetchNextPage` loads newer
+ *   replies using `after_seq` = highest seq in current data.
+ *
+ * Returns a flat `messages` array (deduped, sorted by seq ASC) plus
+ * pagination state for scroll-triggered loading.
+ */
+declare function useInfiniteChannelMessages(options: InfiniteChannelMessagesOptions): {
+    messages: ChannelMessage[];
+    threads: ChannelMessage[];
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_tanstack_react_query.InfiniteData<ChannelMessagesPage, unknown>, Error>>;
+    hasPreviousPage: boolean;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<ChannelMessagesPage, unknown>, Error>>;
+    isFetchingPreviousPage: boolean;
+    hasNextPage: boolean;
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<ChannelMessagesPage, unknown>, Error>>;
+    isFetchingNextPage: boolean;
+};
+type ChannelAiMode = 'on' | 'off';
+interface Channel {
+    id: string;
+    path: string;
+    name: string;
+    displayName: string;
+    /** Controls AI auto-response only: 'on' auto-responds, 'off' requires explicit invocation/member addressing. */
+    aiMode: ChannelAiMode;
+    isPrivate: boolean;
+    isDm: boolean;
+    messageCount: number;
+    updatedAt: string;
+    chatScopePath: string;
+    contextId: string;
+    contextPath: string;
+    contextType: string;
+    contextName: string;
+    contextDisplayName: string;
+    contextPrincipalId?: string;
+    accountId: string;
+    accountPath: string;
+    accountDisplayName: string;
+    memberRole: string;
+    memberPath: string;
+    modePath: string;
+    autoPilot: boolean;
+}
+interface ChannelsOptions {
+    realtime?: boolean;
+    enabled?: boolean;
+}
+/** Fetch all channels (DMs + public) via `list-channels`. */
+declare function useAllChannels(options?: ChannelsOptions): {
+    channels: Channel[];
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Channel[], Error>>;
+};
+/** Fetch public (non-DM) channels only. */
+declare function useChannels(options?: ChannelsOptions): {
+    channels: Channel[];
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Channel[], Error>>;
+};
+/** Fetch DM channels only. */
+declare function useDmChannels(options?: ChannelsOptions): {
+    channels: Channel[];
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Channel[], Error>>;
+};
+interface Notification {
+    type: 'mention' | 'reply' | string;
+    message_id: string;
+    channel_id: string;
+    channel_path: string;
+    is_unread: boolean;
+}
+interface NotificationsOptions {
+    filter?: 'unread' | 'all';
+    limit?: number;
+    realtime?: boolean;
+    enabled?: boolean;
+}
+/** Fetch notifications via `get-notifications`. */
+declare function useNotifications(options?: NotificationsOptions): {
+    notifications: Notification[];
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Notification[], Error>>;
+};
+interface UnreadCountsOptions {
+    channels?: Channel[];
+    realtime?: boolean;
+    enabled?: boolean;
+}
+/** Aggregated unread counts per channel. */
+declare function useUnreadCounts(options?: UnreadCountsOptions): {
+    unreadByChannel: Map<string, number>;
+    totalUnread: number;
+    dmUnread: number;
+    channelUnread: number;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Notification[], Error>>;
+};
+/** Create a new VFS item. Invalidates parent's children on success. */
+declare function useCreate(): _tanstack_react_query.UseMutationResult<any, Error, CreateParams, unknown>;
+/** Update an existing VFS item. */
+declare function useUpdate(): _tanstack_react_query.UseMutationResult<any, Error, UpdateParams, unknown>;
+/** Delete a VFS item. */
+declare function useDelete(): _tanstack_react_query.UseMutationResult<any, Error, DeleteParams, unknown>;
+/** Move a VFS item. */
+declare function useMove(): _tanstack_react_query.UseMutationResult<any, Error, MoveParams, unknown>;
+/** Create an edge between two items. Invalidates edges for both. */
+declare function useLink(): _tanstack_react_query.UseMutationResult<any, Error, LinkParams, unknown>;
+/**
+ * Generic mutation hook for arbitrary kernel methods.
+ * For methods not covered by useCreate/useUpdate/useDelete/useMove/useLink.
+ *
+ * @example
+ * const archiveTask = useMutation('archive-task');
+ * await archiveTask.mutateAsync({ task_id: '...' });
+ */
+declare function useMutation(method: string, options?: {
+    onSuccess?: (data: any) => void;
+    onError?: (error: any) => void;
+    optimistic?: {
+        queryKey: readonly unknown[];
+        update: (old: any, params: Record<string, unknown>) => any;
+    };
+}): _tanstack_react_query.UseMutationResult<GatewayResponse, any, Record<string, unknown>, any>;
+/**
+ * Subscribe to SSE events of a given type.
+ * Calls the handler whenever an event arrives, optionally filtered by predicate.
+ *
+ * @example
+ * useEventStream('vfs_change', (event) => {
+ *   console.log('VFS changed:', event);
+ * });
+ */
+declare function useEventStream(handlerOrEventType: string | ((data: any) => void), handlerOrOptions?: ((data: any) => void) | {
+    eventType: string;
+    filter?: (data: any) => boolean;
+    enabled?: boolean;
+}, filter?: (data: any) => boolean): void;
+/**
+ * A useQuery wrapper that auto-refetches on matching SSE events.
+ *
+ * @example
+ * const { data } = useRealtimeQuery({
+ *   queryKey: ['my-data'],
+ *   queryFn: () => fetchMyData(),
+ *   eventType: 'vfs_change',
+ *   filter: (data) => data.path.startsWith('/root/foo'),
+ * });
+ */
+declare function useRealtimeQuery<T>(options: {
+    queryKey: readonly unknown[];
+    queryFn: () => Promise<T>;
+    eventType: string | string[];
+    filter?: (data: any) => boolean;
+    enabled?: boolean;
+    debounceMs?: number;
+}): _tanstack_react_query.UseQueryResult<_tanstack_react_query.NoInfer<T>, Error>;
+
+/**
+ * @fsaos/gateway — Schema Interpretation Utilities
+ *
+ * Derives UI capabilities (filterable fields, sortable fields, table columns,
+ * form fields) from a type definition's input_schema and system_schema.
+ *
+ * The type definition IS the contract. These utilities read it and return
+ * structured metadata that UI components use to render generically.
+ */
+
+/** A field descriptor derived from the type's JSON Schema. */
+interface FieldDescriptor {
+    /** Field key (property name in type_data). */
+    key: string;
+    /** Human-readable label derived from schema title or key. */
+    label: string;
+    /** JSON Schema type (string, number, integer, boolean, array, object). */
+    type: string;
+    /** Description from schema. */
+    description?: string;
+    /** Enum values if constrained. */
+    enum_values?: string[];
+    /** Default value from default_data or field_defaults. */
+    default_value?: any;
+    /** Whether this field is user-editable (from input_schema) or system-managed. */
+    editable: boolean;
+    /** Whether this field can be used as a filter. */
+    filterable: boolean;
+    /** Whether this field can be sorted on. */
+    sortable: boolean;
+    /** Suggested filter widget type. */
+    filter_widget: 'select' | 'text' | 'toggle' | 'range' | 'date' | 'none';
+}
+/** Complete schema interpretation result for a type. */
+interface TypeSchema {
+    /** All fields (input + system), ordered as declared. */
+    fields: FieldDescriptor[];
+    /** Fields suitable for table columns (non-object, non-array). */
+    columns: FieldDescriptor[];
+    /** Fields that can be filtered on. */
+    filterable: FieldDescriptor[];
+    /** Fields that can be sorted on. */
+    sortable: FieldDescriptor[];
+    /** Fields for creation/edit forms (input_schema only). */
+    form_fields: FieldDescriptor[];
+    /** Fields that are system-managed (read-only display). */
+    system_fields: FieldDescriptor[];
+}
+/**
+ * Interpret a type definition's schemas and return structured field metadata.
+ *
+ * @example
+ * const typeDef = useType('project');
+ * const schema = interpretSchema(typeDef);
+ * // schema.columns → fields to show in table
+ * // schema.filterable → fields to offer as filters
+ * // schema.form_fields → fields for create/edit form
+ */
+declare function interpretSchema(typeDef: TypeDefinition): TypeSchema;
+/**
+ * Get the default sort field for a type.
+ * Returns 'updated_at' as the universal default (column on os_items).
+ */
+declare function getDefaultSort(_typeDef: TypeDefinition): {
+    field: string;
+    direction: 'asc' | 'desc';
+};
+/**
+ * Get the creation form schema for a type — only editable fields
+ * that don't have defaults (i.e., the user must provide them).
+ */
+declare function getRequiredFormFields(typeDef: TypeDefinition): FieldDescriptor[];
+
+/**
+ * @fsaos/gateway — File Upload
+ *
+ * Two exports:
+ *   - uploadFile()    — imperative, returns a Promise. Use from Fractals, scripts,
+ *                       non-React contexts, or anywhere you just need the result.
+ *   - useFileUpload() — React hook wrapping uploadFile() with reactive state
+ *                       (progress tracking, retry, cancel, uploads list).
+ *
+ * Both orchestrate the same three-step dance:
+ *   1. gatewayCall('create', { file_source }) → VFS item + storage instruction
+ *   2. PUT binary → storage worker (direct upload, no gateway proxy)
+ *   3. POST /storage/upload-complete → gateway verifies + commits file_ref
+ *
+ * The consumer never sees storage_instruction, upload_token, or the
+ * upload-complete endpoint. They call upload(file, opts) and get a result.
+ */
+interface FileRef {
+    storage_key: string;
+    provider: string;
+    content_type: string;
+    size_bytes: number;
+    version: number;
+    etag?: string;
+}
+interface UploadOptions {
+    /** VFS path where the file item will be created (required). */
+    parentPath: string;
+    /** Override the file name (defaults to File.name). */
+    name?: string;
+    /** Override item_type (defaults to 'file'). */
+    itemType?: string;
+    /** Additional type_data fields to merge onto the created item. */
+    typeData?: Record<string, unknown>;
+}
+interface UploadResult {
+    itemId: string;
+    itemPath: string;
+    fileRef: FileRef;
+}
+interface UploadItem {
+    /** Client-generated tracking ID. */
+    id: string;
+    /** The original File object. */
+    file: File;
+    /** Current status in the three-step dance. */
+    status: 'creating' | 'uploading' | 'confirming' | 'complete' | 'error';
+    /** Upload progress 0–100 (only meaningful during 'uploading'). */
+    progress: number;
+    /** Error message if status is 'error'. */
+    error: string | null;
+    /** VFS item ID (available after 'creating' succeeds). */
+    itemId: string | null;
+    /** VFS item path. */
+    itemPath: string | null;
+    /** Completed file_ref (available when status is 'complete'). */
+    fileRef: FileRef | null;
+    /** The options that were passed to upload(). */
+    options: UploadOptions;
+}
+interface UseFileUploadReturn {
+    /** Upload a single file. */
+    upload: (file: File, options: UploadOptions) => void;
+    /** Upload multiple files to the same destination. */
+    uploadMultiple: (files: File[], options: UploadOptions) => void;
+    /** Reactive list of all uploads (in-progress, completed, failed). */
+    uploads: UploadItem[];
+    /** Retry a failed upload from the step it failed at. */
+    retryUpload: (uploadId: string) => void;
+    /** Cancel an in-progress upload (aborts XHR if uploading). */
+    cancelUpload: (uploadId: string) => void;
+    /** Remove a completed or failed upload from the list. */
+    removeUpload: (uploadId: string) => void;
+    /** Remove all completed uploads from the list. */
+    clearCompleted: () => void;
+    /** True if any upload is currently in progress. */
+    isUploading: boolean;
+}
+/**
+ * Upload a file to the VFS. Handles the full three-step dance:
+ * create → upload binary → confirm.
+ *
+ * @param file       The File or Blob to upload.
+ * @param options    Where to put it and what to call it.
+ * @param onProgress Optional callback for upload progress (0–100).
+ * @param signal     Optional AbortSignal for cancellation.
+ * @returns          The created item's ID, path, and committed file_ref.
+ */
+declare function uploadFile(file: File | Blob, options: UploadOptions, onProgress?: (percent: number) => void, signal?: AbortSignal): Promise<UploadResult>;
+/**
+ * React hook for file uploads. Wraps uploadFile() with reactive state:
+ * tracks progress, supports retry from the failed step, cancel, and
+ * manages a list of concurrent uploads.
+ *
+ * @example
+ * ```tsx
+ * const { upload, uploads, isUploading } = useFileUpload();
+ *
+ * const handleDrop = (files: File[]) => {
+ *   for (const file of files) {
+ *     upload(file, { parentPath: '/root/accounts/.../drive' });
+ *   }
+ * };
+ *
+ * return (
+ *   <div onDrop={handleDrop}>
+ *     {uploads.map(u => (
+ *       <div key={u.id}>{u.file.name} — {u.status} — {u.progress}%</div>
+ *     ))}
+ *   </div>
+ * );
+ * ```
+ */
+declare function useFileUpload(): UseFileUploadReturn;
+
+export { type AccountInfo, type Channel, type ChannelMessage, type ChannelMessagesOptions, type ChannelMessagesPage, type ChannelsOptions, type ComponentOpener, ComponentRenderer, type CreateParams, type DeleteParams, EnforcementDeniedError, type EnforcementPayload, type FieldDescriptor, type FileRef, type GatewayParams, type GatewayResponse, type InfiniteChannelMessagesOptions, type ItemsFilter, KernelProvider, type LinkParams, type MoveParams, type Notification, type NotificationsOptions, type OpenEnvelope, type OpenOptions, type PrincipalData, type SessionEntry, type TypeDefinition, type TypeHelpers, type TypeSchema, type UnreadCountsOptions, type UpdateParams, type UploadItem, type UploadOptions, type UploadResult, type UseFileUploadReturn, type VFSEdge, type VFSItem, auth, awaitScopeReady, callTool, clearCachedToken, clearSession, createItem, disconnectSSE, disposeVfsRealtimeWs, emitEvent, fetchChannelMessages, fetchChannelMessagesPage, fetchEdgesForItem, fetchItemHistory, fetchItems, fetchMemberFocus, fetchOpenEnvelope, fetchRecentActivity, fetchTypeDefinitions, fetchVfsChildren, fetchVfsChildrenPage, fetchVfsItem, fetchVfsItemById, fetchVfsTree, gatewayCall, getAccessToken, getAssetUrl, getDefaultSort, getRequiredFormFields, getScope, getScopeVersion, getSessionEntry, initSession, initVfsRealtimeWs, interpretSchema, invalidateAllVfs, invalidateChannelMessages, invalidateChildren, invalidateItem, invalidateOpenEnvelope, invalidatePathAndParent, invalidateSubtree, invalidateTypes, isScopeReady, listChildren, mount, mountRealtimeScope, normalizeItem, ping, pushChanges, queryClient, readItem, registerCleanup, resetAllSdkState, resolvePrincipalId, setCachedToken, setScope, setupRequireShim, signal, subscribeScope, subscribeToEvents, subscribeToPath, subscribeToScope, unmountRealtimeScope, updateItem, uploadFile, useAccounts, useAllChannels, useAsset, useAuth, useChannelMessages, useChannels, useChildren, useComponent, useCreate, useDelete, useDmChannels, useEdges, useEventStream, useFileUpload, useInfiniteChannelMessages, useInfiniteChildren, useInfiniteItems, useItem, useItemById, useItemHistory, useItems, useLink, useList, useMemberFocus, useMove, useMutation, useNotifications, useOpen, usePermission, usePermissions, usePrincipal, useRealtimeQuery, useRecentActivity, useScope, useScopeReady, useSearch, useTheme, useTool, useTree, useType, useTypeHelpers, useTypes, useUnreadCounts, useUpdate, vfsKeys };