better-supabase 0.7.1 → 0.9.0

package/dist/block-hooks-plbZ0AbJ.d.ts

@@ -1,107 +0,0 @@
-import { b as DbError, f as Result, t as AsyncResult, w as ErrorMapper } from "./result-D7y2fT87.js";
-import { t as BlockTransport } from "./block-transport-DvaoPuZ9.js";
-import { n as Logger } from "./logger-DWVYUmwi.js";
-import { t as BlockCall } from "./block-helpers-CKtbFcRv.js";
-//#region src/core/block-hooks.d.ts
-/** A block method: anything that returns an `AsyncResult`. */
-type BlockMethod = (...args: never[]) => AsyncResult<unknown>;
-/** The names of a block client's methods that return an `AsyncResult`. */
-type BlockMethodName<C> = { [K in keyof C]: C[K] extends BlockMethod ? K : never; }[keyof C] & string;
-type ArgsOf<F> = F extends ((...args: infer A) => AsyncResult<unknown>) ? A : never;
-type DataOf<F> = F extends ((...args: never[]) => AsyncResult<infer T>) ? T : never;
-/** Which call a hook runs for. */
-interface BlockHookInfo {
-  /** The block, as `createBlocks` names it, or the name `withBlockHooks` got. */
-  readonly block: string;
-  readonly method: string;
-}
-/**
- * Hooks for one block method. `before` runs first: return nothing to keep
- * the arguments, a new argument list to replace them, or a `DbError` to
- * refuse the call, which then returns that error without reaching the
- * database. `after` observes a copy of the result and can't change it; when
- * it throws, the logger gets the error and the caller still gets the result.
- */
-interface BlockMethodHooks<A extends readonly unknown[], T> {
-  readonly before?: (args: A, info: BlockHookInfo) => Readonly<A> | DbError | void | Promise<Readonly<A> | DbError | void>;
-  readonly after?: (result: Result<T>, args: A, info: BlockHookInfo) => void | Promise<void>;
-}
-/** Hooks keyed by the block client's method names. */
-type BlockHooks<C> = { readonly [K in BlockMethodName<C>]?: BlockMethodHooks<ArgsOf<C[K]>, DataOf<C[K]>>; };
-interface WithBlockHooksOptions {
-  /** The block's name in `BlockHookInfo` and log messages. Default `block`. */
-  readonly block?: string;
-  /** Receives the errors `after` hooks throw. Default: `console`. */
-  readonly logger?: Logger;
-}
-/**
- * Runs `hooks` around a block client's methods. Use it to add a rule the
- * block doesn't know (refuse `invite` above a seat limit), rewrite arguments
- * (fill a default), or observe results (metrics, an audit line). Methods
- * without hooks are unchanged.
- *
- * ```ts
- * const orgs = withBlockHooks(createOrganizations(options), {
- *   invite: { before: ([input]) => (input.role === "owner" ? dbError("forbidden", "Owners are added by support") : undefined) },
- * });
- * ```
- */
-declare function withBlockHooks<C extends object>(client: C, hooks: BlockHooks<C> | undefined, options?: WithBlockHooksOptions): C;
-/** What `extendBlock` hands the builder besides the base client. */
-interface ExtendBlockTools {
-  /**
-   * Calls a SQL function in the block's schema over its transport and maps a
-   * rejection to a `DbError`, as the block's own methods do. Needs the
-   * `transport` option.
-   */
-  readonly call: BlockCall;
-}
-interface ExtendBlockOptions {
-  /** The transport `call` uses: the one the block was created with. */
-  readonly transport?: BlockTransport;
-  /** The schema `call` targets. Default `better_supabase`. */
-  readonly schema?: string;
-  /** Error mappers `call` runs before the built-in ones. */
-  readonly mappers?: readonly ErrorMapper[];
-}
-/**
- * Adds methods to a block client. The builder gets the base client, so a
- * new method can compose existing ones, and `call` for SQL functions the
- * app adds to the block's schema. Redefining a base method throws: wrap it
- * with `withBlockHooks` instead.
- *
- * ```ts
- * const orgs = extendBlock(createOrganizations(options), (base, { call }) => ({
- *   archive: (id: string) => call("archive_organization", { id }, () => undefined),
- * }), { transport: options.transport });
- * ```
- */
-declare function extendBlock<C extends object, X extends object>(client: C, build: (base: C, tools: ExtendBlockTools) => X, options?: ExtendBlockOptions): C & X;
-/** One transport call, as middleware sees it. */
-interface BlockTransportRequest {
-  readonly schema: string;
-  readonly fn: string;
-  readonly args: Readonly<Record<string, unknown>>;
-}
-/**
- * Runs around every call a transport makes: tracing, a statement timeout,
- * an extra argument every function takes. Pass a changed request to `next`
- * to rewrite it. Reject with the error `next` rejected with so the block
- * still maps it to a `DbError`.
- */
-interface BlockTransportMiddleware {
-  readonly apiVersion: 1;
-  readonly name: string;
-  call(request: BlockTransportRequest, next: (request: BlockTransportRequest) => Promise<unknown>): Promise<unknown>;
-}
-/** Fills in `apiVersion: 1`. */
-declare function defineTransportMiddleware(middleware: Omit<BlockTransportMiddleware, "apiVersion"> & {
-  readonly apiVersion?: 1;
-}): BlockTransportMiddleware;
-/**
- * A transport that runs `middleware` around `transport`, the first one
- * outermost. Throws when a middleware targets an API other than 1.
- */
-declare function wrapTransport(transport: BlockTransport, ...middleware: readonly BlockTransportMiddleware[]): BlockTransport;
-//#endregion
-export { BlockTransportMiddleware as a, ExtendBlockTools as c, extendBlock as d, withBlockHooks as f, BlockMethodName as i, WithBlockHooksOptions as l, BlockHooks as n, BlockTransportRequest as o, wrapTransport as p, BlockMethodHooks as r, ExtendBlockOptions as s, BlockHookInfo as t, defineTransportMiddleware as u };

