@rebasepro/types 0.19.1 → 0.19.2-canary.g09316f6

package/dist/controllers/data_driver.d.ts

@@ -3,7 +3,8 @@ import type { EntityStatus, EntityValues } from "../types/entities.js";
 import type { CollectionConfig, FilterValues } from "../types/collections.js";
 import type { OrderByTuple } from "../types/filter-operators.js";
 import type { RebaseCallContext } from "../call_context.js";
-import type { LogicalCondition } from "./data.js";
+import type { IncludeSpec, LogicalCondition } from "./data.js";
+import type { CollectionUpdateMeta } from "../types/websockets.js";
 /**
  * @internal
  */
@@ -12,6 +13,13 @@ export interface FetchOneProps<M extends Record<string, unknown> = Record<string
     id: string | number;
     databaseId?: string;
     collection?: CollectionConfig<M>;
+    /**
+     * See {@link FetchCollectionProps.withDeleted}. A soft-deleted row is a 404
+     * here by default, so `findById` and `find` agree about which rows exist —
+     * a row you cannot find in a listing and can still open by id is the kind
+     * of inconsistency that makes a feature untrustworthy.
+     */
+    withDeleted?: boolean | "only";
 }
 /**
  * @internal
@@ -121,12 +129,50 @@ export interface FetchCollectionProps<M extends Record<string, unknown> = Record
     order?: "desc" | "asc";
     /** Vector similarity search configuration */
     vectorSearch?: VectorSearchParams;
+    /**
+     * What to do about rows a soft delete has stamped.
+     *
+     * Unset (the default) hides them, which is the whole point of the feature:
+     * a deleted row is deleted as far as the application is concerned. `true`
+     * includes them alongside the live ones — a trash view, an admin audit.
+     * `"only"` returns nothing but them, which is the trash view proper and is
+     * not expressible as a filter, because the field is not part of the
+     * caller's vocabulary.
+     *
+     * Ignored by collections that do not declare {@link
+     * PostgresCollectionConfig.softDelete}: there is no stamp to look at, and
+     * silently returning nothing for `"only"` on such a collection would be a
+     * worse answer than ignoring it.
+     */
+    withDeleted?: boolean | "only";
+    /**
+     * Relations to load — see {@link IncludeSpec}.
+     *
+     * Absent means *no* relations, the same as it does over REST. It used to be
+     * absent from this contract entirely, and the driver's own fetch then loaded
+     * every relation of every row unconditionally: `find()` returned a row with
+     * a foreign key and `listen()` returned the same row with a nested object
+     * where that key was, for the same query.
+     */
+    include?: IncludeSpec;
+    /** Columns to read, as a projection. See `FindParams.fields`. */
+    fields?: string[];
+    /** `SELECT DISTINCT` over the projection. See `FindParams.distinct`. */
+    distinct?: boolean;
 }
 /**
  * @internal
  */
 export type ListenCollectionProps<M extends Record<string, unknown> = Record<string, unknown>> = FetchCollectionProps<M> & {
-    onUpdate: (rows: Record<string, unknown>[]) => void;
+    /**
+     * Page number (1-indexed), as `FindParams.page`.
+     *
+     * A subscription could name a `limit` and an `offset` but not a `page`,
+     * so a live list on page three had to compute the offset itself — and
+     * the two spellings then disagreed about what a page was.
+     */
+    page?: number;
+    onUpdate: (rows: Record<string, unknown>[], meta?: CollectionUpdateMeta) => void;
     onError?: (error: Error) => void;
 };
 /**
@@ -149,6 +195,22 @@ export interface SaveProps<M extends Record<string, unknown> = Record<string, un
      * them there is no conflict target and the row is inserted normally.
      */
     upsert?: boolean;
