@rebasepro/types 0.8.0 → 0.9.1-canary.09aaf62

package/dist/controllers/email.d.ts

@@ -1,7 +1,7 @@
 /**
- * Email service types — portable interface shared by RebaseClient and server-core.
+ * Email service types — portable interface shared by RebaseClient and server.
  *
- * The concrete SMTP implementation lives in `@rebasepro/server-core/email`.
+ * The concrete SMTP implementation lives in `@rebasepro/server/email`.
  * This file provides only the consumer-facing contract so that it can be
  * referenced from `RebaseClient` without dragging in nodemailer.
  */

package/dist/controllers/index.d.ts

@@ -11,7 +11,7 @@ export * from "./storage";
 export * from "./email";
 export * from "./client";
 export * from "./customization_controller";
-export * from "./side_entity_controller";
+export * from "./side_panel_controller";
 export * from "./side_dialogs_controller";
 export * from "./dialogs_controller";
 export * from "./snackbar";

package/dist/controllers/local_config_persistence.d.ts

@@ -1,16 +1,16 @@
-import type { EntityCollection } from "../types/collections";
+import type { CollectionConfig } from "../types/collections";
 /**
  * @group Models
  */
-export type PartialEntityCollection<M extends Record<string, unknown> = Record<string, unknown>> = Partial<EntityCollection<M>>;
+export type PartialCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>> = Partial<CollectionConfig<M>>;
 /**
  * This interface is in charge of defining the controller that persists
  * modifications to a collection or collection, and retrieves them back from
  * a data source, such as local storage or Firestore.
  */
 export interface UserConfigurationPersistence {
-    onCollectionModified: <M extends Record<string, unknown> = Record<string, unknown>>(path: string, partialCollection: PartialEntityCollection<M>) => void;
-    getCollectionConfig: <M extends Record<string, unknown> = Record<string, unknown>>(path: string) => PartialEntityCollection<M>;
+    onCollectionModified: <M extends Record<string, unknown> = Record<string, unknown>>(path: string, partialCollection: PartialCollectionConfig<M>) => void;
+    getCollectionConfig: <M extends Record<string, unknown> = Record<string, unknown>>(path: string) => PartialCollectionConfig<M>;
     recentlyVisitedPaths: string[];
     setRecentlyVisitedPaths: (paths: string[]) => void;
     favouritePaths: string[];

package/dist/controllers/navigation.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import type { EntityCollection } from "../types/collections";
+import type { CollectionConfig } from "../types/collections";
 /**
  * Controller that handles URL path building and resolution.
  * @group Models
@@ -212,7 +212,7 @@ export interface NavigationEntry {
     name: string;
     slug: string;
     type: "collection" | "view" | "admin";
-    collection?: EntityCollection;
+    collection?: CollectionConfig;
     view?: AppView;
     description?: string;
     group: string;

package/dist/controllers/registry.d.ts

@@ -1,12 +1,12 @@
 import { ReactNode } from "react";
-import type { EntityCollection } from "../types/collections";
-import type { EntityCollectionsBuilder, AppViewsBuilder } from "../types/builders";
+import type { CollectionConfig } from "../types/collections";
+import type { CollectionConfigsBuilder, AppViewsBuilder } from "../types/builders";
 import type { EntityCustomView } from "../types/entity_views";
 import type { EntityAction } from "../types/entity_actions";
 import type { AppView, NavigationGroupMapping } from "./navigation";
 /**
  * Options to enable the built-in collection editor.
- * When provided to `<RebaseCMS>`, the editor is auto-wired as a native feature.
+ * When provided to `<RebaseAdmin>`, the editor is auto-wired as a native feature.
  */
 export interface CollectionEditorOptions {
     /**
@@ -19,8 +19,8 @@ export interface CollectionEditorOptions {
     /** Suggested base paths shown when creating new collections. */
     pathSuggestions?: string[];
 }
-export interface RebaseCMSConfig<EC extends EntityCollection = EntityCollection> {
-    collections?: EC[] | EntityCollectionsBuilder<EC>;
+export interface RebaseAdminConfig<EC extends CollectionConfig = CollectionConfig> {
+    collections?: EC[] | CollectionConfigsBuilder<EC>;
     /**
      * Custom top-level views added to the main navigation.
      * Accepts a static array of views or an async builder function
@@ -45,9 +45,22 @@ export interface RebaseCMSConfig<EC extends EntityCollection = EntityCollection>
      * are all auto-wired — no plugin or manual view injection needed.
      */
     collectionEditor?: boolean | CollectionEditorOptions;
+    /**
+     * URL path prefix the admin is mounted under, when it does not live at the
+     * site root. Set this when the admin is rendered inside a path-prefixed
+     * route (e.g. `<Route path="/admin/*">`) so URL⇄collection resolution
+     * accounts for the prefix — otherwise the current path won't be recognized
+     * as a collection path and views hang on a spinner with no data fetch.
+     *
+     * Do NOT set this when mounting via a react-router `basename` — react-router
+     * already strips the prefix from the location, so the default (`/`) is correct.
+     *
+     * @default "/"
+     */
+    basePath?: string;
 }
 export interface RebaseStudioConfig {
-    tools?: ("sql" | "js" | "rls" | "schema" | "storage" | "cron" | "schema-visualizer" | "branches" | "api" | "logs" | "api-keys")[];
+    tools?: ("sql" | "js" | "rls" | "schema" | "storage" | "cron" | "schema-visualizer" | "branches" | "backups" | "api" | "logs" | "api-keys")[];
     homePage?: ReactNode;
     devViews?: AppView[];
 }
@@ -55,10 +68,10 @@ export interface RebaseAuthConfig {
     loginView?: ReactNode;
 }
 export interface RebaseRegistryController {
-    cmsConfig: RebaseCMSConfig | null;
+    cmsConfig: RebaseAdminConfig | null;
     studioConfig: RebaseStudioConfig | null;
     authConfig: RebaseAuthConfig | null;
-    registerCMS: (config: RebaseCMSConfig) => void;
+    registerCMS: (config: RebaseAdminConfig) => void;
     unregisterCMS: () => void;
     registerStudio: (config: RebaseStudioConfig) => void;
     unregisterStudio: () => void;

package/dist/controllers/{side_entity_controller.d.ts → side_panel_controller.d.ts}

@@ -1,10 +1,10 @@
 import type { Entity } from "../types/entities";
-import type { EntityCollection } from "../types/collections";
+import type { CollectionConfig } from "../types/collections";
 /**
  * Props used to open a side dialog
  * @group Hooks and utilities
  */
-export interface EntitySidePanelProps<M extends Record<string, unknown> = Record<string, unknown>> {
+export interface SidePanelBindingProps<M extends Record<string, unknown> = Record<string, unknown>> {
     /**
      * Absolute path of the entity
      */
@@ -31,7 +31,7 @@ export interface EntitySidePanelProps<M extends Record<string, unknown> = Record
      * Collection representing the entities of this view.
      * If you leave it blank it will be induced by your navigation
      */
-    collection?: EntityCollection<M>;
+    collection?: CollectionConfig<M>;
     /**
      * Should update the URL when opening the dialog.
      * Consider that if the collection that you provide is not defined in the base
@@ -74,7 +74,7 @@ export interface EntitySidePanelProps<M extends Record<string, unknown> = Record
  * Controller to open the side dialog displaying entity forms
  * @group Hooks and utilities
  */
-export interface SideEntityController {
+export interface SidePanelController {
     /**
      * Close the last panel
      */
@@ -84,14 +84,14 @@ export interface SideEntityController {
      * of the view is fetched from the collections you have specified in the
      * navigation.
      * At least you need to pass the path of the entity you would like
-     * to edit. You can set an entityId if you would like to edit and existing one
+     * to edit. You can set a entityId if you would like to edit and existing one
      * (or a new one with that id).
      * @param props
      */
-    open: <M extends Record<string, unknown> = Record<string, unknown>>(props: EntitySidePanelProps<M>) => void;
+    open: <M extends Record<string, unknown> = Record<string, unknown>>(props: SidePanelBindingProps<M>) => void;
     /**
      * Replace the last open entity panel with the given one.
      * @param props
      */
-    replace: <M extends Record<string, unknown> = Record<string, unknown>>(props: EntitySidePanelProps<M>) => void;
+    replace: <M extends Record<string, unknown> = Record<string, unknown>>(props: SidePanelBindingProps<M>) => void;
 }

package/dist/controllers/storage.d.ts

@@ -1,3 +1,20 @@
+/**
+ * Path prefix that marks an object as **public**. Files stored under this
+ * prefix are served without any auth token via a stable, permanent,
+ * CDN-cacheable URL (see {@link StorageSource.getSignedUrl}). Shared by the
+ * client SDK and the backend so both agree on which objects are public.
+ *
+ * @group Models
+ */
+export declare const PUBLIC_STORAGE_PREFIX = "public/";
+/**
+ * True when a storage key/path points at a public object (lives under
+ * {@link PUBLIC_STORAGE_PREFIX}). The check is applied to the key *within the
+ * bucket* — strip any `bucket/` and `scheme://` prefixes first.
+ *
+ * @group Models
+ */
+export declare function isPublicStoragePath(path: string | null | undefined): boolean;
 /**
  * @group Models
  */
@@ -6,6 +23,13 @@ export interface UploadFileProps {
     key: string;
     metadata?: Record<string, unknown>;
     bucket?: string;
+    /**
+     * Store this object as **public**: it is placed under
+     * {@link PUBLIC_STORAGE_PREFIX} and served via a stable, token-less,
+     * permanent URL (safe to persist in a database and cache on a CDN).
+     * Defaults to `false` (private, short-lived signed URLs).
+     */
+    public?: boolean;
 }
 /**
  * @group Models
@@ -67,6 +91,21 @@ export declare interface DownloadMetadata {
      */
     contentType: string;
     customMetadata: Record<string, unknown>;
+    /**
+     * Optional short-lived download token (for local/server-mediated storage).
+     * Absent for public objects, which need no token.
+     */
+    token?: string;
+    /**
+     * Optional remaining lifetime of the token, in seconds.
+     */
+    tokenExpiresIn?: number;
+    /**
+     * True when this object is public: it is served without a token via a
+     * stable, permanent, CDN-cacheable URL. When set, the client builds a
+     * token-less URL and caches it indefinitely.
+     */
+    public?: boolean;
 }
 /**
  * @group Models

package/dist/errors.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Structured initializer for {@link RebaseApiError}.
+ *
+ * @group Errors
+ */
+export interface RebaseErrorInit {
+    /**
+     * HTTP status code, when the error originated from an HTTP response.
+     * Left `undefined` for realtime/WebSocket, network, and client-side
+     * logic errors that have no HTTP status.
+     */
+    status?: number;
+    /** Stable, machine-readable error code (e.g. `"NOT_FOUND"`, `"BAD_REQUEST"`). */
+    code?: string;
+    /** Structured error payload returned by the server, when present. */
+    details?: unknown;
+    /** The underlying error this one wraps, if any. */
+    cause?: unknown;
+}
+/**
+ * The single error type thrown across the entire Rebase client surface —
+ * HTTP data/control-plane calls, realtime/WebSocket operations, and
+ * client-side logic errors (e.g. an unknown collection accessor). A `catch`
+ * block only ever needs to check for this one class:
+ *
+ * ```ts
+ * import { RebaseApiError } from "@rebasepro/client"; // re-exported
+ *
+ * try {
+ *   await client.data.products.update(id, { price: 9 });
+ * } catch (e) {
+ *   if (e instanceof RebaseApiError) {
+ *     if (e.status === 404) { ... }   // HTTP failures carry a status
+ *     console.error(e.code, e.details);
+ *   }
+ * }
+ * ```
+ *
+ * `status` is present for HTTP failures and `undefined` otherwise, so its
+ * presence distinguishes transport-level errors from realtime/logic errors.
+ *
+ * @group Errors
+ */
+export declare class RebaseApiError extends Error {
+    /** HTTP status code, or `undefined` for non-HTTP errors. */
+    readonly status?: number;
+    /** Stable machine-readable error code, when the server supplied one. */
+    readonly code?: string;
+    /** Structured error payload from the server, when present. */
+    readonly details?: unknown;
+    constructor(message: string, init?: RebaseErrorInit);
+}
+/**
+ * Client-side logic error — raised before any request is made (e.g. accessing
+ * an unknown collection accessor when a typed dictionary is configured).
+ *
+ * A subclass of {@link RebaseApiError} (with no `status`), so a single
+ * `catch (e) { if (e instanceof RebaseApiError) ... }` handles it too.
+ *
+ * @group Errors
+ */
+export declare class RebaseClientError extends RebaseApiError {
+    constructor(message: string);
+}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./errors";
 export * from "./rebase_context";
 export * from "./types";
 export * from "./controllers";

package/dist/index.es.js

@@ -1,6 +1,63 @@
+//#region src/errors.ts
+/**
+* The single error type thrown across the entire Rebase client surface —
+* HTTP data/control-plane calls, realtime/WebSocket operations, and
+* client-side logic errors (e.g. an unknown collection accessor). A `catch`
+* block only ever needs to check for this one class:
+*
+* ```ts
+* import { RebaseApiError } from "@rebasepro/client"; // re-exported
+*
+* try {
+*   await client.data.products.update(id, { price: 9 });
+* } catch (e) {
+*   if (e instanceof RebaseApiError) {
+*     if (e.status === 404) { ... }   // HTTP failures carry a status
+*     console.error(e.code, e.details);
+*   }
+* }
+* ```
+*
+* `status` is present for HTTP failures and `undefined` otherwise, so its
+* presence distinguishes transport-level errors from realtime/logic errors.
+*
+* @group Errors
+*/
+var RebaseApiError = class extends Error {
+	/** HTTP status code, or `undefined` for non-HTTP errors. */
+	status;
+	/** Stable machine-readable error code, when the server supplied one. */
+	code;
+	/** Structured error payload from the server, when present. */
+	details;
+	constructor(message, init = {}) {
+		super(message);
+		this.name = "RebaseApiError";
+		this.status = init.status;
+		this.code = init.code;
+		this.details = init.details;
+		if (init.cause !== void 0) this.cause = init.cause;
+	}
+};
+/**
+* Client-side logic error — raised before any request is made (e.g. accessing
+* an unknown collection accessor when a typed dictionary is configured).
+*
+* A subclass of {@link RebaseApiError} (with no `status`), so a single
+* `catch (e) { if (e instanceof RebaseApiError) ... }` handles it too.
+*
+* @group Errors
+*/
+var RebaseClientError = class extends RebaseApiError {
+	constructor(message) {
+		super(message);
+		this.name = "RebaseClientError";
+	}
+};
+//#endregion
 //#region src/types/entities.ts
 /**
-* Class used to create a reference to an entity in a different path.
+* Class used to create a reference to a entity in a different path.
 *
 * @example
 * // Simple reference (most common case - single driver, single db)
@@ -34,7 +91,7 @@ var EntityReference = class {
 	*/
 	databaseId;
 	/**
-	* Create a reference to an entity.
+	* Create a reference to a entity.
 	*
 	* @example
 	* // Simple reference (most common case)
@@ -68,7 +125,7 @@ var EntityReference = class {
 	}
 };
 /**
-* Class used to create a reference to an entity in a different path
+* Class used to create a reference to a entity in a different path
 */
 var EntityRelation = class {
 	__type = "relation";
@@ -134,7 +191,13 @@ var CANONICAL_TO_REST = {
 	"in": "in",
 	"not-in": "nin",
 	"array-contains": "cs",
-	"array-contains-any": "csa"
+	"array-contains-any": "csa",
+	"like": "like",
+	"ilike": "ilike",
+	"not-like": "nlike",
+	"not-ilike": "nilike",
+	"is-null": "isnull",
+	"is-not-null": "notnull"
 };
 /** Maps REST short-code operators to their canonical equivalents. */
 var REST_TO_CANONICAL = {
@@ -147,10 +210,26 @@ var REST_TO_CANONICAL = {
 	"in": "in",
 	"nin": "not-in",
 	"cs": "array-contains",
-	"csa": "array-contains-any"
+	"csa": "array-contains-any",
+	"like": "like",
+	"ilike": "ilike",
+	"nlike": "not-like",
+	"nilike": "not-ilike",
+	"isnull": "is-null",
+	"notnull": "is-not-null"
 };
-/** All canonical operator strings for runtime validation. */
-var CANONICAL_OPS = new Set([
+/**
+* Operators that test for null/not-null and therefore ignore their value.
+* Codecs normalize the value of these conditions to `null`.
+*/
+var NULL_OPS = new Set(["is-null", "is-not-null"]);
+/**
+* Every canonical operator, in a stable order. Useful for engine capability
+* declarations ({@link DataSourceCapabilities.filterOperators}) and for
+* building operator subsets.
+* @group Models
+*/
+var ALL_WHERE_FILTER_OPS = [
 	"<",
 	"<=",
 	"==",
@@ -160,8 +239,16 @@ var CANONICAL_OPS = new Set([
 	"in",
 	"not-in",
 	"array-contains",
-	"array-contains-any"
-]);
+	"array-contains-any",
+	"like",
+	"ilike",
+	"not-like",
+	"not-ilike",
+	"is-null",
+	"is-not-null"
+];
+/** All canonical operator strings for runtime validation. */
+var CANONICAL_OPS = new Set(ALL_WHERE_FILTER_OPS);
 /**
 * Resolve any operator string (canonical or REST short-code) to its
 * canonical `WhereFilterOp` form. Returns `undefined` for unknown operators.
@@ -183,21 +270,21 @@ function toCanonicalOp(op) {
 * Returns true if the collection uses the Postgres engine (or the default engine).
 * @group Models
 */
-function isPostgresCollection(collection) {
+function isPostgresCollectionConfig(collection) {
 	return !collection.engine || collection.engine === "postgres";
 }
 /**
 * Type guard for Firebase / Firestore collections.
 * @group Models
 */
-function isFirebaseCollection(collection) {
+function isFirebaseCollectionConfig(collection) {
 	return collection.engine === "firestore";
 }
 /**
 * Type guard for MongoDB collections.
 * @group Models
 */
-function isMongoDBCollection(collection) {
+function isMongoDBCollectionConfig(collection) {
 	return collection.engine === "mongodb";
 }
 /**
@@ -206,8 +293,8 @@ function isMongoDBCollection(collection) {
 * otherwise falls back to `slug`.
 */
 function getCollectionDataPath(collection) {
-	if (isFirebaseCollection(collection) && collection.path) return collection.path;
-	if (isMongoDBCollection(collection) && collection.path) return collection.path;
+	if (isFirebaseCollectionConfig(collection) && collection.path) return collection.path;
+	if (isMongoDBCollectionConfig(collection) && collection.path) return collection.path;
 	return collection.slug;
 }
 /**
@@ -225,6 +312,23 @@ function getDeclaredSubcollections(collection) {
 }
 //#endregion
 //#region src/types/policy.ts
+/**
+* The id a request without a logged-in user reports as `auth.uid()`.
+*
+* A user-context request always sets `app.user_id`: blank would read back as
+* `NULL`, and `NULL` is how the trusted server context is recognised, so an
+* anonymous visitor would be promoted to server privileges. The driver
+* therefore substitutes this sentinel at the single chokepoint where the GUC
+* is set.
+*
+* The consequence for policy authors is that **`auth.uid() IS NOT NULL` is a
+* tautology on the user path** — it is true for anonymous visitors too. Use
+* {@link policy.authenticated} (or `auth.uid() <> 'anonymous'`) to mean "signed
+* in", and {@link policy.serverContext} to mean "the trusted server context".
+*
+* @group Models
+*/
+var ANONYMOUS_USER_ID = "anonymous";
 /** @group Models */
 var policy = {
 	true: () => ({ kind: "true" }),
@@ -256,6 +360,12 @@ var policy = {
 		roles
 	}),
 	authenticated: () => ({ kind: "authenticated" }),
+	serverContext: () => ({ kind: "serverContext" }),
+	existsIn: (args) => ({
+		kind: "existsIn",
+		collection: args.collection,
+		where: args.where
+	}),
 	raw: (sql) => ({
 		kind: "raw",
 		sql
@@ -264,6 +374,10 @@ var policy = {
 		kind: "field",
 		name
 	}),
+	outerField: (name) => ({
+		kind: "outerField",
+		name
+	}),
 	literal: (value) => ({
 		kind: "literal",
 		value
@@ -320,6 +434,7 @@ var POSTGRES_CAPABILITIES = {
 	supportsReferences: false,
 	supportsColumnTypes: true,
 	supportsRealtime: true,
+	filterOperators: ALL_WHERE_FILTER_OPS,
 	supportsSQLAdmin: true,
 	supportsDocumentAdmin: false,
 	supportsSchemaAdmin: true
@@ -334,6 +449,7 @@ var FIREBASE_CAPABILITIES = {
 	supportsReferences: true,
 	supportsColumnTypes: false,
 	supportsRealtime: true,
+	filterOperators: ALL_WHERE_FILTER_OPS.filter((op) => op !== "like" && op !== "ilike" && op !== "not-like" && op !== "not-ilike"),
 	supportsSQLAdmin: false,
 	supportsDocumentAdmin: false,
 	supportsSchemaAdmin: false
@@ -348,6 +464,7 @@ var MONGODB_CAPABILITIES = {
 	supportsReferences: true,
 	supportsColumnTypes: false,
 	supportsRealtime: false,
+	filterOperators: ALL_WHERE_FILTER_OPS,
 	supportsSQLAdmin: false,
 	supportsDocumentAdmin: true,
 	supportsSchemaAdmin: true
@@ -366,6 +483,7 @@ var DEFAULT_CAPABILITIES = {
 	supportsReferences: true,
 	supportsColumnTypes: true,
 	supportsRealtime: true,
+	filterOperators: ALL_WHERE_FILTER_OPS,
 	supportsSQLAdmin: true,
 	supportsDocumentAdmin: true,
 	supportsSchemaAdmin: true
@@ -423,6 +541,33 @@ function isLazyComponentRef(ref) {
 	return typeof ref === "object" && ref !== null && "__rebaseLazy" in ref && ref.__rebaseLazy === true;
 }
 //#endregion
-export { CANONICAL_TO_REST, DEFAULT_CAPABILITIES, DEFAULT_DATA_SOURCE_KEY, DEFAULT_STORAGE_SOURCE_KEY, EntityReference, EntityRelation, FIREBASE_CAPABILITIES, GeoPoint, MONGODB_CAPABILITIES, POSTGRES_CAPABILITIES, REST_TO_CANONICAL, Vector, getCollectionDataPath, getDataSourceCapabilities, getDeclaredSubcollections, isBranchAdmin, isDocumentAdmin, isFirebaseCollection, isLazyComponentRef, isMongoDBCollection, isPostgresCollection, isSQLAdmin, isSchemaAdmin, policy, registerDataSourceCapabilities, toCanonicalOp };
+//#region src/controllers/storage.ts
+/**
+* Path prefix that marks an object as **public**. Files stored under this
+* prefix are served without any auth token via a stable, permanent,
+* CDN-cacheable URL (see {@link StorageSource.getSignedUrl}). Shared by the
+* client SDK and the backend so both agree on which objects are public.
+*
+* @group Models
+*/
+var PUBLIC_STORAGE_PREFIX = "public/";
+/**
+* True when a storage key/path points at a public object (lives under
+* {@link PUBLIC_STORAGE_PREFIX}). The check is applied to the key *within the
+* bucket* — strip any `bucket/` and `scheme://` prefixes first.
+*
+* @group Models
+*/
+function isPublicStoragePath(path) {
+	if (!path) return false;
+	let p = path;
+	const scheme = p.indexOf("://");
+	if (scheme !== -1) p = p.substring(scheme + 3);
+	p = p.replace(/^\/+/, "");
+	if (p.split("/").some((seg) => seg === "..")) return false;
+	return p.startsWith("public/") || p.startsWith(`default/public/`);
+}
+//#endregion
+export { ALL_WHERE_FILTER_OPS, ANONYMOUS_USER_ID, CANONICAL_TO_REST, DEFAULT_CAPABILITIES, DEFAULT_DATA_SOURCE_KEY, DEFAULT_STORAGE_SOURCE_KEY, EntityReference, EntityRelation, FIREBASE_CAPABILITIES, GeoPoint, MONGODB_CAPABILITIES, NULL_OPS, POSTGRES_CAPABILITIES, PUBLIC_STORAGE_PREFIX, REST_TO_CANONICAL, RebaseApiError, RebaseClientError, Vector, getCollectionDataPath, getDataSourceCapabilities, getDeclaredSubcollections, isBranchAdmin, isDocumentAdmin, isFirebaseCollectionConfig, isLazyComponentRef, isMongoDBCollectionConfig, isPostgresCollectionConfig, isPublicStoragePath, isSQLAdmin, isSchemaAdmin, policy, registerDataSourceCapabilities, toCanonicalOp };
 
 //# sourceMappingURL=index.es.js.map