package/dist/block-transport-BLr-ZgLc.js

@@ -1,59 +0,0 @@
-import { r as sqlIdent } from "./template--jDkl3UP.js";
-//#region src/core/block-transport.ts
-/**
-* Calls the functions over Postgres, as the user `client` runs as:
-* `sqlTransport(postgres.asUser(ctx.auth.claims))`. Works for any schema.
-*/
-function sqlTransport(client) {
-	return { async call(schema, fn, args) {
-		const entries = Object.entries(args).filter(([, value]) => value !== void 0);
-		const params = entries.map(([, value]) => value !== null && typeof value === "object" && !Array.isArray(value) ? JSON.stringify(value) : value);
-		const list = entries.map(([name], index) => `${sqlIdent(name)} => $${String(index + 1)}`).join(", ");
-		const [row] = await client.queryRaw(`select ${sqlIdent(schema)}.${sqlIdent(fn)}(${list}) as value`, params);
-		return row?.value ?? null;
-	} };
-}
-/**
-* Calls the functions over the Data API with the user's session. Pass
-* `schema` with the API schema that `sql.modules.<module>.api` writes
-* wrappers into; without it the calls go to the module schema, which then
-* has to be exposed.
-*/
-function rpcTransport(client, options = {}) {
-	const untyped = client;
-	return { async call(schema, fn, args) {
-		const defined = Object.fromEntries(Object.entries(args).filter(([, value]) => value !== void 0));
-		const { data, error } = await untyped.schema(options.schema ?? schema).rpc(fn, defined);
-		if (error) {
-			const message = typeof error === "object" && "message" in error ? String(error.message) : String(error);
-			throw Object.assign(new Error(message), error);
-		}
-		return data;
-	} };
-}
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-/** The Postgres or PostgREST error a transport rejected with, if it is one. */
-function rawError(cause) {
-	if (!isRecord(cause)) return void 0;
-	const field = (key) => {
-		const value = cause[key];
-		return typeof value === "string" ? value : void 0;
-	};
-	if (field("code") === void 0) return void 0;
-	const raw = {};
-	for (const key of [
-		"message",
-		"code",
-		"details",
-		"hint",
-		"constraint"
-	]) {
-		const value = field(key);
-		if (value !== void 0) raw[key] = value;
-	}
-	const detail = field("detail");
-	if (raw["details"] === void 0 && detail !== void 0) raw["details"] = detail;
-	return raw;
-}
-//#endregion
-export { rpcTransport as n, sqlTransport as r, rawError as t };

