better-supabase 0.8.0 → 0.9.0

package/dist/types-D0W4fnsc.d.ts

@@ -0,0 +1,162 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "./result-Cj3yWhjH.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { i as CredentialRef, r as CredentialProvider } from "./provider-9gBq9W6k.js";
+import { t as BlockTransport } from "./block-transport-DaGGXjIw.js";
+import { i as CursorPageOptions, r as BlockTemporalOptions } from "./block-helpers-C86hPEjI.js";
+import { n as BlockHooks } from "./block-hooks-BLPWD3Jt.js";
+//#region src/blocks/ai-providers/types.d.ts
+/** A tenant's own key for a provider. The key itself stays in the credential provider. */
+interface AiProviderKey {
+  readonly id: string;
+  readonly organizationId: string;
+  /** The AI Gateway's provider slug, such as `anthropic` or `openai`. */
+  readonly provider: string;
+  /** Tells several keys of one provider apart; `default` unless named. */
+  readonly name: string;
+  readonly credentialRef: CredentialRef;
+  /** The provider's other options, such as a region; never a secret. */
+  readonly settings: Readonly<Record<string, unknown>>;
+  readonly enabled: boolean;
+  readonly createdBy: string | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface AiProviderKeyInput {
+  readonly provider: string;
+  /** Store the key first, for example with `vaultCredentials().set(ref, apiKey)`. */
+  readonly credentialRef: CredentialRef;
+  readonly name?: string;
+  readonly settings?: Readonly<Record<string, unknown>>;
+  readonly enabled?: boolean;
+}
+/** A key resolved for one request. */
+interface ResolvedProviderKey {
+  readonly provider: string;
+  readonly name: string;
+  readonly token: string;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly settings: Readonly<Record<string, unknown>>;
+}
+type AiBatchStatus = "pending" | "completed" | "failed" | "cancelled";
+interface AiBatchCounts {
+  readonly total?: number;
+  readonly pending?: number;
+  readonly completed?: number;
+  readonly failed?: number;
+}
+interface AiBatch {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly userId: string | undefined;
+  readonly provider: string;
+  /** The SDK's batch reference, such as `{ version, id, provider }`. */
+  readonly reference: Readonly<Record<string, unknown>>;
+  readonly status: AiBatchStatus;
+  /** The provider's own status word. */
+  readonly rawStatus: string | undefined;
+  readonly itemCount: number;
+  readonly counts: AiBatchCounts;
+  readonly error: string | undefined;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  /** The results are in `items`. */
+  readonly resultsSaved: boolean;
+  readonly polls: number;
+  readonly nextPollAt: Temporal.Instant | undefined;
+  readonly expiresAt: Temporal.Instant | undefined;
+  readonly completedAt: Temporal.Instant | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface NewAiBatch {
+  readonly provider: string;
+  readonly reference: Readonly<Record<string, unknown>>;
+  readonly itemCount?: number;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+  /** Service role only: the user the batch is for. */
+  readonly userId?: string;
+  readonly status?: AiBatchStatus;
+  readonly rawStatus?: string;
+  readonly counts?: AiBatchCounts;
+  readonly expiresAt?: Temporal.Instant;
+}
+interface AiBatchPatch {
+  readonly status?: AiBatchStatus;
+  readonly rawStatus?: string;
+  readonly counts?: AiBatchCounts;
+  readonly error?: string | null;
+  readonly expiresAt?: Temporal.Instant;
+  readonly resultsSaved?: boolean;
+  /** `null` stops polling. */
+  readonly nextPollAt?: Temporal.Instant | null;
+}
+type AiBatchItemStatus = "succeeded" | "failed" | "cancelled" | "expired";
+interface AiBatchItem {
+  readonly batchId: string;
+  readonly requestId: string;
+  readonly organizationId: string;
+  readonly status: AiBatchItemStatus;
+  readonly output: unknown;
+  readonly usage: unknown;
+  readonly error: string | undefined;
+  readonly createdAt: Temporal.Instant;
+}
+interface AiBatchItemInput {
+  readonly requestId: string;
+  readonly status: AiBatchItemStatus;
+  readonly output?: unknown;
+  readonly usage?: unknown;
+  readonly error?: string;
+}
+interface AiProvidersOptions extends BlockTemporalOptions {
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<AiProviders>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  /** Calls as the user: `rpcTransport(supabase)`. */
+  readonly transport: BlockTransport;
+  /** Calls as the service role, for resolving keys, polling and the idle stop. */
+  readonly service?: BlockTransport;
+  /** Resolves and revokes the keys' credential refs. */
+  readonly credentials?: CredentialProvider;
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. Default `better_supabase`. */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+}
+interface AiProviders {
+  readonly keys: {
+    list(organizationId: string): AsyncResult<readonly AiProviderKey[]>;
+    /** Adds or replaces a key (`ai.admin`), and revokes the credential it replaced. */
+    save(organizationId: string, key: AiProviderKeyInput): AsyncResult<AiProviderKey>;
+    /** Deletes a key and revokes its credential. `false` when there was none. */
+    remove(keyId: string): AsyncResult<boolean>;
+    /**
+     * Deletes every key of a tenant and revokes each credential (service
+     * role): the step to run when a tenant is deleted. Returns how many.
+     */
+    removeAll(organizationId: string): AsyncResult<number>;
+    /** The tenant's enabled keys with their tokens, for one request (service role). */
+    resolve(organizationId: string, options?: {
+      readonly providers?: readonly string[];
+      readonly signal?: AbortSignal;
+    }): AsyncResult<readonly ResolvedProviderKey[]>;
+  };
+  readonly batches: {
+    record(organizationId: string, batch: NewAiBatch): AsyncResult<AiBatch>;
+    get(batchId: string): AsyncResult<AiBatch | undefined>;
+    list(organizationId: string, options?: {
+      readonly status?: AiBatchStatus;
+      readonly limit?: number;
+    }): AsyncResult<readonly AiBatch[]>;
+    items(batchId: string, options?: CursorPageOptions<string>): AsyncResult<readonly AiBatchItem[]>;
+    /** Claims batches to poll for `leaseSeconds` (service role). */
+    due(options?: {
+      readonly batch?: number;
+      readonly leaseSeconds?: number;
+    }): AsyncResult<readonly AiBatch[]>;
+    update(batchId: string, patch: AiBatchPatch): AsyncResult<AiBatch>;
+    saveItems(batchId: string, items: readonly AiBatchItemInput[]): AsyncResult<number>;
+  };
+}
+//#endregion
+export { AiBatchItemStatus as a, AiProviderKey as c, AiProvidersOptions as d, NewAiBatch as f, AiBatchItemInput as i, AiProviderKeyInput as l, AiBatchCounts as n, AiBatchPatch as o, ResolvedProviderKey as p, AiBatchItem as r, AiBatchStatus as s, AiBatch as t, AiProviders as u };

package/dist/types-R6syp1el.js

@@ -0,0 +1,29 @@
+//#region src/ir/types.ts
+const and = (...items) => {
+	const present = items.filter((item) => item !== void 0);
+	if (present.length === 0) return;
+	if (present.length === 1) return present[0];
+	return {
+		kind: "and",
+		items: present
+	};
+};
+const or = (...items) => {
+	if (items.length === 1 && items[0]) return items[0];
+	return {
+		kind: "or",
+		items
+	};
+};
+const not = (item) => ({
+	kind: "not",
+	item
+});
+const column = (name, op, value) => ({
+	kind: "column",
+	column: name,
+	op,
+	value
+});
+//#endregion
+export { or as i, column as n, not as r, and as t };

package/dist/types-YfwpIE-d.d.ts

@@ -0,0 +1,357 @@
+/// <reference lib="esnext.temporal" />
+//#region src/storage/versioning.d.ts
+/** A bucket's object versioning state in Storage. */
+type VersioningStatus = "DISABLED" | "ENABLED" | "SUSPENDED";
+/** One rule of a bucket lifecycle policy. Storage only expires noncurrent versions today. */
+interface BucketLifecycleRule {
+  /** Storage generates one when you omit it. */
+  readonly id?: string;
+  /** Defaults to `Enabled`. `Disabled` keeps the rule stored but inactive. */
+  readonly status?: "Enabled" | "Disabled";
+  readonly noncurrentVersionExpiration: {
+    /** How old a noncurrent version must be before it expires, in days (at least 1). */
+    readonly noncurrentDays: number;
+    /** Keep this many of the newest noncurrent versions regardless of age (1 to 100). */
+    readonly newerNoncurrentVersions?: number;
+  };
+}
+/** A bucket lifecycle policy: 1 to 1000 rules, applied by `bucket.apply()`. */
+interface BucketLifecycle {
+  readonly rules: readonly [BucketLifecycleRule, ...BucketLifecycleRule[]];
+}
+/** One version of an object, newest first in `versions()`. */
+interface ObjectVersion {
+  readonly versionId: string;
+  /** The version the path serves now. */
+  readonly current: boolean;
+  /** A delete marker hides the object without removing its versions. */
+  readonly deleteMarker: boolean;
+  readonly size?: number;
+  readonly contentType?: string;
+  readonly createdAt: string | null;
+  /** When the version stopped being current. */
+  readonly archivedAt: string | null;
+}
+//#endregion
+//#region src/schema/types.d.ts
+type Casing = "snake" | "camel";
+/** Runtime metadata for one column. Keyed by the app (cased) column name. */
+interface ColumnMeta {
+  /** Database column name. */
+  readonly db: string;
+  /** Postgres type name (`uuid`, `text`, `timestamptz`, `note_kind`). */
+  readonly type: string;
+  readonly nullable: boolean;
+  /**
+   * An insert may leave the column out: it has a default, a `before insert`
+   * trigger can fill it, or `tables.<t>.insertOptional` lists it.
+   */
+  readonly hasDefault: boolean;
+  readonly generated?: boolean;
+  /** Identity column; `'always'` columns can't be written. */
+  readonly identity?: "always" | "by default";
+  /** `false` when inserts can't set this column (generated, identity always, view). */
+  readonly insertable?: false;
+  /** `false` when updates can't set this column. */
+  readonly updatable?: false;
+  readonly array?: boolean;
+  readonly json?: boolean;
+  /** Allowed values for enum columns and CHECK-constraint unions. */
+  readonly enum?: readonly string[];
+  /** How values are decoded from the wire (see the `codecs` config). */
+  readonly codec?: Codec;
+  /** Listed in `config.sensitive`; the `noSensitiveSelect` rule guards reads of it. */
+  readonly sensitive?: true;
+  /** Bucket id of the objects this text column points to (`config.storagePaths`). */
+  readonly storage?: string;
+  /** The column's `COMMENT ON`, without its `@example` and `@deprecated` lines. */
+  readonly description?: string;
+  /** The column's comment has a `@deprecated` line. */
+  readonly deprecated?: true;
+}
+/**
+ * Runtime representation for a column: `instant` decodes `timestamptz` to
+ * `Temporal.Instant`, `plainDateTime` decodes `timestamp` to
+ * `Temporal.PlainDateTime`, and `bigint` and `string` read the exact text of
+ * `int8`/`numeric` values.
+ */
+type Codec = "instant" | "plainDateTime" | "bigint" | "string";
+interface RelationMeta {
+  /** App key of the target table. */
+  readonly table: string;
+  readonly kind: "one" | "many";
+  readonly nullable: boolean;
+  /** Foreign key constraint name, used as the PostgREST embed hint. */
+  readonly foreignKey: string;
+  /** App column names on the source table. */
+  readonly columns: readonly string[];
+  /** App column names on the target table. */
+  readonly references: readonly string[];
+  /** `forward`: this table holds the FK. `reverse`: the target holds it. */
+  readonly direction: "forward" | "reverse";
+  /** What deleting the referenced row does to the referencing rows, when it changes them. */
+  readonly onDelete?: "cascade" | "set null" | "set default";
+}
+interface TableFlags {
+  /** App column holding the soft-delete timestamp. */
+  readonly softDelete?: string;
+  readonly timestamps?: {
+    readonly createdAt?: string;
+    readonly updatedAt?: string;
+  };
+  /** App column holding the tenant id. */
+  readonly tenant?: string;
+  readonly actor?: {
+    readonly createdBy?: string;
+    readonly updatedBy?: string;
+    /** The admin behind an impersonated write; `null` otherwise. */
+    readonly impersonatedBy?: string;
+  };
+  /** App column used for optimistic concurrency, usually `updatedAt`. */
+  readonly version?: string;
+}
+interface TableMeta {
+  /** App key of the table (`customerTags` in camel casing). */
+  readonly key: string;
+  /** Database table name. */
+  readonly name: string;
+  readonly schema: string;
+  readonly kind: "table" | "view";
+  readonly columns: Readonly<Record<string, ColumnMeta>>;
+  /** App column names. */
+  readonly primaryKey: readonly string[];
+  /** Constraint name to app column names. */
+  readonly uniqueKeys: Readonly<Record<string, readonly string[]>>;
+  readonly relations: Readonly<Record<string, RelationMeta>>;
+  readonly flags: TableFlags;
+  /** The table's `COMMENT ON`, without its `@example` and `@deprecated` lines. */
+  readonly description?: string;
+  /** The table's comment has a `@deprecated` line. */
+  readonly deprecated?: true;
+}
+interface FunctionMeta extends FunctionSignature {
+  readonly name: string;
+  readonly schema: string;
+  /**
+   * Every signature of an overloaded function, in signature order. The
+   * fields above describe the first one; `$rpc` picks the signature whose
+   * argument names match the call.
+   */
+  readonly overloads?: readonly FunctionSignature[];
+}
+interface FunctionSignature {
+  readonly args: readonly {
+    readonly name: string;
+    readonly type: string;
+    /** The argument has a default; set in `overloads` only. */
+    readonly optional?: boolean;
+  }[];
+  readonly returns: string;
+  readonly returnsSet: boolean;
+  readonly volatility: "immutable" | "stable" | "volatile";
+  /**
+   * How `$rpc` decodes the returned rows, present when decoding changes
+   * them: the rows of a table (by app key), or a `returns table (...)` record.
+   */
+  readonly result?: FunctionResult;
+}
+type FunctionResult = {
+  readonly table: string;
+} | {
+  readonly columns: readonly ResultColumn[];
+};
+/** A column of a `returns table (...)` result. */
+interface ResultColumn {
+  /** Database name, the key PostgREST returns. */
+  readonly db: string;
+  /** App name, when the casing changes it. */
+  readonly name?: string;
+  readonly codec?: Codec;
+}
+interface SchemaMeta {
+  readonly version: 1;
+  readonly casing: Casing;
+  readonly tables: Readonly<Record<string, TableMeta>>;
+  readonly enums: Readonly<Record<string, readonly string[]>>;
+  readonly functions: Readonly<Record<string, FunctionMeta>>;
+  readonly buckets?: Readonly<Record<string, BucketMeta>>;
+  readonly topics?: Readonly<Record<string, string>>;
+  /** Tables that broadcast change signals (`config.realtime.tables`), keyed by app key. */
+  readonly realtime?: Readonly<Record<string, RealtimeTableMeta>>;
+  /** Claim names from `config.claims` that differ from the defaults. */
+  readonly claims?: Partial<ClaimsMeta>;
+}
+/** The claim names the SQL modules, codegen and runtime defaults agree on. */
+interface ClaimsMeta {
+  /** Top-level claim holding the active tenant id. Defaults to `tenant_id`. */
+  readonly tenant: string;
+  /** `scope` of the tenant entries in the `memberships` claim. Defaults to `tenant`. */
+  readonly scope: string;
+  /** Claim holding plan features per tenant (`{ [tenantId]: string[] }`). Defaults to `features`. */
+  readonly features: string;
+  /** Claim holding the caller's memberships (`{ scope, id, role }[]`). Defaults to `memberships`. */
+  readonly memberships: string;
+}
+interface RealtimeTableMeta {
+  /** App column whose value scopes the broadcast topic. */
+  readonly tenant?: string;
+  /** App column of the row's user (`realtime.users`): the topic is per user. */
+  readonly user?: string;
+}
+type BucketPolicyName = "tenant" | "owner" | "public" | "none";
+/**
+ * SQL templates a Storage or Realtime policy calls instead of the access
+ * contract, usually an authorization provider's (`authorization.functions`).
+ * `{permission}` is the key as a literal and `{scope}` the policy's scope.
+ */
+interface AccessPolicySql {
+  /** The ids of the `{scope}` instances where the caller holds `{permission}`, as a set. */
+  readonly idsWith: string;
+  /** Whether the caller holds `{permission}` platform-wide. */
+  readonly isPlatform: string;
+}
+/**
+ * A policy through the SQL modules' [access contract](/docs/blocks/access):
+ * `tenant_ids_with(permission)` for the tenant id in the path, or
+ * `is_platform(permission)`. Works with every access model. With `sql`, it
+ * calls those templates instead, for any scope they take.
+ */
+interface AccessBucketPolicy {
+  readonly access: {
+    /** Downloads, signed URLs, renders and metadata reads. */
+    readonly read: string;
+    /** Listing; without it `read` covers listing too. */
+    readonly list?: string;
+    /** Uploads, updates and moves; also deletes unless `delete` is set. */
+    readonly write: string;
+    readonly delete?: string;
+  };
+  /**
+   * `tenant` (default) checks the path's tenant segment; `platform` checks
+   * platform permissions. With `sql`, any scope name its templates take.
+   */
+  readonly scope?: string;
+  /** 1-based path segment holding the scope id. Defaults to the `{organizationId}` segment. */
+  readonly segment?: number;
+  /**
+   * The templates to call, or `"provider"` for `authorization.functions`
+   * from the config, which `gen` copies in.
+   */
+  readonly sql?: AccessPolicySql | "provider";
+}
+/** An access topic policy: `select` (receive) and `insert` (send) on `realtime.messages`. */
+interface AccessTopicPolicy {
+  readonly receive: string;
+  /** Lets clients send on the topic with this permission. */
+  readonly send?: string;
+  /** As for {@link AccessBucketPolicy}. */
+  readonly scope?: string;
+  /** 1-based `:`-separated topic segment holding the scope id. Defaults to the `{organizationId}` segment. */
+  readonly segment?: number;
+  /** As for {@link AccessBucketPolicy}. */
+  readonly sql?: AccessPolicySql | "provider";
+}
+interface BucketMeta {
+  readonly id: string;
+  readonly public: boolean;
+  readonly path: string | readonly [string, ...string[]];
+  readonly policy?: BucketPolicyName | AccessBucketPolicy;
+  /** Claim paths for the tenant policy, when `config.claims.tenant` is not the default. */
+  readonly tenant?: {
+    readonly claim: readonly string[];
+  };
+  readonly fileSizeLimit?: string;
+  readonly allowedMimeTypes?: readonly string[];
+  readonly versioning?: boolean;
+  readonly lifecycle?: BucketLifecycle;
+}
+interface RelationTypes {
+  readonly table: string;
+  readonly kind: "one" | "many";
+  readonly nullable: boolean;
+}
+interface ModelFlags {
+  readonly softDelete?: string;
+  readonly timestamps?: true;
+  readonly tenant?: string;
+  readonly actor?: true;
+  readonly version?: string;
+}
+interface ModelTypes {
+  readonly Row: object;
+  readonly Insert: object;
+  readonly Update: object;
+  readonly Relations: object;
+  readonly PrimaryKey: PropertyKey;
+  readonly UniqueKeys: object;
+  /** CHECK constraint names. */
+  readonly Checks?: string;
+  /** Foreign key constraint names on this table. */
+  readonly ForeignKeys?: string;
+  readonly Flags: ModelFlags;
+}
+type AnyModels = {
+  readonly [table: string]: ModelTypes;
+};
+type FunctionTypes = {
+  readonly Args: object;
+  readonly Returns: unknown;
+};
+type AnyFunctions = {
+  readonly [name: string]: FunctionTypes;
+};
+/**
+ * Carries the model types next to the runtime metadata. Created by
+ * `defineSchema` in the generated module.
+ */
+interface Schema<M extends AnyModels = AnyModels, D = unknown, F extends AnyFunctions = AnyFunctions, S extends string = string> {
+  readonly meta: SchemaMeta;
+  /** Phantom. Never present at runtime. */
+  readonly "~types"?: {
+    readonly models: M;
+    readonly database: D;
+    readonly functions: F;
+    /** The `config.subjects` type names. */
+    readonly subjects: S;
+  };
+}
+type ModelsOf<S> = S extends Schema<infer M> ? M : never;
+type DatabaseOf<S> = S extends Schema<AnyModels, infer D> ? D : never;
+type FunctionsOf<S> = S extends Schema<AnyModels, unknown, infer F> ? F : never;
+/** The schema's subject types (`config.subjects`), `string` without a registry. */
+type SubjectTypeOf<S> = S extends Schema<AnyModels, unknown, AnyFunctions, infer T> ? T : string;
+/** One subject: its type and its id as text. */
+interface SubjectRef<T extends string = string> {
+  readonly type: T;
+  readonly id: string;
+}
+type TableKey<M extends AnyModels> = Extract<keyof M, string>;
+type Row<M extends AnyModels, T extends keyof M> = M[T]["Row"];
+type Insert<M extends AnyModels, T extends keyof M> = M[T]["Insert"];
+type Update<M extends AnyModels, T extends keyof M> = M[T]["Update"];
+type Relations<M extends AnyModels, T extends keyof M> = M[T]["Relations"];
+type Flags<M extends AnyModels, T extends keyof M> = M[T]["Flags"];
+type PrimaryKeyColumn<M extends AnyModels, T extends keyof M> = Extract<M[T]["PrimaryKey"], keyof Row<M, T>>;
+type UniqueKeyName<M extends AnyModels, T extends keyof M> = Extract<keyof M[T]["UniqueKeys"], string>;
+type UniqueKeyColumns<M extends AnyModels, T extends keyof M, K extends keyof M[T]["UniqueKeys"]> = Extract<M[T]["UniqueKeys"][K] extends readonly (infer C)[] ? C : never, keyof Row<M, T>>;
+/**
+ * Values for exactly one unique key: the primary key columns, or the columns
+ * of one named unique constraint or unique index.
+ */
+type UniqueWhere<M extends AnyModels, T extends keyof M> = { readonly [C in PrimaryKeyColumn<M, T>]: Row<M, T>[C]; } | { [K in keyof M[T]["UniqueKeys"]]: { readonly [C in UniqueKeyColumns<M, T, K>]: Row<M, T>[C]; }; }[keyof M[T]["UniqueKeys"]];
+/** Every unique constraint name in the schema, for `isConflict`. */
+type UniqueConstraint<M extends AnyModels> = { [T in keyof M]: Extract<keyof M[T]["UniqueKeys"], string>; }[keyof M];
+/** Every CHECK constraint name in the schema, for `isCheck`. */
+type CheckConstraint<M extends AnyModels> = { [T in keyof M]: M[T] extends {
+  readonly Checks: infer C extends string;
+} ? C : never; }[keyof M];
+/** Every foreign key constraint name in the schema, for `isForeignKey`. */
+type ForeignKeyConstraint<M extends AnyModels> = { [T in keyof M]: M[T] extends {
+  readonly ForeignKeys: infer C extends string;
+} ? C : never; }[keyof M];
+type IsUnion<T, U = T> = T extends unknown ? [U] extends [T] ? false : true : never;
+/** A single value for single-column keys, an object for composite keys. */
+type PrimaryKeyValue<M extends AnyModels, T extends keyof M> = true extends IsUnion<PrimaryKeyColumn<M, T>> ? { readonly [K in PrimaryKeyColumn<M, T>]: Row<M, T>[K]; } : Row<M, T>[PrimaryKeyColumn<M, T>];
+type Simplify<T> = { [K in keyof T]: T[K]; } & {};
+//#endregion
+export { Relations as A, TableMeta as B, ModelTypes as C, RealtimeTableMeta as D, PrimaryKeyValue as E, Simplify as F, BucketLifecycle as G, UniqueKeyName as H, SubjectRef as I, VersioningStatus as J, BucketLifecycleRule as K, SubjectTypeOf as L, Row as M, Schema as N, RelationMeta as O, SchemaMeta as P, TableFlags as R, ModelFlags as S, PrimaryKeyColumn as T, UniqueWhere as U, UniqueConstraint as V, Update as W, FunctionResult as _, AnyModels as a, FunctionsOf as b, Casing as c, Codec as d, ColumnMeta as f, FunctionMeta as g, ForeignKeyConstraint as h, AnyFunctions as i, ResultColumn as j, RelationTypes as k, CheckConstraint as l, Flags as m, AccessPolicySql as n, BucketMeta as o, DatabaseOf as p, ObjectVersion as q, AccessTopicPolicy as r, BucketPolicyName as s, AccessBucketPolicy as t, ClaimsMeta as u, FunctionSignature as v, ModelsOf as w, Insert as x, FunctionTypes as y, TableKey as z };