+    /**
+     * The columns the upsert matches a conflict on, instead of the primary key.
+     *
+     * The key is the only target that always exists, and it is the wrong one
+     * for the write an upsert is usually reached for: "this user, identified by
+     * their email, exists with these values". Keyed on the primary key that is
+     * an insert, because the caller does not know the serial id — so the row is
+     * duplicated on every run.
+     *
+     * Only column sets carrying a uniqueness guarantee are legal here; Postgres
+     * refuses anything else with 42P10, from inside a transaction. The REST
+     * layer checks the target against the collection's declarations first (see
+     * `resolveConflictTarget`), so the answer is a 400 naming the available
+     * targets rather than a 500 naming a constraint the caller never wrote.
+     */
+    onConflict?: readonly string[];
 }
 /**
  * @internal
@@ -163,6 +225,8 @@ export interface SaveManyProps<M extends Record<string, unknown> = Record<string
     collection?: CollectionConfig<M>;
     /** Apply every row as INSERT ... ON CONFLICT DO UPDATE. See {@link SaveProps.upsert}. */
     upsert?: boolean;
+    /** The conflict target for those upserts. See {@link SaveProps.onConflict}. */
+    onConflict?: readonly string[];
 }
 /**
  * @internal
@@ -193,6 +257,17 @@ export interface DeleteProps<M extends Record<string, unknown> = Record<string,
         values?: Partial<EntityValues<M>>;
     };
     collection?: CollectionConfig<M>;
+    /**
+     * Issue a real `DELETE` on a collection that declares
+     * {@link PostgresCollectionConfig.softDelete}.
+     *
+     * The row and every cascade behind it go. It needs the same permission an
+     * ordinary delete does and nothing more: it is the same verb, and a second
+     * access-control surface for one operation is a second thing to get wrong.
+     * No effect on a collection without soft delete, where every delete is
+     * already this one.
+     */
+    hard?: boolean;
 }
 /**
  * @internal
@@ -201,6 +276,34 @@ export interface DeleteManyProps<M extends Record<string, unknown> = Record<stri
     path: string;
     ids: (string | number)[];
     collection?: CollectionConfig<M>;
+    /** See {@link DeleteProps.hard}. */
+    hard?: boolean;
+}
+/**
+ * One operation of a {@link DataDriver.batchWrite}.
+ *
+ * `path` rather than a slug, because a batch entry addresses rows exactly as
+ * the single-row props do and a nested path is a legal address there.
+ *
+ * @internal
+ */
+export interface BatchWriteOperation<M extends Record<string, unknown> = Record<string, unknown>> {
+    op: "create" | "update" | "upsert" | "delete";
+    path: string;
+    /** Required for `update` and `delete`. May be a `$ref` marker; see `batchWrite`. */
+    id?: unknown;
+    values?: Partial<EntityValues<M>>;
+    collection?: CollectionConfig<M>;
+    /** See {@link SaveProps.onConflict}. `upsert` only. */
+    onConflict?: readonly string[];
+    /** Names this operation's result, for a later `$ref`. */
+    ref?: string;
+}
+/**
+ * @internal
+ */
+export interface BatchWriteProps<M extends Record<string, unknown> = Record<string, unknown>> {
+    operations: BatchWriteOperation<M>[];
 }
 export type FilterCombinationValidProps = {
     path: string;
@@ -333,6 +436,31 @@ export interface DataDriver {
      * {@link SDKCollectionClient.deleteMany}. Optional, as `saveMany` is.
      */
     deleteMany?<M extends Record<string, unknown> = Record<string, unknown>>(props: DeleteManyProps<M>): Promise<void>;
+    /**
+     * Apply a mixed list of writes across collections as one unit of work.
+     *
+     * The capability `saveMany` and `deleteMany` cannot express between them: a
+     * batch that touches two tables. Sent as two requests those can
+     * half-succeed, and the recovery — read back, work out which half landed,
+     * undo it — is code nobody writes.
+     *
+     * Every operation runs the pipeline its single-row equivalent runs, in
+     * order, in one transaction, under the caller's own role. Operations may
+     * carry `{ "$ref": "<name>.<field>" }` markers in `values` or `id`, which
+     * the driver resolves against the rows earlier operations wrote — the
+     * driver, because inside the transaction is the only place those rows
+     * exist. `@rebasepro/server` exports `resolveBatchRefs` so the resolution
+     * is one implementation rather than one per driver.
+     *
+     * Resolves to one entry per operation, aligned to the input: the written
+     * row for a create, update or upsert, and `null` for a delete.
+     *
+     * Optional for the same reason `saveMany` is: a driver that cannot make it
+     * atomic must not pretend to. The REST layer answers `BATCH_UNSUPPORTED`
+     * rather than falling back to a loop, which would be the non-atomic
+     * sequence the caller reached for this to avoid.
+     */
+    batchWrite?<M extends Record<string, unknown> = Record<string, unknown>>(props: BatchWriteProps<M>): Promise<(Record<string, unknown> | null)[]>;
     /**
      * Check if the given property is unique in the given collection
      * @param path Collection path
@@ -420,7 +548,34 @@ export interface RestFetchService {
         searchExplain?: boolean;
         databaseId?: string;
         vectorSearch?: VectorSearchParams;
-    }, include?: string[]): Promise<Record<string, unknown>[]>;
+        /** See {@link FetchCollectionProps.withDeleted}. */
+        withDeleted?: boolean | "only";
+        /**
+         * Columns to read. A projection pushed into the SELECT, not a trim
+         * of the response — `excludeFromApi` still applies on top, and the
+         * primary key is always read whether or not it is named.
+         */
+        fields?: string[];
+        /** `SELECT DISTINCT` over the projection. See `FindParams.distinct`. */
+        distinct?: boolean;
+    }, include?: IncludeSpec): Promise<Record<string, unknown>[]>;
+    /**
+     * The opaque cursor that continues a listing after `row`.
+     *
+     * On the driver rather than the route because deriving it needs the
+     * collection's primary key — which may be named anything and span several
+     * columns — and that is the driver's knowledge. The route holds the last
+     * row and the sort keys and asks for the string.
+     *
+     * `undefined` where no cursor can describe the page: an ordering with no
+     * stored value to compare against (relevance), or a row missing a value for
+     * one of the sort keys. The listing then reports no `nextCursor` and the
+     * caller pages by offset, which is what it did before cursors existed.
+     *
+     * Optional: a driver that cannot seek simply never issues one, and
+     * `meta.nextCursor` is absent for every read it serves.
+     */
+    cursorFor?(collectionPath: string, row: Record<string, unknown>, orderBy?: OrderByTuple[]): string | undefined;
     /**
      * `count`/`sum`/`avg`/`min`/`max` over the rows a filter selects,
      * optionally grouped.
@@ -445,9 +600,16 @@ export interface RestFetchService {
         logical?: LogicalCondition;
         searchString?: string;
         limit?: number;
+        /** See {@link FetchCollectionProps.withDeleted}. */
+        withDeleted?: boolean | "only";
     }): Promise<Record<string, unknown>[]>;
     /**
      * Fetch a single flattened entity with optional relation includes.
      */