package/dist/block-transport-DvaoPuZ9.d.ts

@@ -1,48 +0,0 @@
-import { t as SqlClient } from "./executor-DbvExCFC.js";
-//#region src/core/block-transport.d.ts
-/**
- * Calls a block function as the current user and resolves with its result.
- * Rejects with the raw database error (a `pg` error or a PostgREST error
- * object), which the block maps to a `DbError`.
- */
-interface BlockTransport {
-  call(schema: string, fn: string, args: Readonly<Record<string, unknown>>): Promise<unknown>;
-}
-/**
- * Calls the functions over Postgres, as the user `client` runs as:
- * `sqlTransport(postgres.asUser(ctx.auth.claims))`. Works for any schema.
- */
-declare function sqlTransport(client: SqlClient): BlockTransport;
-interface RpcResponse {
-  readonly data: unknown;
-  readonly error: unknown;
-}
-/**
- * The part of a supabase-js client `rpcTransport` uses. The parameters are
- * `never` so a typed `SupabaseClient<Database>` fits too: its `schema` and
- * `rpc` only take the names its `Database` declares, which never include the
- * block functions of a schema the types leave out.
- */
-interface RpcClient {
-  schema(name: never): {
-    rpc(fn: never, args: never): PromiseLike<RpcResponse>;
-  };
-}
-/** Options for `rpcTransport`. */
-interface RpcTransportOptions {
-  /**
-   * The exposed schema that holds the block's entry points, such as `api`
-   * from `sql.modules.<module>.api`. Every call goes there instead of the
-   * module schema, which stays out of `[api] schemas` (doctor BS312).
-   */
-  readonly schema?: string;
-}
-/**
- * Calls the functions over the Data API with the user's session. Pass
- * `schema` with the API schema that `sql.modules.<module>.api` writes
- * wrappers into; without it the calls go to the module schema, which then
- * has to be exposed.
- */
-declare function rpcTransport(client: RpcClient, options?: RpcTransportOptions): BlockTransport;
-//#endregion
-export { sqlTransport as i, RpcClient as n, rpcTransport as r, BlockTransport as t };

package/dist/bucket-Cl46E3jS.d.ts

