@rebasepro/types 0.7.0 → 0.9.0

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,10 +1,9 @@
 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";
-import type { RebasePlugin } from "../types/plugins";
 /**
  * Options to enable the built-in collection editor.
  * When provided to `<RebaseCMS>`, the editor is auto-wired as a native feature.
@@ -20,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 RebaseCMSConfig<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
@@ -31,7 +30,6 @@ export interface RebaseCMSConfig<EC extends EntityCollection = EntityCollection>
     homePage?: ReactNode;
     entityViews?: EntityCustomView[];
     entityActions?: EntityAction[];
-    plugins?: RebasePlugin[];
     /**
      * Centralized configuration for how collections and views are grouped
      * in the navigation sidebar and home page.
@@ -47,6 +45,19 @@ 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")[];

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";
@@ -122,30 +179,195 @@ var Vector = class {
 	}
 };
 //#endregion
+//#region src/types/filter-operators.ts
+/** Maps canonical operators to their REST short-code equivalents. */
+var CANONICAL_TO_REST = {
+	"==": "eq",
+	"!=": "neq",
+	">": "gt",
+	">=": "gte",
+	"<": "lt",
+	"<=": "lte",
+	"in": "in",
+	"not-in": "nin",
+	"array-contains": "cs",
+	"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 = {
+	"eq": "==",
+	"neq": "!=",
+	"gt": ">",
+	"gte": ">=",
+	"lt": "<",
+	"lte": "<=",
+	"in": "in",
+	"nin": "not-in",
+	"cs": "array-contains",
+	"csa": "array-contains-any",
+	"like": "like",
+	"ilike": "ilike",
+	"nlike": "not-like",
+	"nilike": "not-ilike",
+	"isnull": "is-null",
+	"notnull": "is-not-null"
+};
+/**
+* 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 = [
+	"<",
+	"<=",
+	"==",
+	"!=",
+	">=",
+	">",
+	"in",
+	"not-in",
+	"array-contains",
+	"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.
+*
+* @example
+* toCanonicalOp("==")   // "=="
+* toCanonicalOp("eq")   // "=="
+* toCanonicalOp("cs")   // "array-contains"
+* toCanonicalOp("xyz")  // undefined
+*/
+function toCanonicalOp(op) {
+	if (CANONICAL_OPS.has(op)) return op;
+	return REST_TO_CANONICAL[op];
+}
+//#endregion
 //#region src/types/collections.ts
 /**
 * Type guard for PostgreSQL collections.
-* Returns true if the collection uses the Postgres driver (or the default driver).
+* Returns true if the collection uses the Postgres engine (or the default engine).
 * @group Models
 */