-    fetchOneForRest(collectionPath: string, id: string | number, include?: string[], databaseId?: string): Promise<Record<string, unknown> | null>;
+    fetchOneForRest(collectionPath: string, id: string | number, include?: IncludeSpec, databaseId?: string, options?: {
+        /** See `FetchCollectionProps.fields`. */
+        fields?: string[];
+        /** See {@link FetchOneProps.withDeleted}. */
+        withDeleted?: boolean | "only";
+    }): Promise<Record<string, unknown> | null>;
 }

package/dist/controllers/storage.d.ts

@@ -30,6 +30,36 @@ export interface UploadFileProps {
      * Defaults to `false` (private, short-lived signed URLs).
      */
     public?: boolean;
+    /**
+     * Which property this file is being uploaded *for* — the collection's slug
+     * and the property path within it (`coverImage`, `meta.avatar`,
+     * `gallery` for an array of files).
+     *
+     * The server reads it to enforce that property's own `storage.maxSize` and
+     * `storage.acceptedFiles`, which were declared per property, published in
+     * the generated types, rendered by the panel's file picker, and until now
+     * enforced by nothing on the server — so a `curl` past the picker put a
+     * 40 MB executable in a bucket whose config said "images, under 200 KB".
+     *
+     * Advisory in one direction only. The rules are resolved from the server's
+     * own registry by slug, so naming a property can make an upload *stricter*
+     * or leave it at the global cap; it can never widen anything.
+     *
+     * Omitted, the upload is checked against the deployment's global
+     * `maxFileSize` exactly as before.
+     */
+    context?: UploadPropertyContext;
+}
+/**
+ * The property an upload is destined for.
+ *
+ * @group Models
+ */
+export interface UploadPropertyContext {
+    /** The collection's slug, as the server registered it. */
+    collection: string;
+    /** Dotted path to the property — `coverImage`, `meta.avatar`. */
+    property: string;
 }
 /**
  * @group Models

package/dist/index.es.js

@@ -345,6 +345,21 @@ var REST_TO_CANONICAL = {
 */
 var NULL_OPS = /* @__PURE__ */ new Set(["is-null", "is-not-null"]);
 /**
+* Operators whose operand is a **list** of values rather than one value.
+*
+* On the wire that list is always parenthesised — `in.(draft,review)` — which
+* is what lets the REST codec tell `?status=in.(a,b)` (the operator) from
+* `?status=in.progress` (a value that happens to start with an operator's
+* name). See `deserializeSingle` in `@rebasepro/common`.
+*
+* @group Models
+*/
+var LIST_OPS = /* @__PURE__ */ new Set([
+	"in",
+	"not-in",
+	"array-contains-any"
+]);
+/**
 * Every canonical operator, in a stable order. Useful for engine capability
 * declarations ({@link DataSourceCapabilities.filterOperators}) and for
 * building operator subsets.
@@ -799,6 +814,24 @@ var DEFAULT_FUZZY_THRESHOLD = .3;
 var RELEVANCE_SORT_FIELD = "_score";
 //#endregion
 //#region src/types/relations.ts
+/**
+* The key a junction row's own columns are carried under, in both directions.
+*
+* A read that includes a `manyToMany` relation serves each related row with its
+* link's columns nested here — `{ id: 5, name: "ts", _pivot: { role: "owner" } }`
+* — and a membership write may name the same key on an element to state what
+* the link should hold. One constant because the two have to be the same word:
+* a wire name that differs between the read and the write it round-trips
+* through is a shape no client can echo back.
+*
+* Leading underscore, like `_matches`: it reads as metadata about the row
+* rather than as one of its columns. A payload property may not be named
+* `_pivot` either — `checkJunctionPayload` refuses it — so the key means one
+* thing wherever it appears.
+*
+* @group Models
+*/
+var JUNCTION_PIVOT_KEY = "_pivot";
 /** @group Models */
 function hasForeignKeyOnTarget(relation) {
 	return relation.kind === "hasOne" || relation.kind === "hasMany";
@@ -919,7 +952,11 @@ var policy = {
 		value
 	}),
 	authUid: () => ({ kind: "authUid" }),