@@ -1,347 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { b as DbError, f as Result, t as AsyncResult } from "./result-D7y2fT87.js";
-import { G as ObjectVersion, K as VersioningStatus, U as BucketLifecycle, s as BucketPolicyName, t as AccessBucketPolicy } from "./types-6BdhkmZe.js";
-import { m as RequestContext } from "./plugin-FGY8UhYm.js";
-import { n as StoragePath, t as PathIn } from "./path-Cv__-OTj.js";
-import { n as TemplateValues, t as TemplateParams } from "./template-CwO38Do8.js";
-import { SupabaseClient } from "@supabase/supabase-js";
-//#region src/storage/ttl.d.ts
-declare const TTL: {
-  readonly minute: 60;
-  readonly hour: 3600;
-  readonly day: 86_400;
-  readonly week: 604_800;
-};
-type TtlPreset = keyof typeof TTL;
-//#endregion
-//#region src/storage/apply.d.ts
-interface AppliedBucket {
-  /** The bucket did not exist and was created. */
-  readonly created: boolean;
-}
-//#endregion
-//#region src/storage/bucket.d.ts
-type BucketPolicy = BucketPolicyName | AccessBucketPolicy;
-interface BucketConfig<P extends string = string, Id extends string = string> {
-  /** Bucket id, e.g. `customer-logos`. */
-  readonly id: Id;
-  /**
-   * Object path template, e.g. `{organizationId}/{customerId}/logo/{version}.webp`,
-   * or several for a bucket that stores objects in more than one layout. A
-   * path from values uses the template whose placeholders are exactly the
-   * values given, and a stored path string is accepted when any template
-   * matches it, so list the current layout first and keep older ones after
-   * it. A last segment `{...rest}` matches one or more segments.
-   */
-  readonly path: P | readonly [P, ...P[]];
-  readonly public?: boolean;
-  /**
-   * Generated `storage.objects` policies. `tenant` and `owner` match a path
-   * segment against the JWT; `public` allows reads (on a `public: true`
-   * bucket the public URLs need no policy, so none is written and nobody can
-   * list the objects); `none` leaves access to
-   * the secret key; `{ access }` calls the SQL modules' access contract
-   * (`tenant_ids_with`), or the `sql` templates it is given. Defaults to
-   * `none`.
-   *
-   * The access checks decide by role and scope only: for a permission with
-   * row conditions (e.g. `ownerId = principal.id`) the bucket would grant
-   * every object in the scope. `better-supabase doctor` (BS214) refuses
-   * keys the authorization provider doesn't mark `sqlComplete: true`.
-   */
-  readonly policy?: BucketPolicy;
-  /** `'5MiB'`, `'500KB'` or bytes. */
-  readonly fileSizeLimit?: string | number;
-  /** `['image/png', 'image/*']`. */
-  readonly allowedMimeTypes?: readonly string[];
-  /**
-   * Keep earlier versions of an object when it is overwritten or removed.
-   * Set by `apply()` through the Storage API; `sql()` can't write it.
-   */
-  readonly versioning?: boolean;
-  /**
-   * When noncurrent versions expire. Needs `versioning: true`; set by
-   * `apply()`, which removes a stored policy when this is unset.
-   */
-  readonly lifecycle?: BucketLifecycle;
-  /**
-   * The tenant segment. Set it and connected clients only touch paths whose
-   * `param` holds the caller's tenant: pass `{ context }` or `{ tenant }` to
-   * `connect()`, or `{ allTenants: true }` for cross-tenant admin work.
-   */
-  readonly tenant?: {
-    /** Placeholder holding the tenant id. Defaults to `organizationId`. */
-    readonly param?: string;
-    /** JWT claim paths, first match wins. Defaults to `tenant_id`, then `app_metadata.tenant_id`. */
-    readonly claim?: string | readonly string[];
-    /** SQL expression for the tenant id, instead of `claim`. */
-    readonly sql?: string;
-  };
-  readonly owner?: {
-    /** Placeholder holding the user id. Defaults to `userId`. */
-    readonly param?: string;
-  };
-}
-/** The values of one of the bucket's path templates. */
-type PathValues<P extends string> = P extends string ? TemplateValues<P> : never;
-/**
- * A path from the values of one of the bucket's templates, or an existing
- * path string (checked against the templates). `StoragePath`s of other
- * buckets are rejected.
- */
-type ObjectTarget<P extends string, Id extends string = string> = PathValues<P> | PathIn<Id>;
-interface TransformOptions {
-  readonly width?: number;
-  readonly height?: number;
-  readonly resize?: "cover" | "contain" | "fill";
-  readonly quality?: number;
-  readonly format?: "origin";
-}
-type UploadBody = Blob | ArrayBuffer | ArrayBufferView | ReadableStream<Uint8Array> | FormData | string;
-interface UploadOptions {
-  readonly contentType?: string;
-  readonly cacheControl?: string;
-  readonly upsert?: boolean;
-  readonly metadata?: Readonly<Record<string, unknown>>;
-  readonly signal?: AbortSignal;
-  /**
-   * Upload progress from 0 to 1. Where `XMLHttpRequest` exists (browsers,
-   * React Native) the body goes to a signed upload URL so progress events
-   * arrive and `signal` cancels the request; elsewhere it reports 1 when
-   * done. Uploads with `metadata` or a stream body report 1 when done.
-   */
-  readonly onProgress?: (fraction: number) => void;
-}
-interface UrlOptions {
-  /** Seconds or a preset. Defaults to `hour`. */
-  readonly ttl?: number | TtlPreset;
-  readonly transform?: TransformOptions;
-  /** Serve as an attachment, optionally with a file name. */
-  readonly download?: boolean | string;
-  /** Added to the URL so the CDN and browsers fetch it again, e.g. the object's `updatedAt`. */
-  readonly cacheNonce?: string;
-  /** A URL for this version of the object instead of the current one (a versioned bucket). */
-  readonly versionId?: string;
-}
-interface DownloadOptions {
-  /** Read this version of the object instead of the current one. */
-  readonly versionId?: string;
-  readonly signal?: AbortSignal;
-}
-interface TransferOptions {
-  /** Copy or move this version of the source instead of the current one. */
-  readonly versionId?: string;
-}
-interface PurgeCacheOptions {
-  /** Purge only the transformed variants and keep the cached original. */
-  readonly transformations?: boolean;
-  readonly signal?: AbortSignal;
-}
-interface StoredObject {
-  readonly path: string;
-  readonly size?: number;
-  readonly contentType?: string;
-  readonly createdAt: string | null;
-  readonly updatedAt: string | null;
-}
-interface Reservation {
-  readonly path: string;
-  readonly token: string;
-  readonly signedUrl: string;
-}
-interface ReplaceOptions<Id extends string = string> extends UploadOptions {
-  /**
-   * Path the object replaces, checked like any other target before the
-   * upload. Removed after `commit` succeeds.
-   */
-  readonly previous?: string | null;
-  /**
-   * Store the new path, e.g. update the row. Throwing or returning an error
-   * `Result` removes the new object and keeps the previous one.
-   */
-  readonly commit?: (path: StoragePath<Id>) => unknown;
-}
-interface ReplaceResult<Id extends string = string> {
-  readonly path: StoragePath<Id>;
-  readonly removed: string | null;
-  /** Set when the previous object could not be removed. */
-  readonly cleanup?: DbError;
-}
-interface SweepOptions<P extends string> {
-  /** Only look under the path prefix these values fill. */
-  readonly within?: Partial<TemplateValues<P>>;
-  /**
-   * A cutoff instant, or a minimum age. A duration counts a day as 24 hours
-   * and cannot use months or years.
-   */
-  readonly olderThan: Temporal.Instant | Temporal.Duration;
-  /** Returns which of `paths` are still referenced. */
-  readonly referenced: (paths: readonly string[]) => PromiseLike<Iterable<string>> | Iterable<string>;
-  readonly dryRun?: boolean;
-  readonly batchSize?: number;
-  readonly signal?: AbortSignal;
-  readonly now?: () => Temporal.Instant;
-}
-interface SweepResult {
-  readonly scanned: number;
-  readonly orphans: readonly string[];
-  readonly removed: readonly string[];
-}
-interface BucketDrift {
-  readonly field: "missing" | "public" | "fileSizeLimit" | "allowedMimeTypes" | "versioning" | "lifecycle";
-  readonly expected: unknown;
-  readonly actual: unknown;
-  readonly message: string;
-}
-/** Bucket state as stored in `storage.buckets` (or `better-supabase` introspection). */
-interface ActualBucket {
-  readonly public: boolean;
-  readonly fileSizeLimit?: number | null;
-  readonly allowedMimeTypes?: readonly string[] | null;
-  /** `storage.buckets.versioning_status`; leave it out when Storage has no versioning, and it isn't compared. */
-  readonly versioning?: VersioningStatus | null;
-  /** `storage.buckets.lifecycle_configuration`; leave it out to skip the comparison. */
-  readonly lifecycle?: unknown;
-}
-type StorageClient = Pick<SupabaseClient, "storage">;
-interface BucketClient<P extends string, Id extends string = string> {
-  readonly bucket: Bucket<P, Id>;
-  /** The object path, checked against the template and, with `tenant`, the caller's tenant. */
-  path(target: ObjectTarget<P, Id>): Result<StoragePath<Id>>;
-  upload(target: ObjectTarget<P, Id>, body: UploadBody, options?: UploadOptions): AsyncResult<{
-    path: StoragePath<Id>;
-  }>;
-  download(target: ObjectTarget<P, Id>, options?: DownloadOptions): AsyncResult<Blob>;
-  exists(target: ObjectTarget<P, Id>): AsyncResult<boolean>;
-  remove(targets: readonly ObjectTarget<P, Id>[]): AsyncResult<readonly string[]>;
-  /** Copies an object to another path in the bucket; an existing object there is a `conflict`. */
-  copy(from: ObjectTarget<P, Id>, to: ObjectTarget<P, Id>, options?: TransferOptions): AsyncResult<{
-    path: StoragePath<Id>;
-  }>;
-  /** Moves an object to another path in the bucket, as one Storage request. */
-  move(from: ObjectTarget<P, Id>, to: ObjectTarget<P, Id>, options?: TransferOptions): AsyncResult<{
-    path: StoragePath<Id>;
-  }>;
-  /** Every version of the object, newest first, including delete markers. */
-  versions(target: ObjectTarget<P, Id>, options?: {
-    signal?: AbortSignal;
-  }): AsyncResult<readonly ObjectVersion[]>;
-  /** Permanently removes versions of the object, current or noncurrent. */
-  removeVersions(target: ObjectTarget<P, Id>, versionIds: readonly string[]): AsyncResult<readonly string[]>;
-  /**
-   * Purges the CDN cache for the object. Needs the secret key, and on
-   * self-hosted Storage a configured CDN purge endpoint.
-   */
-  purgeCache(target: ObjectTarget<P, Id>, options?: PurgeCacheOptions): AsyncResult<void>;
-  list(within?: Partial<TemplateValues<P>>, options?: {
-    signal?: AbortSignal;
-  }): AsyncResult<readonly StoredObject[]>;
-  signedUrl(target: ObjectTarget<P, Id>, options?: UrlOptions): AsyncResult<string>;
-  signedUrls(targets: readonly ObjectTarget<P, Id>[], options?: Omit<UrlOptions, "transform">): AsyncResult<readonly string[]>;
-  /**
-   * URL for public buckets. No request is made, so it returns a `Result`
-   * like `path()`: an error for a path outside the templates or the tenant.
-   */
-  publicUrl(target: ObjectTarget<P, Id>, options?: Omit<UrlOptions, "ttl">): Result<string>;
-  /** Image transform URL: public for public buckets, signed otherwise. */
-  renderUrl(target: ObjectTarget<P, Id>, transform: TransformOptions, options?: Omit<UrlOptions, "transform">): AsyncResult<string>;
-  /** Upload the new object, run `commit`, then remove the previous object. */
-  replace(target: ObjectTarget<P, Id>, body: UploadBody, options?: ReplaceOptions<Id>): AsyncResult<ReplaceResult<Id>>;
-  /** A signed upload URL for a browser or another service. */
-  reserve(target: ObjectTarget<P, Id>, options?: {
-    upsert?: boolean;
-  }): AsyncResult<Reservation>;
-  uploadReserved(reservation: Pick<Reservation, "path" | "token">, body: UploadBody, options?: UploadOptions): AsyncResult<{
-    path: StoragePath<Id>;
-  }>;
-  /** Removes objects that match a template and the `within` values, are old enough and are not referenced. */
-  sweep(options: SweepOptions<P>): AsyncResult<SweepResult>;
-}
-interface Bucket<P extends string, Id extends string = string> {
-  readonly id: Id;
-  /** The first path template. */
-  readonly template: P;
-  /** Every path template, in the order given. */
-  readonly templates: readonly P[];
-  readonly params: readonly TemplateParams<P>[];
-  readonly public: boolean;
-  readonly policy: BucketPolicy;
-  /**
-   * Placeholder holding the owning user's id: `owner.param` for `owner`
-   * buckets, otherwise `userId` when the template has it. Account deletion
-   * removes the objects it fills.
-   */
-  readonly owner: string | undefined;
-  /** Placeholder connected clients check against the caller's tenant; set by `tenant`. */
-  readonly tenant: string | undefined;
-  readonly fileSizeLimit: number | undefined;
-  readonly allowedMimeTypes: readonly string[] | undefined;
-  readonly versioning: boolean;
-  readonly lifecycle: BucketLifecycle | undefined;
-  /**
-   * Builds a path with the template whose placeholders are exactly the keys
-   * of `values`. A value Storage would refuse, or keys no template takes, is
-   * an `invalid_input` error.
-   */
-  path(values: PathValues<P>): Result<StoragePath<Id>>;
-  /** The values of the first template that matches `path`, or `null`. */
-  match(path: string): PathValues<P> | null;
-  /** Folder prefix filled by `values`, for listing. */
-  prefix(values?: Partial<TemplateValues<P>>): string;
-  /** Checks a size and content type against the bucket limits. */
-  check(file: {
-    size?: number;
-    type?: string;
-  }): DbError | undefined;
-  /** `insert into storage.buckets` plus `storage.objects` policies. Idempotent. */
-  sql(): string;
-  /** A `[storage.buckets.<id>]` section for `supabase/config.toml`. */
-  toml(): string;
-  drift(actual: ActualBucket | undefined): readonly BucketDrift[];
-  /**
-   * Creates or updates the bucket through the Storage API, including
-   * versioning and the lifecycle policy, which `sql()` can't set. Needs the
-   * secret key. Idempotent.
-   */
-  apply(client: StorageClient): AsyncResult<AppliedBucket>;
-  connect(client: StorageClient, options?: BucketConnectOptions): BucketClient<P, Id>;
-}
-interface BucketConnectOptions {
-  /**
-   * Reuse a signed URL for the same path, `ttl`, `transform` and `download`
-   * until shortly before it expires (a tenth of the `ttl`, at most a minute).
-   * The cache belongs to this connection; connect once per request so URLs
-   * never cross users.
-   */
-  readonly cacheSignedUrls?: boolean;
-  /**
-   * The request context (`db.$context`, or what an adapter passes to
-   * `connect`). For a bucket with `tenant`, its tenant (`context.tenant`, the
-   * one `tenant()` resolved, or the `tenant.claim` claims) must fill the
-   * tenant segment of every path.
-   */
-  readonly context?: RequestContext;
-  /** The tenant every path must hold, instead of reading it from `context`. */
-  readonly tenant?: string;
-  /** Skip the tenant check, for admin jobs that work across tenants. */
-  readonly allTenants?: boolean;
-}
-declare function parseSize(value: string | number): number;
-/**
- * A typed Storage bucket: path builders from a template, limits, generated
- * SQL policies and `config.toml`, and helpers for the multi-step work apps
- * repeat (replace, signed uploads, orphan cleanup).
- *
- * ```ts
- * export const logos = defineBucket({
- *   id: 'customer-logos',
- *   path: '{organizationId}/{customerId}/logo/{version}.webp',
- *   policy: 'tenant',
- *   fileSizeLimit: '5MiB',
- *   allowedMimeTypes: ['image/webp'],
- * });
- * ```
- */
-declare function defineBucket<const P extends string, const Id extends string = string>(config: BucketConfig<P, Id>): Bucket<P, Id>;
-//#endregion
-export { UrlOptions as C, TTL as D, AppliedBucket as E, TtlPreset as O, UploadOptions as S, parseSize as T, SweepOptions as _, BucketConnectOptions as a, TransformOptions as b, DownloadOptions as c, PurgeCacheOptions as d, ReplaceOptions as f, StoredObject as g, StorageClient as h, BucketConfig as i, ObjectTarget as l, Reservation as m, Bucket as n, BucketDrift as o, ReplaceResult as p, BucketClient as r, BucketPolicy as s, ActualBucket as t, PathValues as u, SweepResult as v, defineBucket as w, UploadBody as x, TransferOptions as y };