-function isPostgresCollection(collection) {
-	return !collection.driver || collection.driver === "postgres";
+function isPostgresCollectionConfig(collection) {
+	return !collection.engine || collection.engine === "postgres";
 }
 /**
 * Type guard for Firebase / Firestore collections.
 * @group Models
 */
-function isFirebaseCollection(collection) {
-	return collection.driver === "firestore";
+function isFirebaseCollectionConfig(collection) {
+	return collection.engine === "firestore";
 }
 /**
 * Type guard for MongoDB collections.
 * @group Models
 */
-function isMongoDBCollection(collection) {
-	return collection.driver === "mongodb";
+function isMongoDBCollectionConfig(collection) {
+	return collection.engine === "mongodb";
+}
+/**
+* Returns the data path for a collection.
+* For Firestore or MongoDB collections with a `path`, returns that value;
+* otherwise falls back to `slug`.
+*/
+function getCollectionDataPath(collection) {
+	if (isFirebaseCollectionConfig(collection) && collection.path) return collection.path;
+	if (isMongoDBCollectionConfig(collection) && collection.path) return collection.path;
+	return collection.slug;
+}
+/**
+* Reads a collection's driver-declared subcollections thunk (the `subcollections`
+* field) independent of engine identity, so engine-agnostic code doesn't have to
+* type-guard against a specific driver. Returns `undefined` when the collection
+* declares none.
+*
+* Pair with `getDataSourceCapabilities(engine).supportsSubcollections` to decide
+* whether the engine honours subcollections at all before reading them.
+* @group Models
+*/
+function getDeclaredSubcollections(collection) {
+	return collection.subcollections;
 }
 //#endregion
+//#region src/types/policy.ts
+/** @group Models */
+var policy = {
+	true: () => ({ kind: "true" }),
+	false: () => ({ kind: "false" }),
+	and: (...operands) => ({
+		kind: "and",
+		operands
+	}),
+	or: (...operands) => ({
+		kind: "or",
+		operands
+	}),
+	not: (operand) => ({
+		kind: "not",
+		operand
+	}),
+	compare: (left, op, right) => ({
+		kind: "compare",
+		op,
+		left,
+		right
+	}),
+	rolesOverlap: (roles) => ({
+		kind: "rolesOverlap",
+		roles
+	}),
+	rolesContain: (roles) => ({
+		kind: "rolesContain",
+		roles
+	}),
+	authenticated: () => ({ kind: "authenticated" }),
+	existsIn: (args) => ({
+		kind: "existsIn",
+		collection: args.collection,
+		where: args.where
+	}),
+	raw: (sql) => ({
+		kind: "raw",
+		sql
+	}),
+	field: (name) => ({
+		kind: "field",
+		name
+	}),
+	outerField: (name) => ({
+		kind: "outerField",
+		name
+	}),
+	literal: (value) => ({
+		kind: "literal",
+		value
+	}),
+	authUid: () => ({ kind: "authUid" }),
+	authRoles: () => ({ kind: "authRoles" })
+};
+//#endregion
 //#region src/types/backend.ts
 /**
 * Type guard: does this admin support SQL operations?
@@ -194,6 +416,7 @@ var POSTGRES_CAPABILITIES = {
 	supportsReferences: false,
 	supportsColumnTypes: true,
 	supportsRealtime: true,
+	filterOperators: ALL_WHERE_FILTER_OPS,
 	supportsSQLAdmin: true,
 	supportsDocumentAdmin: false,
 	supportsSchemaAdmin: true
@@ -208,6 +431,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
@@ -222,6 +446,7 @@ var MONGODB_CAPABILITIES = {
 	supportsReferences: true,
 	supportsColumnTypes: false,
 	supportsRealtime: false,
+	filterOperators: ALL_WHERE_FILTER_OPS,
 	supportsSQLAdmin: false,
 	supportsDocumentAdmin: true,
 	supportsSchemaAdmin: true
@@ -240,6 +465,7 @@ var DEFAULT_CAPABILITIES = {
 	supportsReferences: true,
 	supportsColumnTypes: true,
 	supportsRealtime: true,
+	filterOperators: ALL_WHERE_FILTER_OPS,
 	supportsSQLAdmin: true,
 	supportsDocumentAdmin: true,
 	supportsSchemaAdmin: true
@@ -251,13 +477,13 @@ var CAPABILITIES_REGISTRY = {
 	"(default)": DEFAULT_CAPABILITIES
 };
 /**
-* Look up capabilities for a given driver key.
-* If `driver` is undefined or not found, returns `DEFAULT_CAPABILITIES`.
+* Look up capabilities for a given engine key.
+* If `engine` is undefined or not found, returns `DEFAULT_CAPABILITIES`.
 * @group Models
 */
-function getDataSourceCapabilities(driver) {
-	if (!driver) return POSTGRES_CAPABILITIES;
-	return CAPABILITIES_REGISTRY[driver] ?? DEFAULT_CAPABILITIES;
+function getDataSourceCapabilities(engine) {
+	if (!engine) return POSTGRES_CAPABILITIES;
+	return CAPABILITIES_REGISTRY[engine] ?? DEFAULT_CAPABILITIES;
 }
 /**
 * Register custom capabilities for a third-party driver.
@@ -267,6 +493,27 @@ function registerDataSourceCapabilities(capabilities) {
 	CAPABILITIES_REGISTRY[capabilities.key] = capabilities;
 }
 //#endregion
+//#region src/types/storage_source.ts
+/**
+* Describes a named storage backend — a place files live.
+*
+* Declared once and shared front + back: the frontend uses it to decide
+* transport (HTTP proxy vs direct SDK), the backend uses the same `key`
+* to resolve a StorageController, and collection properties reference
+* a definition by its `key` via `StorageConfig.storageSource`.
+*
+* This mirrors the {@link DataSourceDefinition} pattern used for databases.
+*
+* @group Models
+*/
+/**
+* The default storage source key, used when a property does not specify
+* a `storageSource`. Shared by the frontend and backend registries so
+* both agree on "the default storage backend".
+* @group Models
+*/
+var DEFAULT_STORAGE_SOURCE_KEY = "(default)";
+//#endregion
 //#region src/types/component_ref.ts
 /**
 * Type guard: checks if a value is a `LazyComponentRef` produced by the
@@ -276,6 +523,33 @@ function isLazyComponentRef(ref) {
 	return typeof ref === "object" && ref !== null && "__rebaseLazy" in ref && ref.__rebaseLazy === true;
 }
 //#endregion
-export { DEFAULT_CAPABILITIES, DEFAULT_DATA_SOURCE_KEY, EntityReference, EntityRelation, FIREBASE_CAPABILITIES, GeoPoint, MONGODB_CAPABILITIES, POSTGRES_CAPABILITIES, Vector, getDataSourceCapabilities, isBranchAdmin, isDocumentAdmin, isFirebaseCollection, isLazyComponentRef, isMongoDBCollection, isPostgresCollection, isSQLAdmin, isSchemaAdmin, registerDataSourceCapabilities };
+//#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, 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