@supabase/lite 0.9.1-next.1 → 0.9.1-next.2

package/dist/vite/index.d.ts

@@ -2,13 +2,13 @@ import { Connect, Plugin } from 'vite';
 import * as _supabase_supabase_js from '@supabase/supabase-js';
 import { SupabaseClientOptions } from '@supabase/supabase-js';
 import * as s from 'jsonv-ts';
-import { Connection } from '@supabase/lite';
+import { Connection as Connection$1 } from '@supabase/lite';
 import * as hono_hono_base from 'hono/hono-base';
 import * as hono_utils_http_status from 'hono/utils/http-status';
 import * as hono_utils_types from 'hono/utils/types';
 import * as hono_types from 'hono/types';
 import { Context, MiddlewareHandler } from 'hono';
-import { Kysely } from 'kysely';
+import { Kysely, KyselyConfig } from 'kysely';
 import { ReadableStream as ReadableStream$1 } from 'node:stream/web';
 
 declare module "jsonv-ts" {
@@ -1331,7 +1331,7 @@ interface StorageAdapter<Options extends StorageAdapterOptions = StorageAdapterO
     uploadObject(bucketName: string, key: string, version: string | undefined, body: CrossReadableStream | Buffer | Uint8Array, contentType: string, cacheControl: string): Promise<ObjectMetadata>;
     deleteObject(bucket: string, key: string, version: string | undefined): Promise<void>;
     deleteObjects(bucket: string, prefixes: string[]): Promise<void>;
-    copyObject(bucket: string, source: string, version: string | undefined, destination: string, destinationVersion: string | undefined): Promise<Pick<ObjectMetadata, "httpStatusCode" | "eTag" | "lastModified">>;
+    copyObject(sourceBucket: string, source: string, version: string | undefined, destinationBucket: string, destination: string, destinationVersion: string | undefined): Promise<Pick<ObjectMetadata, "httpStatusCode" | "eTag" | "lastModified">>;
     headObject(bucket: string, key: string, version: string | undefined): Promise<ObjectMetadata>;
     privateAssetUrl(bucket: string, key: string, version: string | undefined): Promise<string>;
 }
@@ -1371,7 +1371,534 @@ interface TransformationAdapter<Options extends TransformationAdapterOptions = T
     transformFromUrl?(url: string, options: TransformOptions): Promise<TransformResult>;
 }
 