-	authRoles: () => ({ kind: "authRoles" })
+	authRoles: () => ({ kind: "authRoles" }),
+	authClaim: (name) => ({
+		kind: "authClaim",
+		name
+	})
 };
 //#endregion
 //#region src/types/rls-functions.ts
@@ -1023,6 +1060,27 @@ function usesLegacyRlsFunctions(sql) {
 	return /\bauth\.(uid|jwt|roles)\s*\(\s*\)/i.test(sql);
 }
 //#endregion
+//#region src/types/tenancy.ts
+/** Narrow a {@link TenantSource} to its claim form. @group Models */
+function isTenantClaimSource(source) {
+	return typeof source.claim === "string";
+}
+/** Narrow a {@link TenantSource} to its membership form. @group Models */
+function isTenantMembershipSource(source) {
+	return typeof source.membership === "object" && source.membership !== null;
+}
+/**
+* The roles tenancy does not apply to, when the collection names none.
+*
+* `admin`, mirroring the security baseline every collection already carries
+* (`<table>_default_admin_read` / `_write`): the Studio, `dataAsAdmin` and a
+* support operator all run with it, and a tenancy rule that locked them out
+* would make the admin panel show an empty table on a collection full of rows.
+*
+* @group Models
+*/
+var DEFAULT_TENANT_BYPASS_ROLES = ["admin"];
+//#endregion
 //#region src/types/backend.ts
 /**
 * Type guard: can this admin plan a live schema change?
@@ -1073,7 +1131,8 @@ var DEFAULT_COMMIT_PATHS = {
 	ddlFile: "drizzle/schema.sql",
 	policiesFile: "drizzle/policies.sql",
 	searchFile: "drizzle/search.sql",
-	vectorFile: "drizzle/vector.sql"
+	vectorFile: "drizzle/vector.sql",
+	triggersFile: "drizzle/triggers.sql"
 };
 //#endregion
 //#region src/types/channel_bus.ts
@@ -2174,6 +2233,107 @@ function computeSchemaVersion(collections) {
 	return `v1:${hex(h1)}${hex(h2)}`;
 }
 //#endregion
+//#region src/controllers/data.ts
+/**
+* Hops an {@link IncludeSpec} may nest. `comments.author` is two.
+*
+* @group Data
+*/
+var MAX_INCLUDE_DEPTH = 3;
+/**
+* SDK collection client — returns flat rows, no Entity wrapper.
+*
+* This is the public API surface for app developers using
+* `createRebaseClient()`. admin internals use `CollectionAccessor` instead.
+*
+* Type parameters:
+* - `M` — the **Row** shape returned by reads (`find`, `findById`, `listen`).
+* - `I` — the **Insert** shape accepted by {@link create}. Defaults to
+*   `Partial<M>`; the generated SDK supplies a dedicated `Insert` type where
+*   required columns are required and auto-generated / read-only columns are
+*   omitted, so `create({})` on a table with required fields is a compile error.
+* - `U` — the **Update** shape accepted by {@link update}. Defaults to
+*   `Partial<M>`; the generated SDK supplies a dedicated `Update` type.
+*
+* @example
+* const { data: posts } = await rebase.data.posts.find();
+* console.log(posts[0].title);       // flat access
+* console.log(posts[0].id);          // id at top level
+*
+* const post = await rebase.data.posts.findById(1);
+* console.log(post?.title);          // no .values needed
+*
+* @group Data
+*/
+/**
+* A change expressed as an operation on the column's current value, rather than
+* as the value to store.
+*
+* `{ views: 5 }` says what the number becomes; `{ views: { $inc: 1 } }` says
+* what happens to it. The difference is the read the caller no longer has to
+* make — and the race that read opens. Two requests that each read `4`, add one
+* and write `5` lose an increment between them; `SET views = views + 1` cannot,
+* because the arithmetic happens inside the statement holding the row lock.
+*
+* Exactly one operator per field. `{ views: { $inc: 1, $push: "x" } }` is
+* refused rather than applied in an order the caller cannot see.
+*
+* @group Data
+*/
+/**
+* The operator names, as a value.
+*
+* A runtime list beside the type because three layers have to *recognise* an
+* operation, not just accept one: the REST validator, the driver that compiles
+* it, and the offline queue that must refuse to apply one locally. Three copies
+* of four strings is three chances for one of them to miss an operator added to
+* the other two, and the failure is silent in the worst direction — an
+* unrecognised marker is written to the column as a JSON document.
+*
+* @group Data
+*/
+var FIELD_OPERATORS = [
+	"$inc",
+	"$push",
+	"$pull",
+	"$merge"
+];
+/**
+* The key of a {@link BatchRef}. Declared here, beside the field operators,
+* because the two share one namespace: a `$`-prefixed key in a write payload is
+* a marker, and every reader of that namespace has to know all of it.
+*
+* @group Data
+*/
+var BATCH_REF_KEY = "$ref";
+/**
+* Whether a value is *trying* to be a field operation — including a misspelled
+* one, which is the case worth catching.
+*
+* Any `$`-prefixed key counts, because `{ $increment: 1 }` written to a number
+* column as a JSON document is the failure this exists to prevent. No collection
+* can declare a column whose value legitimately has a key beginning with `$`: a
+* `map` property's sub-keys are declared, and `$` is not valid in the
+* identifiers the DDL generators emit.
+*
+* The one exception is `{ $ref: … }`, the batch's backward reference. It stands
+* where a *value* goes and is resolved to one before the row is written, so it
+* is not an operation on a column — reading it as a misspelled operator refused
+* every `$ref` in a batch with "unknown field operator '$ref'".
+*
+* @group Data
+*/
+function isFieldOperation(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Date) return false;
+	const keys = Object.keys(value);
+	if (keys.length === 1 && keys[0] === "$ref") return false;
+	return keys.some((key) => key.startsWith("$"));
+}
+/** True when any value in a write payload is (or is attempting to be) one. @group Data */
+function hasFieldOperation(values) {
+	return !!values && Object.values(values).some(isFieldOperation);
+}
+//#endregion
 //#region src/controllers/data_driver.ts
 /** Rows returned for a plain / text-search list read when the client sends no `limit`. */
 var DEFAULT_LIST_LIMIT = 50;
