@rebasepro/studio 0.0.1-canary.09e5ec5

package/dist/studio/src/components/ApiExplorer/ApiExplorer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Custom-built API Explorer for Rebase Studio.
+ * No external dependencies — renders the OpenAPI spec natively
+ * with deep integration into the Rebase auth system.
+ */
+export declare function ApiExplorer(): import("react/jsx-runtime").JSX.Element;
+export declare namespace ApiExplorer {
+    var displayName: string;
+}

package/dist/studio/src/components/ApiExplorer/EndpointDetail.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedEndpoint, OpenApiSpec } from "./types";
+/**
+ * Renders the documentation view for a single API endpoint:
+ * parameters, request body schema, response schemas.
+ */
+export declare function EndpointDetail({ endpoint, spec }: {
+    endpoint: ParsedEndpoint;
+    spec: OpenApiSpec;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/studio/src/components/ApiExplorer/TryItPanel.d.ts

@@ -0,0 +1,15 @@
+import type { ParsedEndpoint } from "./types";
+import type { User } from "@rebasepro/types";
+interface TryItPanelProps {
+    endpoint: ParsedEndpoint;
+    apiUrl: string;
+    getAuthToken: () => Promise<string | null | undefined>;
+    user: User | null;
+    basePath?: string;
+}
+/**
+ * Interactive "Try It" panel that lets the user execute API requests
+ * using their current JWT token directly from the Studio.
+ */
+export declare function TryItPanel({ endpoint, apiUrl, getAuthToken, user, basePath }: TryItPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/studio/src/components/ApiExplorer/parseSpec.d.ts

@@ -0,0 +1,16 @@
+import type { OpenApiSpec, ParsedEndpoint, EndpointGroup } from "./types";
+/**
+ * Parse an OpenAPI 3.x spec into grouped, sorted endpoints for the sidebar.
+ */
+export declare function parseOpenApiSpec(spec: OpenApiSpec): {
+    groups: EndpointGroup[];
+    allEndpoints: ParsedEndpoint[];
+};
+/**
+ * Resolve a $ref string (e.g. "#/components/schemas/Author") to a schema name.
+ */
+export declare function resolveRefName(ref: string): string;
+/**
+ * Resolve a $ref to its actual schema from the spec.
+ */
+export declare function resolveRef(spec: OpenApiSpec, ref: string): any;

package/dist/studio/src/components/ApiExplorer/types.d.ts

@@ -0,0 +1,90 @@
+/** Minimal OpenAPI 3.x types we care about */
+export interface OpenApiSpec {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+    };
+    servers?: {
+        url: string;
+        description?: string;
+    }[];
+    paths: Record<string, Record<string, OpenApiOperation>>;
+    components?: {
+        schemas?: Record<string, OpenApiSchema>;
+        securitySchemes?: Record<string, any>;
+    };
+    tags?: {
+        name: string;
+        description?: string;
+    }[];
+    security?: Record<string, string[]>[];
+}
+export interface OpenApiOperation {
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    parameters?: OpenApiParameter[];
+    requestBody?: {
+        required?: boolean;
+        content?: Record<string, {
+            schema?: OpenApiSchema;
+        }>;
+    };
+    responses?: Record<string, {
+        description?: string;
+        content?: Record<string, {
+            schema?: OpenApiSchema;
+        }>;
+    }>;
+    security?: Record<string, string[]>[];
+}
+export interface OpenApiParameter {
+    name: string;
+    in: "query" | "path" | "header" | "cookie";
+    description?: string;
+    required?: boolean;
+    schema?: OpenApiSchema;
+}
+export interface OpenApiSchema {
+    type?: string;
+    format?: string;
+    description?: string;
+    properties?: Record<string, OpenApiSchema>;
+    required?: string[];
+    items?: OpenApiSchema;
+    enum?: (string | number)[];
+    oneOf?: OpenApiSchema[];
+    anyOf?: OpenApiSchema[];
+    allOf?: OpenApiSchema[];
+    $ref?: string;
+    readOnly?: boolean;
+    minimum?: number;
+    maximum?: number;
+    maxLength?: number;
+    minLength?: number;
+    default?: any;
+    example?: any;
+    additionalProperties?: boolean | OpenApiSchema;
+}
+export interface ParsedEndpoint {
+    id: string;
+    method: string;
+    path: string;
+    shortPath: string;
+    summary: string;
+    description: string;
+    tags: string[];
+    parameters: OpenApiParameter[];
+    requestBody?: OpenApiOperation["requestBody"];
+    responses: NonNullable<OpenApiOperation["responses"]>;
+    security?: OpenApiOperation["security"];
+    operationId?: string;
+}
+export interface EndpointGroup {
+    tag: string;
+    description?: string;
+    endpoints: ParsedEndpoint[];
+}

package/dist/studio/src/components/AuthSimulationSelector.d.ts

@@ -0,0 +1,11 @@
+import { SelectableUser } from "@rebasepro/core";
+export interface AuthSimulationSelectorProps {
+    authMode: "jwt" | "none";
+    setAuthMode: (mode: "jwt" | "none") => void;
+    selectedUser: SelectableUser | null;
+    setSelectedUser: (user: SelectableUser | null) => void;
+    users: SelectableUser[];
+    loading?: boolean;
+    currentUser: SelectableUser | null;
+}
+export declare function AuthSimulationSelector({ authMode, setAuthMode, selectedUser, setSelectedUser, users, loading, currentUser }: AuthSimulationSelectorProps): import("react/jsx-runtime").JSX.Element;

package/dist/studio/src/components/Branches/BranchesView.d.ts

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

package/dist/studio/src/components/CronJobs/CronJobsView.d.ts

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

package/dist/studio/src/components/JSEditor/JSEditor.d.ts

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

package/dist/studio/src/components/JSEditor/JSEditorSidebar.d.ts

@@ -0,0 +1,21 @@
+export interface JSSnippet {
+    id: string;
+    name: string;
+    code: string;
+    createdAt: number;
+    isFavorite?: boolean;
+}
+interface CollectionInfo {
+    slug: string;
+    properties: string[];
+}
+interface JSEditorSidebarProps {
+    collections: CollectionInfo[];
+    snippets: JSSnippet[];
+    history: string[];
+    onSelectSnippet: (code: string) => void;
+    onDeleteSnippet: (id: string) => void;
+    onInsertCode: (code: string) => void;
+}
+export declare const JSEditorSidebar: ({ collections, snippets, history, onSelectSnippet, onDeleteSnippet, onInsertCode }: JSEditorSidebarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/studio/src/components/JSEditor/JSMonacoEditor.d.ts

@@ -0,0 +1,18 @@
+export type CollectionInfo = {
+    slug: string;
+    name: string;
+    properties: string[];
+};
+export type JSMonacoEditorProps = {
+    value: string;
+    onChange: (value: string | undefined) => void;
+    onRun?: (selectedText?: string) => void;
+    className?: string;
+    readOnly?: boolean;
+    autoFocus?: boolean;
+    /** Collection slugs for basic autocomplete */
+    collectionSlugs?: string[];
+    /** Full collection info with property names for richer type generation */
+    collections?: CollectionInfo[];
+};
+export declare const JSMonacoEditor: ({ value, onChange, onRun, className, readOnly, autoFocus, collectionSlugs, collections }: JSMonacoEditorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/studio/src/components/RLSEditor/PolicyEditor.d.ts

@@ -0,0 +1,9 @@
+import { PostgresPolicy } from "./RLSEditor";
+export interface PolicyEditorProps {
+    policy?: PostgresPolicy;
+    schema: string;
+    table: string;
+    onSave: (policyData: Partial<PostgresPolicy>) => void;
+    onCancel: () => void;
+}
+export declare const PolicyEditor: ({ policy, schema, table, onSave, onCancel }: PolicyEditorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/studio/src/components/RLSEditor/RLSEditor.d.ts

@@ -0,0 +1,19 @@
+export interface PostgresPolicy {
+    policyname: string;
+    tablename: string;
+    permissive: "PERMISSIVE" | "RESTRICTIVE";
+    roles: string[];
+    cmd: "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "ALL";
+    qual: string | null;
+    with_check: string | null;
+    status?: "live" | "code_only" | "both";
+}
+export interface TableRLSStatus {
+    schemaName: string;
+    tableName: string;
+    rlsEnabled: boolean;
+    policies: PostgresPolicy[];
+}
+export declare const RLSEditor: ({ apiUrl }: {
+    apiUrl?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/studio/src/components/RLSEditor/index.d.ts

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

package/dist/studio/src/components/RebaseStudio.d.ts

@@ -0,0 +1,2 @@
+import type { RebaseStudioConfig } from "@rebasepro/types";
+export declare function RebaseStudio({ tools, homePage }: RebaseStudioConfig): null;

package/dist/studio/src/components/SQLEditor/ExplainVisualizer.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+export interface ExplainPlanNode {
+    "Node Type": string;
+    "Relation Name"?: string;
+    "Alias"?: string;
+    "Startup Cost": number;
+    "Total Cost": number;
+    "Plan Rows": number;
+    "Plan Width": number;
+    "Actual Startup Time"?: number;
+    "Actual Total Time"?: number;
+    "Actual Rows"?: number;
+    "Actual Loops"?: number;
+    "Filter"?: string;
+    "Index Cond"?: string;
+    "Hash Cond"?: string;
+    "Plans"?: ExplainPlanNode[];
+    [key: string]: unknown;
+}
+export interface ExplainVisualizerProps {
+    plan: ExplainPlanNode;
+    isRoot?: boolean;
+}
+export declare const ExplainVisualizer: React.FC<ExplainVisualizerProps>;

package/dist/studio/src/components/SQLEditor/MonacoEditor.d.ts

@@ -0,0 +1,17 @@
+export type MonacoEditorProps = {
+    value: string;
+    onChange: (value: string | undefined) => void;
+    onRun?: (selectedText?: string) => void;
+    className?: string;
+    readOnly?: boolean;
+    autoFocus?: boolean;
+    schemas?: Record<string, {
+        schemaName: string;
+        tableName: string;
+        columns: {
+            name: string;
+            dataType: string;
+        }[];
+    }[]>;
+};
+export declare const MonacoEditor: ({ value, onChange, onRun, className, readOnly, autoFocus, schemas }: MonacoEditorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/studio/src/components/SQLEditor/SQLEditor.d.ts

@@ -0,0 +1,11 @@
+export interface SQLEditorColumnInfo {
+    name: string;
+    dataType: string;
+    isPrimaryKey: boolean;
+}
+export interface TableInfo {
+    schemaName: string;
+    tableName: string;
+    columns: SQLEditorColumnInfo[];
+}
+export declare const SQLEditor: () => import("react/jsx-runtime").JSX.Element;

package/dist/studio/src/components/SQLEditor/SQLEditorSidebar.d.ts

@@ -0,0 +1,21 @@
+import { TableInfo } from "./SQLEditor";
+export interface Snippet {
+    id: string;
+    name: string;
+    sql: string;
+    createdAt: number;
+    isFavorite?: boolean;
+}
+interface SQLEditorSidebarProps {
+    onSelectSnippet: (sql: string) => void;
+    onTableClick: (tableName: string) => void;
+    snippets: Snippet[];
+    history: string[];
+    onDeleteSnippet: (id: string) => void;
+    schemas: Record<string, TableInfo[]>;
+    isSchemaLoading: boolean;
+    schemaError: string | null;
+    onRetrySchema: () => void;
+}
+export declare const SQLEditorSidebar: ({ onSelectSnippet, onTableClick, snippets, history, onDeleteSnippet, schemas, isSchemaLoading, schemaError, onRetrySchema }: SQLEditorSidebarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/studio/src/components/SQLEditor/SchemaBrowser.d.ts

@@ -0,0 +1,8 @@
+import { TableInfo } from "./SQLEditor";
+export declare const SchemaBrowser: ({ onTableClick, schemas, isSchemaLoading, schemaError, onRetrySchema }: {
+    onTableClick?: (tableName: string) => void;
+    schemas: Record<string, TableInfo[]>;
+    isSchemaLoading: boolean;
+    schemaError: string | null;
+    onRetrySchema: () => void;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/studio/src/components/SchemaVisualizer/RelationEdge.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { EdgeProps } from "@xyflow/react";
+export declare const RelationEdge: React.MemoExoticComponent<({ id, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, data, selected }: EdgeProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/studio/src/components/SchemaVisualizer/SchemaVisualizer.d.ts

@@ -0,0 +1,2 @@
+import "@xyflow/react/dist/style.css";
+export declare const SchemaVisualizer: () => import("react/jsx-runtime").JSX.Element;

package/dist/studio/src/components/SchemaVisualizer/TableNode.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { NodeProps } from "@xyflow/react";
+export declare const TableNode: React.MemoExoticComponent<({ data, selected }: NodeProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/studio/src/components/SchemaVisualizer/index.d.ts

@@ -0,0 +1,5 @@
+export { SchemaVisualizer } from "./SchemaVisualizer";
+export { TableNode } from "./TableNode";
+export { RelationEdge } from "./RelationEdge";
+export { useSchemaGraph } from "./useSchemaGraph";
+export type { TableNodeData, ColumnInfo } from "./useSchemaGraph";

package/dist/studio/src/components/SchemaVisualizer/schema-visualizer.utils.d.ts

@@ -0,0 +1,42 @@
+import type { Node, Edge } from "@xyflow/react";
+export declare const NODE_WIDTH = 280;
+/** Header with a single line of text (junction tables or tableName === collectionName). */
+export declare const HEADER_HEIGHT_SINGLE = 33;
+/** Header with two lines (name + subtitle when collectionName !== tableName). */
+export declare const HEADER_HEIGHT_DOUBLE = 47;
+/**
+ * Compute the correct header height for a table node.
+ */
+export declare const getHeaderHeight: (opts: {
+    isJunction: boolean;
+    collectionName: string;
+    tableName: string;
+}) => number;
+/**
+ * Estimate the pixel height of a table node based on column count.
+ */
+export declare const estimateNodeHeight: (columnCount: number, headerHeight?: number) => number;
+/**
+ * Get the vertical center Y of a specific column row (0-indexed)
+ * relative to the top of the node.
+ */
+export declare const getColumnRowY: (rowIndex: number, headerHeight?: number) => number;
+export type LayoutDirection = "TB" | "LR";
+/**
+ * Compute node positions using the dagre graph layout engine.
+ * Returns a new array of nodes with updated `position`.
+ */
+export declare const getLayoutedElements: (nodes: Node[], edges: Edge[], direction?: LayoutDirection) => {
+    nodes: Node[];
+    edges: Edge[];
+};
+export declare const getTypeLabel: (type: string) => string;
+export interface RelationEdgeData {
+    cardinality: "one" | "many";
+    direction: "owning" | "inverse";
+    relationName: string;
+    hasJunction: boolean;
+    hasJoinPath: boolean;
+    label: string;
+}
+export declare const getCardinalityLabel: (cardinality: "one" | "many", direction: "owning" | "inverse") => string;

package/dist/studio/src/components/SchemaVisualizer/useSchemaGraph.d.ts

@@ -0,0 +1,37 @@
+import type { Node, Edge } from "@xyflow/react";
+import type { EntityCollection } from "@rebasepro/types";
+import type { LayoutDirection } from "./schema-visualizer.utils";
+export interface ColumnInfo {
+    name: string;
+    type: string;
+    typeLabel: string;
+    isPrimaryKey: boolean;
+    isForeignKey: boolean;
+    isRequired: boolean;
+    isEnum: boolean;
+    enumValues?: string[];
+    relationName?: string;
+}
+export interface TableNodeData {
+    tableName: string;
+    collectionName: string;
+    slug: string;
+    columns: ColumnInfo[];
+    isJunction: boolean;
+    isUnmanaged: boolean;
+    rlsEnabled: boolean;
+    historyEnabled: boolean;
+    icon?: string;
+    [key: string]: unknown;
+}
+export interface UseSchemaGraphResult {
+    nodes: Node[];
+    edges: Edge[];
+    direction: LayoutDirection;
+    setDirection: (dir: LayoutDirection) => void;
+    relayout: () => void;
+    isLoading: boolean;
+    tableCount: number;
+    relationCount: number;
+}
+export declare const useSchemaGraph: (collections: EntityCollection[] | undefined) => UseSchemaGraphResult;

package/dist/studio/src/components/StorageView/StorageView.d.ts

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

package/dist/studio/src/components/StudioHomePage.d.ts

@@ -0,0 +1,9 @@
+import type { HomePageSection } from "@rebasepro/types";
+import React from "react";
+export declare function StudioHomePage({ additionalActions, additionalChildrenStart, additionalChildrenEnd, sections, hiddenGroups }: {
+    additionalActions?: React.ReactNode;
+    additionalChildrenStart?: React.ReactNode;
+    additionalChildrenEnd?: React.ReactNode;
+    sections?: HomePageSection[];
+    hiddenGroups?: string[];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/studio/src/index.d.ts

@@ -0,0 +1,4 @@
+export { StudioBridgeProvider, StudioBridgeContext, useStudioCollectionRegistry, useStudioSideEntityController, useStudioUrlController, useStudioNavigationState, useStudioBreadcrumbs } from "@rebasepro/core";
+export type { StudioBridge, BreadcrumbEntry, BreadcrumbsController } from "@rebasepro/core";
+export * from "./components/RebaseStudio";
+export * from "./components/StudioHomePage";

package/dist/studio/src/utils/pgColumnToProperty.d.ts

@@ -0,0 +1,6 @@
+import { EntityCollection, TableMetadata } from "@rebasepro/types";
+/**
+ * Builds a partial EntityCollection from PostgreSQL table metadata.
+ * This is used when creating a new collection from an existing database table.
+ */
+export declare function buildCollectionFromTableMetadata(tableName: string, metadata: TableMetadata): Partial<EntityCollection>;

package/dist/studio/src/utils/sql_utils.d.ts

@@ -0,0 +1,52 @@
+import { TableInfo } from "../components/SQLEditor/SQLEditor";
+import { EntityCollection } from "@rebasepro/types";
+/**
+ * A table extracted from a SQL query's FROM/JOIN clauses.
+ */
+export interface ExtractedTable {
+    name: string;
+    alias?: string;
+}
+/**
+ * A collection matched to a table in a SQL query.
+ */
+export interface ResolvedQueryCollection {
+    /** DB table name from the SQL AST (e.g. "blog_posts") */
+    tableName: string;
+    /** SQL alias if present (e.g. "bp") */
+    tableAlias?: string;
+    /** The matched collection */
+    collection: EntityCollection;
+    /** Columns from this table that are present in the result set */
+    columns: string[];
+    /** The result column name that holds the primary key for this table (e.g. "id", "author_id") */
+    pkColumn?: string;
+}
+/**
+ * Extract all tables referenced in a SQL query's FROM and JOIN clauses.
+ * Returns an empty array for non-SELECT queries or parse failures.
+ */
+export declare function extractTablesFromQuery(sqlString: string): ExtractedTable[];
+/**
+ * Resolve which collections are referenced by a SQL query.
+ *
+ * Parses the SQL, extracts table names, and matches each against
+ * registered collections via `collection.table` (falling back to
+ * snake_case of `collection.slug`).
+ *
+ * For each matched collection, determines which result columns
+ * belong to that table using the database schema information.
+ */
+export declare function resolveQueryCollections(sqlString: string, schemas: Record<string, TableInfo[]>, collections: EntityCollection[], resultColumns?: string[]): ResolvedQueryCollection[];
+export interface PKMapping {
+    /** The actual column name in the database table */
+    dbColumn: string;
+    /** The column name as it appears in the query result set (may be aliased) */
+    resultColumn: string;
+}
+export interface TableAndPKResult {
+    tableName?: string;
+    primaryKeys?: PKMapping[];
+    error?: string;
+}
+export declare function determineTableAndPK(sqlString: string, columnKey: string, schemas: Record<string, TableInfo[]>): TableAndPKResult;

package/dist/types/src/controllers/analytics_controller.d.ts

@@ -0,0 +1,7 @@
+export type AnalyticsController = {
+    /**
+     * Callback used to get analytics events from the CMS
+     */
+    onAnalyticsEvent?: (event: AnalyticsEvent, data?: object) => void;
+};
+export type AnalyticsEvent = "entity_click" | "entity_click_from_reference" | "reference_selection_clear" | "reference_selection_toggle" | "reference_selected_single" | "reference_selection_new_entity" | "edit_entity_clicked" | "entity_edited" | "new_entity_click" | "new_entity_saved" | "copy_entity_click" | "entity_copied" | "single_delete_dialog_open" | "multiple_delete_dialog_open" | "single_entity_deleted" | "multiple_entities_deleted" | "drawer_navigate_to_home" | "drawer_navigate_to_collection" | "drawer_navigate_to_view" | "home_navigate_to_collection" | "home_favorite_navigate_to_collection" | "home_navigate_to_view" | "home_navigate_to_admin_view" | "home_favorite_navigate_to_view" | "home_move_card" | "home_move_group" | "home_drop_new_group" | "collection_inline_editing" | "view_mode_changed" | "kanban_card_moved" | "kanban_column_reorder" | "kanban_property_changed" | "kanban_new_entity_in_column" | "kanban_backfill_order" | "card_view_entity_click" | "unmapped_event";

package/dist/types/src/controllers/auth.d.ts

@@ -0,0 +1,119 @@
+import { StorageSource } from "./storage";
+import { Role, User } from "../users";
+import { RebaseData } from "./data";
+/**
+ * Capabilities advertised by an auth provider.
+ * UI components use this to show/hide features dynamically
+ * (e.g. password reset, registration, session management).
+ * @group Hooks and utilities
+ */
+export interface AuthCapabilities {
+    emailPasswordLogin?: boolean;
+    googleLogin?: boolean;
+    registration?: boolean;
+    passwordReset?: boolean;
+    sessionManagement?: boolean;
+    profileUpdate?: boolean;
+    emailVerification?: boolean;
+    /** List of enabled OAuth provider IDs (e.g. ["google", "github", "discord"]) */
+    enabledProviders?: string[];
+}
+/**
+ * Controller for retrieving the logged user or performing auth related operations.
+ * Note that if you are implementing your AuthController, you probably will want
+ * to do it as the result of a hook.
+ * @group Hooks and utilities
+ */
+export type AuthController<USER extends User = User, ExtraData = unknown> = {
+    /**
+     * The user currently logged in
+     * The values can be: the user object, null if they skipped login
+     */
+    user: USER | null;
+    /**
+     * Initial loading flag. It is used not to display the login screen
+     * when the app first loads, and it has not been checked whether the user
+     * is logged in or not.
+     */
+    initialLoading?: boolean;
+    /**
+     * Loading flag. It is used to display a loading screen when the user is
+     * logging in or out.
+     */
+    authLoading: boolean;
+    /**
+     * Sign out
+     */
+    signOut: () => Promise<void>;
+    /**
+     * Error initializing the authentication
+     */
+    authError?: unknown;
+    /**
+     * Error dispatched by the auth provider
+     */
+    authProviderError?: unknown;
+    /**
+     * You can use this method to retrieve the auth token for the current user.
+     */
+    getAuthToken: () => Promise<string>;
+    /**
+     * Has the user skipped the login process
+     */
+    loginSkipped: boolean;
+    extra: ExtraData;
+    setExtra: (extra: ExtraData) => void;
+    setUser?(user: USER | null): void;
+    setUserRoles?(roles: Role[]): void;
+    /**
+     * Capabilities advertised by the auth provider.
+     * UI components use this to feature-detect what the backend supports.
+     */
+    capabilities?: AuthCapabilities;
+};
+/**
+ * Extended auth controller with common optional auth methods.
+ * Backend implementations (Rebase backend, Firebase, Supabase, etc.)
+ * extend this with their own backend-specific extras.
+ * @group Hooks and utilities
+ */
+export interface AuthControllerExtended<USER extends User = User, ExtraData = unknown> extends AuthController<USER, ExtraData> {
+    /** Login with email and password */
+    emailPasswordLogin?(email: string, password: string): Promise<void>;
+    /** Login with a Google ID token or trigger Google popup */
+    googleLogin?(idToken: string): Promise<void>;
+    /** Register a new user */
+    register?(email: string, password: string, displayName?: string): Promise<void>;
+    /** Skip login (for anonymous access if enabled) */
+    skipLogin?(): void;
+    /** Request password reset email */
+    forgotPassword?(email: string): Promise<void>;
+    /** Reset password using a token */
+    resetPassword?(token: string, password: string): Promise<void>;
+    /** Change password for the authenticated user */
+    changePassword?(oldPassword: string, newPassword: string): Promise<void>;
+    /** Update user profile */
+    updateProfile?(displayName?: string, photoURL?: string): Promise<USER>;
+}
+/**
+ * Implement this function to allow access to specific users.
+ * @group Hooks and utilities
+ */
+export type Authenticator<USER extends User = User> = (props: {
+    /**
+     * Logged-in user or null
+     */
+    user: USER | null;
+    /**
+     * AuthController
+     */
+    authController: AuthController<USER>;
+    /**
+     * Unified data access API
+     */
+    data: RebaseData;
+    /**
+     * Used storage implementation
+     */
+    storageSource: StorageSource;
+}) => boolean | Promise<boolean>;