-type Dialect = "postgres" | "sqlite";
+interface TableInfo {
+    name: string;
+    sql: string;
+    schema: string;
+    type: "table" | "view";
+    rows: number;
+    engine: string;
+    collation: string;
+}
+interface ColumnInfo {
+    table: string;
+    name: string;
+    type: string;
+    nullable: boolean;
+    default_value: string | null;
+    is_primary_key: boolean;
+    schema: string;
+    ordinal_position: number;
+    collation: string;
+    character_maximum_length: string | null;
+    precision: {
+        precision: number | null;
+        scale: number | null;
+    } | null;
+    is_identity: boolean;
+    pg_type?: string;
+    /**
+     * Schema of the column's data type (information_schema `udt_schema`). For a
+     * composite/enum/domain typed column this is the schema the *type* lives in,
+     * which can differ from the table's `schema` — used to resolve the type
+     * against `custom_types` without cross-schema false matches. Postgres only.
+     */
+    udt_schema?: string;
+    is_generated?: boolean;
+}
+interface IndexInfo {
+    table: string;
+    name: string;
+    unique: boolean;
+    columns: string[];
+    schema: string;
+    sql?: string;
+}
+interface ForeignKeyInfo {
+    table: string;
+    column: string;
+    ref_table: string;
+    ref_column: string;
+    on_update: string;
+    on_delete: string;
+    schema: string;
+    ref_schema?: string;
+    foreign_key_name: string;
+    /** Internal grouping key for derived FK paths that share a display constraint name. */
+    foreign_key_group?: string;
+    fk_def: string;
+    is_visible?: boolean;
+}
+interface PrimaryKeyInfo {
+    table: string;
+    columns: string[];
+    schema: string;
+    field_count: number;
+}
+interface ViewInfo {
+    name: string;
+    sql: string;
+    schema: string;
+}
+interface CheckConstraintInfo {
+    schema: string;
+    table: string;
+    expression: string;
+    name?: string;
+    column?: string;
+}
+interface UniqueConstraintInfo {
+    schema: string;
+    table: string;
+    name: string;
+    columns: string[];
+}
+interface CommentInfo {
+    schema: string;
+    table: string;
+    column?: string;
+    text: string;
+}
+interface TriggerInfo {
+    table: string;
+    name: string;
+    sql: string;
+    schema: string;
+}
+interface CustomTypesInfo {
+    schema: string;
+    type: string;
+    kind: "enum" | "composite";
+    values?: string[];
+    fields?: {
+        name: string;
+        type: string;
+    }[];
+}
+interface FunctionInfo {
+    schema: string;
+    name: string;
+    /** Input parameter names, in declaration order. Empty for unnamed-param functions. */
+    arg_names: string[];
+    /** Input parameter type names (format_type), aligned with proargtypes order. */
+    arg_types: string[];
+    /** Count of trailing input params that have a DEFAULT (pronargdefaults). */
+    arg_defaults: number;
+    /** True when the function has a VARIADIC parameter. */
+    has_variadic: boolean;
+    /** provolatile: 'i' immutable, 's' stable, 'v' volatile. */
+    volatility: string;
+    /** Formatted return type (e.g. "integer", "SETOF" is conveyed via return_is_setof). */
+    return_type: string;
+    /** proretset — function returns a set (SETOF / TABLE). */
+    return_is_setof: boolean;
+    /**
+     * prorows — planner row-count estimate. A SETOF function declared `ROWS 1`
+     * has prorows === 1, which PostgREST reads as a to-one computed relationship.
+     * SETOF without ROWS defaults to 1000; non-set functions to 0.
+     */
+    return_rows?: number;
+    /**
+     * pg_type.typtype of the return type: 'b' base, 'c' composite, 'd' domain,
+     * 'e' enum, 'p' pseudo (record/void), 'r' range, 'm' multirange. 'c'/'p'
+     * indicate a row/record (object) result rather than a scalar.
+     */
+    return_typtype: string;
+    /**
+     * When the return type is a domain ('d'), the formatted name of its underlying
+     * base type (pg_type.typbasetype via format_type) — e.g. a `"text/plain"`
+     * domain over `text` carries `return_base_type: "text"`. Empty/undefined for
+     * non-domain returns. Used to decode a media-type-domain RPC result as raw
+     * text vs raw bytea. See server/data/response/media-domain.ts.
+     */
+    return_base_type?: string;
+    /** True when the function has OUT/INOUT/TABLE output columns (object-shaped result). */
+    has_out_args: boolean;
+}
+type IntrospectOptions = {
+    exclude_tables?: string[];
+    name?: string;
+    version?: string;
+};
+interface IntrospectResult {
+    tables: TableInfo[];
+    columns: ColumnInfo[];
+    indexes: IndexInfo[];
+    foreign_keys: ForeignKeyInfo[];
+    primary_keys: PrimaryKeyInfo[];
+    views: ViewInfo[];
+    check_constraints: CheckConstraintInfo[];
+    unique_constraints: UniqueConstraintInfo[];
+    comments: CommentInfo[];
+    custom_types: CustomTypesInfo[];
+    triggers: TriggerInfo[];
+    /** Stored functions/procedures. Populated on the Postgres dialects only. */
+    functions?: FunctionInfo[];
+    /**
+     * Individual table partitions and their partitioned parent. Populated on the
+     * Postgres dialects only. Partitions are hidden from `tables`/`foreign_keys`
+     * (like PostgREST), so this carries the partition→parent mapping used to emit
+     * the "Perhaps you meant '<parent>'" hint when a partition is requested.
+     */
+    partitions?: {
+        name: string;
+        schema: string;
+        parent: string;
+    }[];
+    database_name: string;
+    version: string;
+    ddl_dialect?: "postgres" | "sqlite";
+    schema_separator?: string;
+    /**
+     * The API's configured default schema (PostgREST `db-schemas` head). Used to
+     * resolve schema-sensitive catalog lookups (e.g. computed relationships/
+     * columns) for requests that omit `Accept-/Content-Profile`, where the
+     * deparser's `currentSchema` is undefined but the DB still reads this schema.
+     */
+    default_schema?: string;
+    /**
+     * Valid time-zone names from `pg_timezone_names`. Populated on the Postgres
+     * dialects only and cached with the rest of the introspection. Mirrors
+     * PostgREST's cached `TimezoneNames`: a `Prefer: timezone=` value with
+     * `handling=strict` is rejected (PGRST122) unless it is a member. Absent on
+     * sqlite (no such catalog), where the preference stays lenient. Stored as an
+     * array (not a Set) so it survives the JSON schema-cache round-trip.
+     */
+    timezones?: readonly string[];
+}
+interface TableDiff {
+    type: "added" | "removed" | "modified";
+    name: string;
+    sql?: string;
+}
+interface ColumnDiff {
+    type: "added" | "removed" | "modified";
+    table: string;
+    name: string;
+    changes?: {
+        type?: {
+            from: string;
+            to: string;
+        };
+        nullable?: {
+            from: boolean;
+            to: boolean;
+        };
+        default_value?: {
+            from: string | null;
+            to: string | null;
+        };
+    };
+    column?: ColumnInfo;
+}
+interface IndexDiff {
+    type: "added" | "removed";
+    table: string;
+    name: string;
+    unique: boolean;
+    columns: string[];
+}
+interface ForeignKeyDiff {
+    type: "added" | "removed";
+    table: string;
+    column: string;
+    ref_table: string;
+    ref_column: string;
+    on_update: string;
+    on_delete: string;
+}
+interface DiffResult {
+    tables: TableDiff[];
+    columns: ColumnDiff[];
+    indexes: IndexDiff[];
+    foreign_keys: ForeignKeyDiff[];
+    has_changes: boolean;
+}
+declare const enum PlanStepType {
+    DISABLE_FOREIGN_KEYS = "disable_foreign_keys",
+    ENABLE_FOREIGN_KEYS = "enable_foreign_keys",
+    BEGIN_TRANSACTION = "begin_transaction",
+    COMMIT_TRANSACTION = "commit_transaction",
+    CREATE_TABLE = "create_table",
+    ADD_COLUMN = "add_column",
+    DROP_COLUMN = "drop_column",
+    ADD_INDEX = "add_index",
+    DROP_INDEX = "drop_index",
+    DROP_TABLE = "drop_table",
+    RENAME_TABLE = "rename_table",
+    COPY_DATA = "copy_data",
+    CREATE_TRIGGER = "create_trigger"
+}
+interface PlanStep {
+    sql: string;
+    description?: string;
+    type?: PlanStepType;
+    /**
+     * Commit the current transaction and begin a new one before running this
+     * step. Set where the planner requires a commit boundary — a statement whose
+     * effect is unusable until its transaction commits, e.g. `ALTER TYPE … ADD
+     * VALUE` followed by anything that uses the new value.
+     *
+     * Execution metadata lives on the step (rather than alongside the plan) so it
+     * survives cloning and JSON round-trips of a `PlanResult`.
+     */
+    newTransaction?: boolean;
+    /** Run this step outside a transaction entirely (e.g. `CREATE INDEX CONCURRENTLY`). */
+    nonTransactional?: boolean;
+}
+interface DataLossWarning {
+    table: string;
+    reason: string;
+}
+interface PlanResult {
+    steps: PlanStep[];
+    warnings?: DataLossWarning[];
+    unsafe: boolean;
+}
+interface SchemaDiffResult {
+    current?: IntrospectResult;
+    desired?: IntrospectResult;
+    diff: DiffResult | string;
+    plan: PlanResult;
+}
+/**
+ * Restricts a diff/migrate to a set of schemas (LITE-291). When set, both the
+ * current and desired catalogs are filtered to these schemas, so out-of-scope
+ * (e.g. user-land `public`) objects are invisible to the diff and are never
+ * dropped. Used by `App.ensureSystemSchema()` to reconcile only system schemas.
+ */
+interface MigrateScope {
+    schemas?: string[];
+}
+interface ConnectionMigrator {
+    diff(scope?: MigrateScope): Promise<SchemaDiffResult>;
+    migrate(opts?: {
+        force?: boolean;
+    } & MigrateScope): Promise<SchemaDiffResult>;
+    migratePlan(planResult: PlanResult, opts?: {
+        force?: boolean;
+    }): Promise<void>;
+    safeSortPlanSteps(steps: PlanStep[]): PlanStep[];
+}
+
+/**
+ * Nested object for runtime variable substitution.
+ * Paths are resolved via lodash-style dot-path access (e.g. "auth.jwt.role" → vars.auth.jwt.role).
+ * e.g. { auth: { uid: "uuid-here", role: "authenticated", jwt: { role: "admin" } } }
+ */
+type VarsContext = Record<string, unknown>;
+
+type ColumnDef = {
+    column?: string;
+    cast?: string;
+    preCast?: string;
+    aggregate?: AggregateFunction;
+    bareCount?: boolean;
+    path?: string;
+    /** True when the trailing JSON-path operator was `->>` (text extract). */
+    pathText?: boolean;
+    /** First key reached after an earlier `->>` text extraction. */
+    invalidJsonTextTraversalKey?: string;
+};
+type EmbedDef = {
+    select?: SelectEntry[];
+    where?: Where;
+    order?: OrderEntry[];
+    limit?: number;
+    offset?: number;
+    spread?: boolean;
+    join?: JoinMap;
+};
+type SelectEntry = string | Record<string, ColumnDef | EmbedDef>;
+type JoinDef = {
+    from?: string;
+    type?: "inner" | "left";
+    hint?: string;
+    on?: Where;
+};
+type JoinMap = Record<string, JoinDef>;
+type Where = Record<string, unknown>;
+type OrderEntry = {
+    column: string;
+    direction?: "asc" | "desc";
+    nullsFirst?: boolean;
+    /** For ordering by embedded resource column: embed alias */
+    embed?: string;
+};
+type ExplainOptions = {
+    analyze?: boolean;
+    verbose?: boolean;
+    settings?: boolean;
+    buffers?: boolean;
+    wal?: boolean;
+};
+type Meta = {
+    cardinality?: "one" | "maybe" | "many";
+    count?: "exact" | "planned" | "estimated";
+    head?: boolean;
+    maxAffected?: number;
+    rollback?: boolean;
+    missing?: "null" | "default";
+    handling?: "strict" | "lenient";
+    timezone?: string;
+    columns?: string[];
+    stripNulls?: boolean;
+    explain?: ExplainOptions;
+    headers?: Record<string, string>;
+    return?: "minimal" | "headers-only" | "representation";
+    tx?: "commit" | "rollback";
+};
+type AnyAST = {
+    type?: string;
+    from?: string;
+    function?: string;
+    schema?: string;
+    join?: JoinMap;
+    select?: SelectEntry[];
+    where?: Where;
+    values?: object | object[];
+    args?: object | unknown[];
+    order?: OrderEntry[];
+    limit?: number;
+    offset?: number;
+    group?: string[];
+    onConflict?: string[];
+    ignoreDuplicates?: boolean;
+    httpMethod?: "GET" | "POST";
+    paramsType?: "named" | "positional";
+    inputType?: "json" | "text" | "binary" | "xml";
+    $meta?: Meta;
+};
+type AggregateFunction = "count" | "sum" | "avg" | "min" | "max";
+
+interface IConnectionConfig extends Partial<KyselyConfig> {
+    url?: string;
+    introspection?: IntrospectOptions;
+    schemaCache?: CacheDriver;
+    /**
+     * Base schema of the connection that is always prepended to any schema operations.
+     * E.g. when migrating to a desired schema, `baseSchema` is always prepended.
+     * This is useful for when auth is enabled, and auth schema must be present.
+     */
+    baseSchema?: string;
+    /** System-owned tables whose own schema enables RLS. */
+    systemRls?: Array<{
+        schema: string;
+        tables: string[];
+    }>;
+}
+type Dialect = "sqlite" | "postgres";
+type TransactionOptions = {
+    intent?: "migration";
+};
+type ConnectionContextOptions = {
+    forceRollback?: boolean;
+    /** Reuse an existing transaction so trusted preflights and scoped writes stay atomic. */
+    transaction?: Kysely<any>;
+    /**
+     * Present for RPC (`/rpc/*`) requests on the postgres backend only. Forces the
+     * call into one explicit transaction so request.* GUC injection, GET read-only
+     * mode, and the function's transaction-local response.* GUCs (read back by the
+     * handler) are atomic. Without it, the common anon path runs with no
+     * transaction and `set_config(...,true)` would be lost before the read-back.
+     * Ignored by the base/sqlite pass-through `withContext` (RPC is rejected on
+     * sqlite at server/data.ts, so sqlite never constructs this).
+     */
+    rpc?: {
+        method: string;
+        path: string;
+        readOnly: boolean;
+        requestHeaders?: Record<string, string>;
+    };
+};
+declare abstract class Connection<Driver = unknown, DB = any, Config extends IConnectionConfig = IConnectionConfig> {
+    config: Config;
+    kysely: Kysely<DB>;
+    abstract driver: Driver;
+    abstract dialect: Dialect;
+    protected introspection: IntrospectResult | undefined;
+    protected constructor(config: Config);
+    /**
+     * Connection-level DDL translation, mainly for SQLite connections to override.
+     */
+    translateDdl(ddl: string): Promise<unknown>;
+    clearSchemaCache(): Promise<void>;
+    protected readCachedIntrospection(options?: {
+        useCache?: boolean;
+    }): Promise<IntrospectResult | undefined>;
+    protected writeCachedIntrospection(result: IntrospectResult, options?: {
+        useDriver?: boolean;
+    }): Promise<void>;
+    protected deleteCachedIntrospection(): Promise<void>;
+    protected schemaCacheKey(): string;
+    exec<T = {
+        rows: unknown[];
+    } | void>(query: string, ...parameters: readonly unknown[]): Promise<T>;
+    ping(): Promise<boolean | void>;
+    abstract introspect(options?: {
+        useCache?: boolean;
+    }): Promise<IntrospectResult>;
+    transaction(_statements: string[], _opts?: TransactionOptions): Promise<void>;
+    /**
+     * Callback-based transaction API for application code (e.g. AuthRepository)
+     * that needs atomicity across several kysely operations without hand-rolling
+     * BEGIN/COMMIT/ROLLBACK. `fn` is handed a kysely instance bound to the
+     * transaction — use it (not `this.kysely`) for every operation that must
+     * participate.
+     *
+     * Default implementation issues a real BEGIN/COMMIT/ROLLBACK via kysely's
+     * `transaction().execute()`, appropriate for backends where `sql\`BEGIN\``
+     * is meaningful (base sqlite drivers, Postgres). Durable Objects storage
+     * has no such thing — `DoSqliteConnection` overrides this to use
+     * `storage.transaction()` instead, running `fn` against the *same* kysely
+     * instance (see that class for why).
+     */
+    runInTransaction<T>(fn: (trx: Kysely<DB>) => Promise<T>): Promise<T>;
+    abstract close(): Promise<void>;
+    createMigrator(_desiredSchema: string): ConnectionMigrator;
+    onPostgrestAST(ast: AnyAST, _vars?: VarsContext): Promise<AnyAST>;
+    /**
+     * Per-row response coercion run after schema-typed deserialization.
+     * Subclasses fix wire-protocol-shape quirks (e.g. JSON-as-text on
+     * Postgres `json_agg`, numeric-as-string from postgres.js). Default = no-op.
+     */
+    deserializeRow(row: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Normalize a database error into a PG-style error object.
+     * Override in subclasses to map dialect-specific error codes.
+     */
+    normalizeDbError(e: unknown): unknown;
+    /**
+     * Wrap PostgREST query execution with connection-specific context.
+     * For Postgres: wraps in a transaction with SET LOCAL role/claims.
+     * Default: pass-through.
+     */
+    withContext<T>(_vars: VarsContext | undefined, fn: (db: Kysely<any>) => Promise<T>, opts?: ConnectionContextOptions): Promise<T>;
+    /**
+     * Whether this connection serves RPC (stored functions). SQLite-backed
+     * connections have none; the data route uses this to gate `/rpc/*`.
+     */
+    get supportsRpc(): boolean;
+    /**
+     * OPTIONS write-capability for a view, resolved from the catalog. Returns
+     * `null` when the dialect cannot introspect view updatability via SQL (e.g.
+     * SQLite, where the caller derives it from `INSTEAD OF` triggers instead).
+     * Overridden on the Postgres path.
+     */
+    viewOptionsMetadata(_viewName: string, _viewSchema: string): Promise<ViewOptionsMetadata | null>;
+}
+/** Catalog metadata for a view used to build an OPTIONS `Allow` header. */
+interface ViewOptionsMetadata {
+    canInsert: boolean;
+    canUpdate: boolean;
+    canDelete: boolean;
+    /** Base relations the view reads from, for scoping the PK check. */
+    baseTables: Array<{
+        schema: string;
+        name: string;
+    }>;
+}
+
 interface Bucket {
     id: string;
     name: string;
@@ -1407,10 +1934,10 @@ interface ListObjectsOptions {
     search?: string;
 }
 declare class StorageRepository {
+    private schema;
     private db;
     private dialect;
-    private schema;
-    constructor(db: Kysely<any>, dialect: Dialect);
+    constructor(connection: Connection);
     private table;
     private insertInto;
     private update;
@@ -1440,20 +1967,22 @@ declare class StorageRepository {
         name: string;
         owner?: string | null;
         owner_id?: string | null;
-        metadata?: Record<string, unknown>;
-        user_metadata?: Record<string, unknown>;
+        metadata?: Record<string, unknown> | null;
+        user_metadata?: Record<string, unknown> | null;
         version?: string | null;
     }): Promise<StorageObject>;
     findObjectById(id: string): Promise<StorageObject | null>;
     findObjectByPath(bucketId: string, name: string): Promise<StorageObject | null>;
     listObjects(bucketId: string, prefix?: string, options?: ListObjectsOptions): Promise<StorageObject[]>;
     updateObject(id: string, updates: Partial<{
+        bucket_id: string;
         name: string;
-        metadata: Record<string, unknown>;
-        user_metadata: Record<string, unknown>;
+        metadata: Record<string, unknown> | null;
+        user_metadata: Record<string, unknown> | null;
         version: string | null;
         owner: string | null;
         owner_id: string | null;
+        updated_at: string;
     }>): Promise<StorageObject | null>;
     deleteObject(id: string): Promise<void>;
     deleteObjectsByBucket(bucketId: string): Promise<string[]>;
@@ -1463,6 +1992,13 @@ declare class StorageRepository {
     private parseObjectRow;
 }
 
+type StorageRole = string;
+interface StorageRequestAuth {
+    role: StorageRole;
+    sub: string | null;
+    jwt: Record<string, unknown> | null;
+}
+
 interface StorageServiceConfig {
     jwtSecret: string;
     fileSizeLimit?: number;
@@ -1481,8 +2017,12 @@ declare class StorageService {
     private config;
     private options;
     private transformationAdapter?;
+    private connection?;
     private initialized;
-    constructor(repo: StorageRepository, adapter: StorageAdapter, config: StorageServiceConfig, options?: StorageServiceOptions, transformationAdapter?: TransformationAdapter | undefined);
+    private access;
+    constructor(repo: StorageRepository, adapter: StorageAdapter, config: StorageServiceConfig, options?: StorageServiceOptions, transformationAdapter?: TransformationAdapter | undefined, connection?: Connection | undefined);
+    setRequestAuth(auth: StorageRequestAuth, operation?: string): void;
+    get requestAuth(): StorageRequestAuth;
     init(): Promise<void>;
     createBucket(params: {
         id: string;
@@ -1493,6 +2033,7 @@ declare class StorageService {
         owner?: string | null;
     }): Promise<Bucket>;
     getBucket(id: string): Promise<Bucket>;
+    getBucketBypass(id: string): Promise<Bucket>;
     listBuckets(): Promise<Bucket[]>;
     updateBucket(id: string, updates: {
         public?: boolean;
@@ -1507,32 +2048,34 @@ declare class StorageService {
         contentLength?: number;
         upsert?: boolean;
         metadata?: Record<string, unknown>;
-        owner?: string | null;
     }): Promise<StorageObject>;
+    private uploadInternal;
     download(bucketId: string, path: string, options?: {
         transform?: TransformOptions;
     }): Promise<{
         body: CrossReadableStream | Blob | Buffer | Uint8Array;
         metadata: ObjectMetadata;
     }>;
+    private downloadBypass;
+    private downloadObject;
     update(bucketId: string, path: string, body: ReadableStream | Buffer | Uint8Array, options?: {
         contentType?: string;
         cacheControl?: string;
         contentLength?: number;
         metadata?: Record<string, unknown>;
         upsert?: boolean;
-        owner?: string | null;
     }): Promise<StorageObject>;
     remove(bucketId: string, paths: string[]): Promise<StorageObject[]>;
     list(bucketId: string, prefix?: string, options?: ListObjectsOptions): Promise<StorageObject[]>;
-    move(bucketId: string, fromPath: string, toPath: string): Promise<void>;
-    copy(bucketId: string, fromPath: string, toPath: string): Promise<{
+    move(bucketId: string, fromPath: string, toPath: string, destinationBucketId?: string): Promise<void>;
+    copy(bucketId: string, fromPath: string, toPath: string, destinationBucketId?: string, upsert?: boolean): Promise<{
         key: string;
     }>;
     info(bucketId: string, path: string): Promise<StorageObject & {
         httpMetadata: ObjectMetadata;
     }>;
     exists(bucketId: string, path: string): Promise<boolean>;
+    private assertBucketRetrievable;
     createSignedUrl(bucketId: string, path: string, expiresIn: number): Promise<{
         signedUrl: string;
     }>;
@@ -1541,7 +2084,10 @@ declare class StorageService {
         signedUrl: string;
         error: string | null;
     }[]>;
-    createSignedUploadUrl(bucketId: string, path: string): Promise<{
+    createSignedUploadUrl(bucketId: string, path: string, upsert?: boolean, options?: {
+        metadata?: Record<string, unknown>;
+        userMetadata?: Record<string, unknown>;
+    }): Promise<{
         signedUrl: string;
         token: string;
         path: string;
@@ -1550,11 +2096,34 @@ declare class StorageService {
         bucket: string;
         path: string;
         intent: "download" | "upload";
+        owner: string | null;
+        upsert: boolean;
     }>;
+    downloadSigned(bucketId: string, path: string, options?: {
+        transform?: TransformOptions;
+    }): Promise<{
+        body: CrossReadableStream | Blob | Buffer | Uint8Array;
+        metadata: ObjectMetadata;
+    }>;
+    uploadSigned(bucketId: string, path: string, body: ReadableStream | Buffer | Uint8Array, options: {
+        contentType?: string;
+        cacheControl?: string;
+        contentLength?: number;
+        upsert?: boolean;
+        metadata?: Record<string, unknown>;
+        owner: string | null;
+    }): Promise<StorageObject>;
     private signStorageToken;
+    private uploadPermissionValues;
+    private databaseErrorCode;
 }
 
+/** Trusted socket metadata supplied by an adapter that owns the listener. */
+type AppRequestContext = {
+    peerAddress: string | null;
+};
 type HonoContext = {
+    Bindings: AppRequestContext;
     Variables: {
         app: App;
         authService: AuthService;
@@ -2405,6 +2974,7 @@ declare function createServer(app: App, options?: ServerOptions): hono_hono_base
             input: {
                 json: {
                     [x: string]: unknown;
+                    destinationBucket?: string | undefined;
                     bucketId: string;
                     sourceKey: string;
                     destinationKey: string;
@@ -2423,6 +2993,7 @@ declare function createServer(app: App, options?: ServerOptions): hono_hono_base
             input: {
                 json: {
                     [x: string]: unknown;
+                    destinationBucket?: string | undefined;
                     bucketId: string;
                     sourceKey: string;
                     destinationKey: string;
@@ -2723,6 +3294,7 @@ declare function createServer(app: App, options?: ServerOptions): hono_hono_base
                     unique: boolean;
                     columns: string[];
                     schema: string;
+                    sql?: string | undefined;
                 }[];
                 foreign_keys: {
                     table: string;
@@ -2817,8 +3389,6 @@ declare function createServer(app: App, options?: ServerOptions): hono_hono_base
     };
 }, "/_system">, "/", "*">;
 
-type Where = Record<string, unknown>;
-
 type PolicyCommand = "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "ALL";
 type PolicyRole = "anon" | "authenticated" | string;
 interface PolicyData {
@@ -2841,7 +3411,7 @@ declare class Policy {
 }
 
 interface IAppConfig extends DefaultSchema {
-    connection: Connection | Promise<Connection>;
+    connection: Connection$1 | Promise<Connection$1>;
     rls?: {
         tables: string[];
         policies: Policy[];
@@ -2866,7 +3436,7 @@ interface SystemOptions {
     schemaReconciliation?: "additive" | "full";
 }
 interface DefaultAppConfig extends IAppConfig {
-    connection: Connection;
+    connection: Connection$1;
     options?: {
         defaults?: true;
         server?: ServerOptions;
@@ -2874,7 +3444,7 @@ interface DefaultAppConfig extends IAppConfig {
         system?: SystemOptions;
     };
 }
-declare class App<Config extends IAppConfig = DefaultAppConfig, Conn = Config extends IAppConfig ? Config["connection"] extends Connection ? Config["connection"] : Config["connection"] extends Promise<Connection> ? Awaited<Config["connection"]> : Connection : never> {
+declare class App<Config extends IAppConfig = DefaultAppConfig, Conn = Config extends IAppConfig ? Config["connection"] extends Connection$1 ? Config["connection"] : Config["connection"] extends Promise<Connection$1> ? Awaited<Config["connection"]> : Connection$1 : never> {
     #private;
     private readonly _connection;
     private readonly _rls;
@@ -2909,6 +3479,7 @@ declare class App<Config extends IAppConfig = DefaultAppConfig, Conn = Config ex
     ensureSystemSchema(opts?: {
         force?: boolean;
     }): Promise<void>;
+    hasEnabledSystemBaseSchema(): boolean;
     isValidConfig(config: Schema | DefaultSchema | IAppConfig): boolean;
     getClient<SchemaName extends string = "public">(options?: SupabaseClientOptions<SchemaName> & {
         apikey?: string;
@@ -2959,7 +3530,7 @@ declare class App<Config extends IAppConfig = DefaultAppConfig, Conn = Config ex
         }>;
     } ? Omit<any, "__InternalSupabase">[SchemaName] : never, any>;
     isLocalRequest(request: Request): boolean;
-    fetch: (request: Request) => Promise<Response>;
+    fetch: (request: Request, context?: AppRequestContext) => Promise<Response>;
     getInfoJson(): {
         connection: object;
         config: Config;
@@ -2977,14 +3548,15 @@ type SupaliteOptions = {
     initOnBoot?: boolean;
     prefixes?: string[];
     /**
-     * Local admin mode (default `true`): keyless, same-origin, loopback
-     * requests from the dev server run as `service_role`. In practice that
-     * means `/rest/v1` here — admin mode also covers `/storage/v1`, but this
-     * plugin does not mount that prefix unless you add it to `prefixes`.
+     * Local admin mode: defaults on for loopback Vite dev hosts and off for
+     * exposed hosts. Keyless, same-origin, loopback requests run as
+     * `service_role`. In practice that means `/rest/v1` here — admin mode also
+     * covers `/storage/v1`, but this plugin does not mount that prefix unless
+     * you add it to `prefixes`.
      *
-     * See `ServerOptions.admin` for the caveats. Never applied in
-     * `vite preview`, which serves a production build; an explicit value here
-     * also outranks `options.server.admin` in `config.toml`.
+     * See `ServerOptions.admin` for the caveats. An explicit value here
+     * outranks `options.server.admin`; explicit `true` is required to enable
+     * admin on an exposed host. Never applied in `vite preview`.
      */
     admin?: boolean;
 };