@@ -2255,6 +2415,6 @@ function isPublicStoragePath(path) {
 	return p.startsWith("public/") || p.startsWith(`default/public/`);
 }
 //#endregion
-export { ADMIN_COLLECTION_KEYS, ADMIN_PROPERTY_KEYS, ALL_WHERE_FILTER_OPS, ANONYMOUS_USER_ID, ANONYMOUS_USER_IDS, BUNDLE_FORMAT_VERSION, CANONICAL_TO_REST, DEFAULT_CAPABILITIES, DEFAULT_COMMIT_PATHS, DEFAULT_DATA_SOURCE_KEY, DEFAULT_FILTERABLE_RELATION_KINDS, DEFAULT_FUZZY_THRESHOLD, DEFAULT_LIST_LIMIT, DEFAULT_RESOURCE_KEY, DEFAULT_SEARCH_COLUMN, DEFAULT_SEARCH_LANGUAGE, DEFAULT_SEARCH_WEIGHT, DEFAULT_STORAGE_SOURCE_KEY, DEFAULT_VECTOR_LIST_LIMIT, EntityReference, EntityRelation, FIREBASE_CAPABILITIES, GeoPoint, LEGACY_RLS_JWT_SQL, LEGACY_RLS_ROLES_SQL, LEGACY_RLS_SCHEMA, LEGACY_RLS_UID_SQL, ListLimitError, MAX_LIST_LIMIT, MONGODB_CAPABILITIES, NULL_OPS, POSTGRES_CAPABILITIES, PUBLIC_STORAGE_PREFIX, REBASE_SCHEMA, RELEVANCE_SORT_FIELD, RESERVED_BACKEND_PREFIXES, RESOURCE_GRAPH_VERSION, REST_TO_CANONICAL, RLS_IS_ANONYMOUS_SQL, RLS_JWT_SQL, RLS_ROLES_SQL, RLS_UID_SQL, RUNTIME_CONTRACT_VERSION, RebaseApiError, RebaseClientError, SCHEMA_VERSION_HEADER, Vector, amendResourceKind, bucket, buildResourceGraph, canonicalSchemaPayload, computeSchemaVersion, database, declareCron, declareFunction, declareResource, declaredDataSources, declaredDatabaseExtensions, declaredQueueConsumers, declaredResources, declaredStorageSources, declaredSubscriptions, deserializeCollections, encodeRelationAggregateSort, envBasesForResource, findEnvSuffixCollision, findStorageSuffixCollision, getCollectionDataPath, getDataSourceCapabilities, getDeclaredSubcollections, hasForeignKeyOnTarget, isAnonymousUid, isBranchAdmin, isChannelBusInstance, isDocumentAdmin, isFirebaseCollectionConfig, isLazyComponentRef, isManyToMany, isMongoDBCollectionConfig, isPostgresCollectionConfig, isPublicStoragePath, isRelationAggregateSort, isRelationalCollectionConfig, isResourceHandle, isSQLAdmin, isSchemaAdmin, isSchemaEditingAdmin, isSerializedCollectionRef, isToMany, isUnsupported, isValidEngine, nestAdminCollectionKeys, nestAdminKeysOf, nestAdminPropertyKeys, parseRelationAggregateSort, policy, queue, registerDataSourceCapabilities, registerResourceKind, reservedPrefixFor, resetDeclaredQueueConsumers, resetDeclaredResources, resetDeclaredSubscriptions, resolveClientListLimit, resolveResourceRefs, resourceEnvSuffix, resourceId, resourceKeyOf, resourceKind, resourceKinds, resourceToDataSource, resourceToStorageSource, rewriteLegacyRlsFunctions, serializeCollections, setQueueRuntime, setTopicRuntime, sortKeyToString, storageEnvSuffix, toCanonicalOp, topic, unsupportedMethod, usesLegacyRlsFunctions };
+export { ADMIN_COLLECTION_KEYS, ADMIN_PROPERTY_KEYS, ALL_WHERE_FILTER_OPS, ANONYMOUS_USER_ID, ANONYMOUS_USER_IDS, BATCH_REF_KEY, BUNDLE_FORMAT_VERSION, CANONICAL_TO_REST, DEFAULT_CAPABILITIES, DEFAULT_COMMIT_PATHS, DEFAULT_DATA_SOURCE_KEY, DEFAULT_FILTERABLE_RELATION_KINDS, DEFAULT_FUZZY_THRESHOLD, DEFAULT_LIST_LIMIT, DEFAULT_RESOURCE_KEY, DEFAULT_SEARCH_COLUMN, DEFAULT_SEARCH_LANGUAGE, DEFAULT_SEARCH_WEIGHT, DEFAULT_STORAGE_SOURCE_KEY, DEFAULT_TENANT_BYPASS_ROLES, DEFAULT_VECTOR_LIST_LIMIT, EntityReference, EntityRelation, FIELD_OPERATORS, FIREBASE_CAPABILITIES, GeoPoint, JUNCTION_PIVOT_KEY, LEGACY_RLS_JWT_SQL, LEGACY_RLS_ROLES_SQL, LEGACY_RLS_SCHEMA, LEGACY_RLS_UID_SQL, LIST_OPS, ListLimitError, MAX_INCLUDE_DEPTH, MAX_LIST_LIMIT, MONGODB_CAPABILITIES, NULL_OPS, POSTGRES_CAPABILITIES, PUBLIC_STORAGE_PREFIX, REBASE_SCHEMA, RELEVANCE_SORT_FIELD, RESERVED_BACKEND_PREFIXES, RESOURCE_GRAPH_VERSION, REST_TO_CANONICAL, RLS_IS_ANONYMOUS_SQL, RLS_JWT_SQL, RLS_ROLES_SQL, RLS_UID_SQL, RUNTIME_CONTRACT_VERSION, RebaseApiError, RebaseClientError, SCHEMA_VERSION_HEADER, Vector, amendResourceKind, bucket, buildResourceGraph, canonicalSchemaPayload, computeSchemaVersion, database, declareCron, declareFunction, declareResource, declaredDataSources, declaredDatabaseExtensions, declaredQueueConsumers, declaredResources, declaredStorageSources, declaredSubscriptions, deserializeCollections, encodeRelationAggregateSort, envBasesForResource, findEnvSuffixCollision, findStorageSuffixCollision, getCollectionDataPath, getDataSourceCapabilities, getDeclaredSubcollections, hasFieldOperation, hasForeignKeyOnTarget, isAnonymousUid, isBranchAdmin, isChannelBusInstance, isDocumentAdmin, isFieldOperation, isFirebaseCollectionConfig, isLazyComponentRef, isManyToMany, isMongoDBCollectionConfig, isPostgresCollectionConfig, isPublicStoragePath, isRelationAggregateSort, isRelationalCollectionConfig, isResourceHandle, isSQLAdmin, isSchemaAdmin, isSchemaEditingAdmin, isSerializedCollectionRef, isTenantClaimSource, isTenantMembershipSource, isToMany, isUnsupported, isValidEngine, nestAdminCollectionKeys, nestAdminKeysOf, nestAdminPropertyKeys, parseRelationAggregateSort, policy, queue, registerDataSourceCapabilities, registerResourceKind, reservedPrefixFor, resetDeclaredQueueConsumers, resetDeclaredResources, resetDeclaredSubscriptions, resolveClientListLimit, resolveResourceRefs, resourceEnvSuffix, resourceId, resourceKeyOf, resourceKind, resourceKinds, resourceToDataSource, resourceToStorageSource, rewriteLegacyRlsFunctions, serializeCollections, setQueueRuntime, setTopicRuntime, sortKeyToString, storageEnvSuffix, toCanonicalOp, topic, unsupportedMethod, usesLegacyRlsFunctions };
 
 //# sourceMappingURL=index.es.js.map