@rebasepro/admin-types 0.10.1-canary.0

package/dist/controllers/navigation.d.ts

@@ -0,0 +1,225 @@
+import React from "react";
+import type { AdminCollection } from "@rebasepro/admin-types";
+/**
+ * Controller that handles URL path building and resolution.
+ * @group Models
+ */
+export type UrlController = {
+    /**
+     * Default path under the navigation routes of the CMS will be created.
+     * Defaults to '/'. You may want to change this `basepath` to 'admin' for example.
+     */
+    basePath: string;
+    /**
+     * Default path under the collection routes of the CMS will be created.
+     * It defaults to '/c'
+     */
+    baseCollectionPath: string;
+    /**
+     * Convert a URL path to a collection or entity path
+     * `/c/products` => `products`
+     * `/my_cms/c/products/B34SAP8Z` => `products/B34SAP8Z`
+     * `/my_cms/my_view` => `my_view`
+     * @param cmsPath
+     */
+    urlPathToDataPath: (cmsPath: string) => string;
+    /**
+     * Base url path for the home screen
+     */
+    homeUrl: string;
+    /**
+     * Check if a url path belongs to a collection
+     * @param path
+     */
+    isUrlCollectionPath: (urlPath: string) => boolean;
+    /**
+     * Build a URL collection path from a data path
+     * `products` => `/c/products`
+     * `products/B34SAP8Z` => `/c/products/B34SAP8Z`
+     * @param path
+     */
+    buildUrlCollectionPath: (path: string) => string;
+    /**
+     * Build a URL path for the CMS (e.g. for custom views)
+     * @param path
+     */
+    buildAppUrlPath: (path: string) => string;
+    /**
+     * Turn a path with collection ids into a resolved path.
+     * The ids (typically used in urls) will be replaced with relative paths (typically used in database paths)
+     * @param path
+     */
+    resolveDatabasePathsFrom: (path: string) => string;
+    /**
+     * A function to navigate to a specified route or URL.
+     *
+     * @param {string} to - The target route or URL to navigate to.
+     * @param {NavigateOptions} [options] - Optional configuration settings for navigation, such as replace behavior or state data.
+     */
+    navigate: (to: string, options?: NavigateOptions) => void;
+};
+/**
+ * Controller that manages the state of the navigation menu,
+ * including resolved views and top-level grouping.
+ * @group Models
+ */
+export type NavigationStateController = {
+    /**
+     * Custom additional views created by the developer, added to the main
+     * navigation
+     */
+    views?: AppView[];
+    /**
+     * Custom additional views created by the developer, added to the admin
+     * navigation
+     */
+    adminViews?: AppView[];
+    /**
+     * Configuration for the views that should be displayed at the top
+     * level of the navigation (e.g. in the home page or the navigation
+     * drawer)
+     */
+    topLevelNavigation?: NavigationResult;
+    /**
+     * Is the navigation loading (the configuration persistence has not
+     * loaded yet, or a specified navigation builder has not completed)
+     */
+    loading: boolean;
+    /**
+     * Was there an error while loading the navigation data
+     */
+    navigationLoadingError?: Error;
+    /**
+     * Call this method to recalculate the navigation
+     */
+    refreshNavigation: () => void;
+};
+export interface NavigateOptions {
+    replace?: boolean;
+    state?: unknown;
+    preventScrollReset?: boolean;
+    relative?: "route" | "path";
+    flushSync?: boolean;
+    viewTransition?: boolean;
+}
+/**
+ * Custom additional views created by the developer, added to the main
+ * navigation.
+ * @group Models
+ */
+export interface AppView {
+    /**
+     * CMS Path you can reach this view from.
+     */
+    slug: string;
+    /**
+     * Name of this view
+     */
+    name: string;
+    /**
+     * Optional description of this view. You can use Markdown
+     */
+    description?: string;
+    /**
+     * Icon key to use in this view.
+     * You can use any of the icons in the Lucide specs:
+     * https://lucide.dev/icons/
+     * e.g. 'ShoppingCart' or 'User'
+     * Find all the icons in https://rebase.pro/docs/icons
+     */
+    icon?: string | React.ReactNode;
+    /**
+     * Should this view be hidden from the main navigation panel.
+     * It will still be accessible if you reach the specified path
+     */
+    hideFromNavigation?: boolean;
+    /**
+     * Navigation group for this view.
+     * Views sharing the same group name will be visually grouped
+     * together in the drawer and home page. If not set, the view
+     * falls into the default "Views" group.
+     */
+    group?: string;
+    /**
+     * Component to be rendered. This can be any React component, and can use
+     * any of the provided hooks.
+     *
+     * Pass a `ComponentType` to enable lazy rendering — the component will
+     * only be instantiated when the route is visited. This is recommended
+     * for dynamic views generated from database data.
+     */
+    view: React.ReactNode | React.ComponentType;
+    /**
+     * If true, a wildcard route (slug/*) is automatically registered
+     * alongside the base route, enabling nested navigation within this view.
+     */
+    nestedRoutes?: boolean;
+    /**
+     * Restrict this view to users with at least one of the listed roles.
+     * When omitted or empty, the view is visible to all authenticated users.
+     * Applied during view resolution — the view is filtered out entirely
+     * (not just hidden from nav) if the user lacks a matching role.
+     */
+    roles?: string[];
+}
+/**
+ * A composable section that can be rendered on the home page.
+ * Use this to add custom content alongside the auto-generated
+ * navigation groups.
+ * @group Models
+ */
+export interface HomePageSection {
+    /**
+     * Unique key for this section.
+     */
+    key: string;
+    /**
+     * Title displayed as the section header.
+     */
+    title: string;
+    /**
+     * Arbitrary React content rendered inside the section.
+     */
+    children: React.ReactNode;
+}
+/**
+ * Used to group navigation entries in the main navigation.
+ */
+export interface NavigationGroupMapping {
+    /**
+     * Name of the group, used to display the group header in the UI
+     */
+    name: string;
+    /**
+     * List of collection ids or view paths that belong to this group.
+     */
+    entries: string[];
+    /**
+     * Configure which groups start collapsed.
+     * Set to `true` to collapse in both drawer and home page,
+     * or use an object to control each independently.
+     *
+     * @defaultValue false (expanded)
+     */
+    collapsedByDefault?: boolean | {
+        drawer?: boolean;
+        home?: boolean;
+    };
+}
+export interface NavigationEntry {
+    id: string;
+    url: string;
+    name: string;
+    slug: string;
+    type: "collection" | "view" | "admin";
+    collection?: AdminCollection;
+    view?: AppView;
+    description?: string;
+    group: string;
+}
+export type NavigationResult = {
+    allowDragAndDrop: boolean;
+    navigationEntries: NavigationEntry[];
+    groups: string[];
+    onNavigationEntriesUpdate: (entries: NavigationGroupMapping[]) => void;
+};

package/dist/controllers/registry.d.ts

@@ -0,0 +1,80 @@
+import { ReactNode } from "react";
+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 { AdminCollection } from "@rebasepro/admin-types";
+/**
+ * Options to enable the built-in collection editor.
+ * When provided to `<RebaseAdmin>`, the editor is auto-wired as a native feature.
+ */
+export interface CollectionEditorOptions {
+    /**
+     * Function that returns an auth token for schema-editor API calls.
+     * Falls back to `authController.getAuthToken` when omitted.
+     */
+    getAuthToken?: () => Promise<string | null>;
+    /** Mark the editor as read-only (disable mutations). */
+    readOnly?: boolean;
+    /** Suggested base paths shown when creating new collections. */
+    pathSuggestions?: string[];
+}
+export interface RebaseAdminConfig<EC extends AdminCollection = AdminCollection> {
+    collections?: EC[] | CollectionConfigsBuilder<EC>;
+    /**
+     * Custom top-level views added to the main navigation.
+     * Accepts a static array of views or an async builder function
+     * that receives the current user/auth context for role-based views.
+     */
+    views?: AppView[] | AppViewsBuilder;
+    homePage?: ReactNode;
+    entityViews?: EntityCustomView[];
+    entityActions?: EntityAction[];
+    /**
+     * Centralized configuration for how collections and views are grouped
+     * in the navigation sidebar and home page.
+     * Each mapping defines a named group and the collection/view slugs
+     * that belong to it. The array order determines group display order.
+     * Entry order within each group determines card order.
+     */
+    navigationGroupMappings?: NavigationGroupMapping[];
+    /**
+     * Enable the built-in visual collection/schema editor.
+     * Pass `true` for zero-config, or an options object for fine-grained control.
+     * When enabled, the editor slots, provider, and Studio schema view
+     * 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" | "backups" | "api" | "logs" | "api-keys")[];
+    homePage?: ReactNode;
+    devViews?: AppView[];
+}
+export interface RebaseAuthConfig {
+    loginView?: ReactNode;
+}
+export interface RebaseRegistryController {
+    cmsConfig: RebaseAdminConfig | null;
+    studioConfig: RebaseStudioConfig | null;
+    authConfig: RebaseAuthConfig | null;
+    registerCMS: (config: RebaseAdminConfig) => void;
+    unregisterCMS: () => void;
+    registerStudio: (config: RebaseStudioConfig) => void;
+    unregisterStudio: () => void;
+    registerAuth: (config: RebaseAuthConfig) => void;
+    unregisterAuth: () => void;
+}

package/dist/controllers/side_dialogs_controller.d.ts

@@ -0,0 +1,67 @@
+import React from "react";
+/**
+ * Controller to open the side dialog
+ * @group Hooks and utilities
+ */
+export interface SideDialogsController {
+    /**
+     * Close the last panel
+     */
+    close: () => void;
+    /**
+     * List of side panels currently open
+     */
+    sidePanels: SideDialogPanelProps[];
+    /**
+     * Override the current side panels
+     * @param panels
+     */
+    setSidePanels: (panels: SideDialogPanelProps[]) => void;
+    /**
+     * Open one or multiple side panels
+     * @param props
+     */
+    open: (panelProps: SideDialogPanelProps | SideDialogPanelProps[]) => void;
+    /**
+     * Replace the last open panel with the given one
+     * @param props
+     */
+    replace: (panelProps: SideDialogPanelProps | SideDialogPanelProps[]) => void;
+}
+/**
+ * Props used to open a side dialog
+ * @group Hooks and utilities
+ */
+export interface SideDialogPanelProps {
+    /**
+     * A key that identifies this panel
+     */
+    key: string;
+    /**
+     * The component type that will be rendered
+     */
+    component: React.ReactNode;
+    /**
+     * Optional width of the panel
+     */
+    width?: string;
+    /**
+     * When open, change the URL to this path.
+     * Note that if you want to restore state from a URL you need to add the
+     * logic yourself by listening to URL updates, and probably call `open`.
+     */
+    urlPath?: string;
+    /**
+     * If the navigation stack is empty (you landed in the `urlPath` url), what
+     * url path to change to when the panel gets closed.
+     */
+    parentUrlPath?: string;
+    /**
+     * Callback when the panel is closed
+     */
+    onClose?: () => void;
+    /**
+     * Use this prop to store additional data in the panel
+     */
+    additional?: unknown;
+}

package/dist/controllers/side_panel_controller.d.ts

@@ -0,0 +1,97 @@
+import type { Entity } from "@rebasepro/types";
+import type { AdminCollection } from "@rebasepro/admin-types";
+/**
+ * Props used to open a side dialog
+ * @group Hooks and utilities
+ */
+export interface SidePanelBindingProps<M extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * Absolute path of the entity
+     */
+    path: string;
+    /**
+     * ID of the entity, if not set, it means we are creating a new entity
+     */
+    entityId?: string | number;
+    /**
+     * Set this flag to true if you want to make a copy of an existing entity
+     */
+    copy?: boolean;
+    /**
+     * Open the entity with a selected sub-collection view. If the panel for this
+     * entity was already open, it is replaced.
+     */
+    selectedTab?: string;
+    /**
+     * Use this prop to override the width of the form view.
+     * e.g. "600px"
+     */
+    width?: number | string;
+    /**
+     * Collection representing the entities of this view.
+     * If you leave it blank it will be induced by your navigation
+     */
+    collection?: AdminCollection<M>;
+    /**
+     * Should update the URL when opening the dialog.
+     * Consider that if the collection that you provide is not defined in the base
+     * config of your `Rebase` component, you will not be able to recreate
+     * the state if copying the URL to a different window.
+     */
+    updateUrl?: boolean;
+    /**
+     * Callback when the entity is updated
+     * @param params
+     */
+    onUpdate?: (params: {
+        entity: Entity<M>;
+    }) => void;
+    /**
+     * Callback when the dialog is closed
+     */
+    onClose?: () => void;
+    /**
+     * Should this panel close when saving
+     */
+    closeOnSave?: boolean;
+    /**
+     * Override some form properties
+     */
+    formProps?: Record<string, unknown>;
+    /**
+     * Allow the user to open the entity fullscreen
+     */
+    allowFullScreen?: boolean;
+    /**
+     * Pre-populate the form with these values when creating a new entity.
+     * Only applied when `entityId` is not set (i.e. the form is in "new" mode).
+     * Useful for actions that fetch data from an external source (e.g. a URL)
+     * and want to pre-fill the document before the user saves.
+     */
+    defaultValues?: Partial<M>;
+}
+/**
+ * Controller to open the side dialog displaying entity forms
+ * @group Hooks and utilities
+ */
+export interface SidePanelController {
+    /**
+     * Close the last panel
+     */
+    close: () => void;
+    /**
+     * Open a new entity sideDialog. By default, the collection and configuration
+     * 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 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: 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: SidePanelBindingProps<M>) => void;
+}

package/dist/controllers/snackbar.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Possible snackbar types
+ * @group Hooks and utilities
+ */
+export type SnackbarMessageType = "success" | "info" | "warning" | "error";
+/**
+ * Controller to display snackbars
+ * @group Hooks and utilities
+ */
+export interface SnackbarController {
+    /**
+     * Close the currently open snackbar
+     */
+    close: () => void;
+    /**
+     * Display a new snackbar. You need to specify the type and message.
+     * You can optionally specify a title
+     */
+    open: (props: {
+        type: SnackbarMessageType;
+        message: React.ReactNode;
+        autoHideDuration?: number;
+    }) => void;
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @rebasepro/admin-types — the React-flavoured half of the Rebase type surface.
+ *
+ * Everything here describes the admin panel: what a collection looks like on
+ * screen, the controllers the panel runs on, the props a custom field or view
+ * receives. It depends on @rebasepro/types and nothing in @rebasepro/types
+ * depends on it, which is what lets a BaaS install exist without React.
+ *
+ * If you are building a backend, you want @rebasepro/types.
+ */
+import "./augment";
+export * from "./types/property_options";
+export * from "./react_component_ref";
+export * from "./collections";
+export * from "./admin_collection";
+export * from "./rebase_context";
+export * from "./types";
+export * from "./controllers";

package/dist/index.es.js

@@ -0,0 +1,92 @@
+import { ADMIN_COLLECTION_KEYS as ADMIN_COLLECTION_KEYS$1 } from "@rebasepro/types";
+//#region src/react_component_ref.ts
+/**
+* The `ComponentLike` contract, as a signature the compiler has to keep true.
+*
+* The split rests on one claim: **every form a React component takes is
+* assignable to `ComponentLike`** — function components, class components,
+* `memo`, `forwardRef`. If that stopped holding, core's `ComponentRef` would
+* quietly begin rejecting real components, and the failure would surface far away
+* in whichever collection file happened to use the broken form.
+*
+* So the claim is not left to a test that someone has to run. This function's
+* parameter and return types state it, and `pnpm typecheck` enforces it on every
+* commit. It is also useful on its own: an explicit widening at the point where
+* an authored component enters a collection config.
+*
+* @example
+* import { MyField } from "./MyField";
+* admin: { Field: asComponentRef(MyField) }
+*/
+function asComponentRef(component) {
+	return component;
+}
+/**
+* The same contract in the other direction: a `ComponentLike` is only renderable
+* once narrowed, and this is the single sanctioned place that narrowing is
+* spelled out. `resolveComponentRef` in `@rebasepro/app` does the runtime half.
+*/
+function asReactComponent(component) {
+	return component;
+}
+//#endregion
+//#region src/admin_collection.ts
+/** Identity at runtime; the overloads above are the whole point. @group Builder */
+function defineCollection(collection) {
+	return collection;
+}
+/**
+* Core's list, re-exported through a `satisfies` clause that is the agreement
+* check: a key core names that is not an option here fails to compile, and
+* `satisfies` keeps the literal tuple type rather than widening it to `string[]`.
+*
+* The reverse direction — an option missing from core's list — has no type-level
+* expression, since there is no exhaustiveness check over an optional-property
+* keyof. `test/admin_collection.test.ts` counts them instead.
+*/
+var ADMIN_COLLECTION_KEYS = ADMIN_COLLECTION_KEYS$1;
+/**
+* Flatten a collection's `admin` block onto it, producing the panel's view model.
+*
+* Shallow by design: the block's fields are independent, so a deep merge would
+* only create opportunities for a nested object to be half from one source and
+* half from the other. `admin` survives on the result.
+*
+* Idempotent — flattening an already-flat collection returns an equivalent one —
+* because the panel resolves collections at more than one entry point (the
+* registry, `<Rebase collections>`, a plugin's `modifyCollection`) and they must
+* not fight over which has run.
+*/
+function resolveAdminCollection(collection) {
+	const block = collection.admin;
+	if (!block) return collection;
+	return {
+		...collection,
+		...block,
+		admin: block
+	};
+}
+/**
+* The inverse: lift flattened admin fields back into the block.
+*
+* Used on the way out — persisting from the collection editor, or handing a
+* collection to anything that expects the authoring shape. Any key in
+* {@link ADMIN_COLLECTION_KEYS} found at the top level is moved down, so a
+* round trip through the panel does not leave the file flat.
+*/
+function toAdminCollectionConfig(collection) {
+	const source = collection;
+	const top = {};
+	const block = { ...source.admin ?? {} };
+	for (const [key, value] of Object.entries(source)) {
+		if (key === "admin") continue;
+		if (ADMIN_COLLECTION_KEYS.includes(key)) block[key] = value;
+		else top[key] = value;
+	}
+	if (Object.keys(block).length > 0) top.admin = block;
+	return top;
+}
+//#endregion
+export { ADMIN_COLLECTION_KEYS, asComponentRef, asReactComponent, defineCollection, resolveAdminCollection, toAdminCollectionConfig };
+
+//# sourceMappingURL=index.es.js.map

package/dist/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","names":[],"sources":["../src/react_component_ref.ts","../src/admin_collection.ts"],"sourcesContent":["import type React from \"react\";\nimport type { ComponentLike, ComponentRef, LazyComponentRef } from \"@rebasepro/types\";\n\n/**\n * `ComponentRef`, narrowed to real React types.\n *\n * Core's {@link ComponentRef} describes a component structurally\n * ({@link ComponentLike}) so that `properties.ts` — and therefore the whole\n * property model the backend reads — can live without React. The trade is that\n * the return type is `unknown`, so a function returning something React cannot\n * render type-checks there.\n *\n * Use this type wherever React genuinely exists: authoring a collection's admin\n * options, and inside the admin packages. Assignments flow into core unchanged,\n * because every member of this union is a member of that one.\n */\nexport type ReactComponentRef<P = any> =\n    | string\n    | LazyComponentRef<P>\n    | (() => Promise<{ default: React.ComponentType<P> }>)\n    | React.ComponentType<P>;\n\n/**\n * The `ComponentLike` contract, as a signature the compiler has to keep true.\n *\n * The split rests on one claim: **every form a React component takes is\n * assignable to `ComponentLike`** — function components, class components,\n * `memo`, `forwardRef`. If that stopped holding, core's `ComponentRef` would\n * quietly begin rejecting real components, and the failure would surface far away\n * in whichever collection file happened to use the broken form.\n *\n * So the claim is not left to a test that someone has to run. This function's\n * parameter and return types state it, and `pnpm typecheck` enforces it on every\n * commit. It is also useful on its own: an explicit widening at the point where\n * an authored component enters a collection config.\n *\n * @example\n * import { MyField } from \"./MyField\";\n * admin: { Field: asComponentRef(MyField) }\n */\nexport function asComponentRef<P>(component: React.ComponentType<P>): ComponentRef<P> {\n    return component;\n}\n\n/**\n * The same contract in the other direction: a `ComponentLike` is only renderable\n * once narrowed, and this is the single sanctioned place that narrowing is\n * spelled out. `resolveComponentRef` in `@rebasepro/app` does the runtime half.\n */\nexport function asReactComponent<P>(component: ComponentLike<P>): React.ComponentType<P> {\n    return component as React.ComponentType<P>;\n}\n","/**\n * The typed admin block, and the type you author a collection against.\n *\n * A collection is one file. Schema, security rules and callbacks sit at the top\n * level, where the backend reads them; everything the admin panel renders sits\n * under `admin`. `@rebasepro/types` does not declare that field at all — naming a\n * kanban column definition would drag `React.ReactNode` back into the BaaS\n * contract, and a server has no use for one. `augment.ts` in this package declares\n * it, by declaration merging, onto core's `CollectionConfig`. So this is the other\n * side of that boundary: the 38 fields, fully typed, in the package where React\n * exists, and reachable only by a program that has opted in.\n *\n * Each field is declared exactly once, here. Core does not carry a React-free\n * skeleton of the same shape; two definitions that agree only by luck is the\n * `WhereFilterOp` mistake, and this block is far bigger than one union.\n */\nimport type React from \"react\";\nimport type {\n    CollectionConfig,\n    ComponentRef,\n    FilterPreset,\n    FilterValues,\n    FirebaseCollectionConfig,\n    FirebaseProperties,\n    InferEntityType,\n    MongoDBCollectionConfig,\n    MongoProperties,\n    OrderByTuple,\n    PostgresCollectionConfig,\n    PostgresProperties,\n    User\n} from \"@rebasepro/types\";\n// A value, not a type: the runtime list core owns.\nimport { ADMIN_COLLECTION_KEYS as CORE_ADMIN_COLLECTION_KEYS } from \"@rebasepro/types\";\n\nimport type {\n    AdditionalFieldDelegate,\n    CollectionActionsProps,\n    CollectionSize,\n    DefaultSelectedViewBuilder,\n    KanbanConfig,\n    SelectionController,\n    ViewMode\n} from \"./collections\";\nimport type { EntityCustomView, FormViewConfig } from \"./types/entity_views\";\nimport type { EntityAction } from \"./types/entity_actions\";\nimport type { ExportConfig } from \"./types/export_import\";\nimport type { CollectionComponentOverrideMap } from \"./types/component_overrides\";\n\n/**\n * Admin-panel presentation and behaviour for a collection.\n *\n * A `type` rather than an `interface`, and that is load-bearing: TypeScript gives\n * an implicit index signature to an object *type alias* but not to an interface.\n * `toAdminCollectionConfig` has to widen a collection carrying this block to\n * `Record<string, unknown>` in order to move the flattened keys back under\n * `admin`, and as an interface that conversion is an error (TS2352, \"index\n * signature for type 'string' is missing\"). Flipping it and running\n * `pnpm typecheck` reproduces that in one line.\n *\n * Declaration merging is not wanted here anyway; a plugin adding fields to the\n * block would have nothing reading them.\n *\n * @group Models\n */\nexport type AdminCollectionOptions<\n    M extends Record<string, unknown> = Record<string, unknown>,\n    USER extends User = User\n> = {\n    /**\n     * Icon for the navigation sidebar or cards.\n     *\n     * Either a Lucide icon name (`\"FileText\"`, `\"ShoppingCart\"`) or a rendered\n     * element. Prefer the name: it survives serialization, so the collection file\n     * stays loadable by the backend and by `rebase generate-sdk`, and it is what\n     * the schema editor writes back.\n     */\n    icon?: string | React.ReactNode;\n\n    /**\n     * Navigation group for this collection.\n     * Collections sharing the same group name will be visually grouped\n     * together in the drawer and home page. If not set, the collection\n     * falls into the default \"Views\" group.\n     */\n    group?: string;\n\n    /**\n     * Array of entity views that this collection has.\n     * Can be an array of `EntityCustomView` or a string representing the key of a global `EntityCustomView`.\n     */\n    entityViews?: (string | EntityCustomView<Record<string, unknown>>)[];\n\n    /**\n     * Default preview properties displayed when this collection is referenced to.\n     */\n    previewProperties?: string[];\n\n    /**\n     * Properties to display as columns in the list view.\n     * If not specified, the list view uses a smart default (Title, Status, Date).\n     */\n    listProperties?: string[];\n\n    /**\n     * Title property of the entity. This is the property that will be used\n     * as the title in entity related views and references.\n     * If not specified, the first property simple text property will be used.\n     */\n    readonly titleProperty?: Extract<keyof M, string> | (string & {});\n\n    /**\n     * When editing a entity, you can choose to open the entity in a side dialog\n     * or in a full screen dialog. Defaults to `full_screen`.\n     */\n    openEntityMode?: \"side_panel\" | \"full_screen\" | \"split\" | \"dialog\";\n\n    /**\n     * Controls what happens when a user clicks on a entity in the collection view.\n     * - `\"edit\"` (default): Opens the entity in the edit form.\n     * - `\"view\"`: Opens a read-only detail view with an \"Edit\" button.\n     */\n    defaultEntityAction?: \"view\" | \"edit\";\n\n    /**\n     * Replace the default entity form with a custom component.\n     * The Builder receives the same props as entity view tabs\n     * (entity, formContext, collection, etc.) and has full control over the UI.\n     *\n     * Works in both edit mode and read-only mode (when `defaultEntityAction`\n     * is `\"view\"`). In read-only mode, `formContext.readOnly` will be `true`.\n     */\n    formView?: FormViewConfig;\n\n    /**\n     * Prevent default actions from being displayed or executed on this collection.\n     */\n    disableDefaultActions?: (\"edit\" | \"copy\" | \"delete\")[];\n\n    /**\n     * Order in which the properties are displayed.\n     * If you are specifying your collection as code, the order is the same as the\n     * one you define in `properties`. Additional columns are added at the\n     * end of the list, if the order is not specified.\n     *\n     * You can use this prop to hide some properties from the table view.\n     * Note that if you set this prop, other ways to hide fields, like\n     * `hidden` in the property definition, will be ignored.\n     * `propertiesOrder` has precedence over `hidden`.\n     *\n     * Supported entry formats:\n     *     - For properties, use the property key.\n     *     - For additional fields, use the field key.\n     *     - Child collections (Firestore subcollections, or Postgres relations\n     *       with `many` cardinality) each get a column with id\n     *       `subcollection:<slug>`, e.g. `subcollection:orders`.\n     */\n    propertiesOrder?: (Extract<keyof M, string> | (string & {}) | string | `subcollection:${string}`)[];\n\n    /**\n     * If enabled, content is loaded in batches. If `false` all entities in the\n     * collection are loaded. This means that when reaching the end of the\n     * collection, the CMS will load more entities.\n     * You can specify a number to specify the pagination size (50 by default)\n     * Defaults to `true`\n     */\n    pagination?: boolean | number;\n\n    selectionEnabled?: boolean;\n\n    /**\n     * Pass your own selection controller if you want to control selected\n     * entities externally.\n     * @see useSelectionController\n     */\n    selectionController?: SelectionController<M>;\n\n    /**\n     * Force a filter in this view. If applied, the rest of the filters will\n     * be disabled. Filters applied with this prop cannot be changed.\n     * e.g. `fixedFilter: { age: [\">\", 18] }`\n     * e.g. `fixedFilter: { related_user: [\"==\", new EntityReference(\"sdc43dsw2\", \"users\")] }`\n     */\n    readonly fixedFilter?: FilterValues<Extract<keyof M, string> | (string & {})>;\n\n    /**\n     * Initial filters applied to the collection this collection is related to.\n     * Defaults to none. Filters applied with this prop can be changed.\n     * e.g. `defaultFilter: { age: [\">\", 18] }`\n     * e.g. `defaultFilter: { related_user: [\"==\", new EntityReference(\"sdc43dsw2\", \"users\")] }`\n     */\n    readonly defaultFilter?: FilterValues<Extract<keyof M, string> | (string & {})>; // setting FilterValues<M> can break defining collections by code\n\n    /**\n     * Pre-defined filter presets that appear as quick-access options in the\n     * collection toolbar. Each preset applies a set of filters (and\n     * optionally a sort order) with a single click.\n     *\n     * ```ts\n     * filterPresets: [\n     *   {\n     *     label: \"Shipped this month\",\n     *     filterValues: {\n     *       status: [\"==\", \"shipped\"],\n     *       order_date: [\">=\", new Date(Date.now() - 30 * 86400000)]\n     *     }\n     *   }\n     * ]\n     * ```\n     */\n    readonly filterPresets?: FilterPreset<Extract<keyof M, string> | (string & {})>[];\n\n    /**\n     * Default sort applied to this collection.\n     * When setting this prop, entities will have a default order\n     * applied in the collection.\n     * e.g. `sort: [\"order\", \"asc\"]`\n     */\n    readonly sort?: OrderByTuple<Extract<keyof M, string> | (string & {})>;\n\n    /**\n     * You can add additional fields to the collection view by implementing\n     * an additional field delegate.\n     */\n    readonly additionalFields?: AdditionalFieldDelegate<M, USER>[];\n\n    /**\n     * Default size of the rendered collection\n     */\n    defaultSize?: CollectionSize;\n\n    /**\n     * Can the elements in this collection be edited inline in the collection\n     * view. Even when inline editing is disabled, entities can still be\n     * edited in the side panel (subject to `securityRules`).\n     */\n    inlineEditing?: boolean;\n\n    /**\n     * Should this collection be hidden from the main navigation panel, if\n     * it is at the root level, or in the entity side panel if it's a\n     * subcollection.\n     * It will still be accessible if you reach the specified path.\n     * You can also use this collection as a reference target.\n     */\n    hideFromNavigation?: boolean;\n\n    /**\n     * If you want to open custom views or subcollections by default when opening the edit\n     * view of a entity, you can specify the path to the view here.\n     * The path is relative to the current collection. For example if you have a collection\n     * that has a custom view as well as a subcollection that refers to another entity, you can\n     * either specify the path to the custom view or the path to the subcollection.\n     */\n    defaultSelectedView?: string | DefaultSelectedViewBuilder;\n\n    /**\n     * Should the ID of this collection be hidden from the form view.\n     */\n    hideIdFromForm?: boolean;\n\n    /**\n     * Should the ID of this collection be hidden from the grid view.\n     */\n    hideIdFromCollection?: boolean;\n\n    /**\n     * If set to true, the form will be auto-saved when the user changes\n     * the value of a field.\n     * Defaults to false.\n     * When a new entity is created, this property can be updated to generated a new ID\n     */\n    formAutoSave?: boolean;\n\n    /**\n     *\n     */\n    exportable?: boolean | ExportConfig<USER>;\n\n    /**\n     * Width of the side dialog (in pixels) when opening a entity in this collection.\n     */\n    sideDialogWidth?: number | string;\n\n    /**\n     * If set to true, the default values of the properties will be applied\n     * to the entity every time the entity is updated (not only when created).\n     * Defaults to false.\n     */\n    alwaysApplyDefaultValues?: boolean;\n\n    /**\n     * If set to true, a tab including the JSON representation of the entity will be included.\n     */\n    includeJsonView?: boolean;\n\n    /**\n     * Should local changes be backed up in local storage, to prevent data loss on\n     * accidental navigations.\n     * - `manual_apply`: When the user navigates back to a entity with local changes,\n     *   they will be prompted to restore the changes.\n     * - `auto_apply`: When the user navigates back to a entity with local changes,\n     *   the changes will be automatically applied.\n     * - `false`: Local changes will not be backed up.\n     * Defaults to `manual_apply`.\n     */\n    localChangesBackup?: \"manual_apply\" | \"auto_apply\" | false;\n\n    /**\n     * Default view mode for displaying this collection.\n     * - \"table\": Display entities in a table with inline editing (default)\n     * - \"cards\": Display entities as a grid of cards with thumbnails\n     * - \"kanban\": Display entities in a Kanban board grouped by a property\n     * Defaults to \"table\".\n     */\n    defaultViewMode?: ViewMode;\n\n    /**\n     * Which view modes are available for this collection.\n     * Possible values: \"table\", \"cards\", \"kanban\".\n     * Defaults to all three: [\"table\", \"cards\", \"kanban\"].\n     * Note: \"kanban\" will only be available if the collection has at least\n     * one string property with `enum` defined, regardless of this setting.\n     */\n    enabledViews?: ViewMode[];\n\n    /**\n     * Configuration for Kanban board view mode.\n     * When set, the Kanban view mode becomes available.\n     */\n    kanban?: KanbanConfig<M>;\n\n    /**\n     * Property key to use for ordering items.\n     * Must reference a string/text property. When items are reordered,\n     * this property will be updated with lexicographic sort keys\n     * (e.g. \"a0\", \"a1\", \"a0V\") using string-based fractional indexing.\n     * Used by Kanban view for ordering within columns\n     * and can be used for general ordering purposes.\n     */\n    readonly orderProperty?: Extract<keyof M, string> | (string & {});\n\n    /**\n     * Actions that can be performed on the entities in this collection.\n     */\n    entityActions?: EntityAction<M, USER>[];\n\n    /**\n     * Builder for the collection actions rendered in the toolbar\n     */\n    Actions?: ComponentRef<CollectionActionsProps>[];\n\n    /**\n     * Collection-scoped component overrides. These take precedence over\n     * global overrides set on `<Rebase>`, but only within this collection's\n     * views (entity form, detail view, table, empty state, etc.).\n     *\n     * Only collection-scoped components (like `Entity.Form`, `Collection.EmptyState`,\n     * `Collection.Card`, etc.) can be overridden here. App-level components\n     * (like `Shell.AppBar`, `HomePage`) can only be overridden at the `<Rebase>` level.\n     *\n     * @example\n     * ```tsx\n     * const productsCollection: PostgresCollectionConfig = {\n     *     name: \"Products\",\n     *     slug: \"products\",\n     *     table: \"products\",\n     *     components: {\n     *         \"Entity.Form\": { Component: ProductCustomForm },\n     *         \"Collection.Card\": { Component: ProductCard },\n     *     },\n     *     properties: { ... }\n     * };\n     * ```\n     */\n    components?: CollectionComponentOverrideMap;};\n\n/**\n * There is deliberately no `AdminCollectionConfig` here any more.\n *\n * It used to be `Omit<CollectionConfig, \"admin\"> & { admin?: AdminCollectionOptions }`,\n * a wrapper that existed because core typed the block opaquely. Now that `augment.ts`\n * declares `admin` directly on `BaseCollectionConfig`, `CollectionConfig` *is* the\n * authoring type — the wrapper would be an alias of it, and a second name for one thing\n * is what this whole refactor has been removing.\n *\n * A project opts its program in with one line, once:\n *\n * ```ts\n * /// <reference types=\"@rebasepro/admin-types\" />\n * ```\n *\n * after which `admin` is typed on every collection and every property. Without it,\n * writing one is an error — which is the guarantee a BaaS install depends on.\n */\n\n/**\n * Define a collection with the admin block type-checked.\n *\n * The same identity function as `defineCollection` in `@rebasepro/common` — which\n * is what a BaaS or headless project uses, and where `admin` does not exist at all\n * — with one difference: importing this one brings the augmentation with it, so\n * `admin: { icon, listProperties, kanban }` gets completion and a typo is an\n * error. See {@link AdminCollectionOptions}.\n *\n * Import it from the layer you are in. A project with an admin panel wants this\n * one; a project without one has no `admin` block to check.\n *\n * `const P` captures the literal property types, which is what gives\n * `admin.titleProperty`, `admin.sort` and `admin.propertiesOrder` completion over\n * the collection's own property keys rather than plain `string`.\n *\n * @example\n * export default defineCollection({\n *     slug: \"posts\",\n *     table: \"posts\",\n *     properties: {\n *         title: { name: \"Title\", type: \"string\" },\n *         status: { name: \"Status\", type: \"string\" }\n *     },\n *     admin: {\n *         icon: \"FileText\",\n *         titleProperty: \"title\",     // completion: \"title\" | \"status\"\n *         listProperties: [\"title\", \"status\"]\n *     }\n * });\n *\n * @group Builder\n */\nexport function defineCollection<\n    const P extends PostgresProperties,\n    USER extends User = User\n>(\n    collection: Omit<PostgresCollectionConfig<InferEntityType<P>, USER>, \"properties\">\n        & { properties: P }\n): PostgresCollectionConfig<InferEntityType<P>, USER> & { properties: P };\n\n/** Define a Firestore-backed collection with the admin block checked. @group Builder */\nexport function defineCollection<\n    const P extends FirebaseProperties,\n    USER extends User = User\n>(\n    collection: Omit<FirebaseCollectionConfig<InferEntityType<P>, USER>, \"properties\">\n        & { properties: P }\n): FirebaseCollectionConfig<InferEntityType<P>, USER> & { properties: P };\n\n/** Define a MongoDB-backed collection with the admin block checked. @group Builder */\nexport function defineCollection<\n    const P extends MongoProperties,\n    USER extends User = User\n>(\n    collection: Omit<MongoDBCollectionConfig<InferEntityType<P>, USER>, \"properties\">\n        & { properties: P }\n): MongoDBCollectionConfig<InferEntityType<P>, USER> & { properties: P };\n\n/** Identity at runtime; the overloads above are the whole point. @group Builder */\nexport function defineCollection(collection: CollectionConfig): CollectionConfig {\n    return collection;\n}\n\n/**\n * Re-exported from `@rebasepro/types`, where the list has to live: the ts-morph\n * schema editor in `@rebasepro/server` needs it to know which keys go inside the\n * block when it rewrites a collection file, and a core package may not import\n * this one. The list is plain data, so core is a fine home for it.\n *\n * What core *cannot* do is check the list against the type. That happens here.\n *\n * @group Models\n */\nexport type { AdminCollectionKey } from \"@rebasepro/types\";\n\n/**\n * Core's list, re-exported through a `satisfies` clause that is the agreement\n * check: a key core names that is not an option here fails to compile, and\n * `satisfies` keeps the literal tuple type rather than widening it to `string[]`.\n *\n * The reverse direction — an option missing from core's list — has no type-level\n * expression, since there is no exhaustiveness check over an optional-property\n * keyof. `test/admin_collection.test.ts` counts them instead.\n */\nexport const ADMIN_COLLECTION_KEYS = CORE_ADMIN_COLLECTION_KEYS satisfies readonly (keyof AdminCollectionOptions)[];\n\n\n/**\n * A collection as the admin panel works with it: the contract with the `admin`\n * block flattened onto the top level.\n *\n * The panel reads presentation fields in a few hundred places, and threading\n * `collection.admin?.propertiesOrder` through all of them would be noise that\n * buys nothing — the panel has already resolved the collection by then, merging\n * the declared config with the user's per-collection overrides from local\n * storage. So the panel gets a flat *view model*, exactly as it already does for\n * entities (`Entity` is an admin view model over flat rows, not a wire type).\n *\n * The distinction that matters is direction:\n *\n * - **Reading** a resolved collection → `AdminCollection` (flat, convenient).\n * - **Authoring or persisting** one → core's `CollectionConfig`, with the `admin`\n *   block this package augments onto it (nested, which is what the file on disk\n *   and the wire both look like).\n *\n * `admin` is kept alongside the flattened fields so the collection editor can\n * still see the block it has to write back.\n *\n * @group Models\n */\nexport type AdminCollection<\n    M extends Record<string, unknown> = Record<string, unknown>,\n    USER extends User = User\n> = WithFlatAdmin<CollectionConfig<M, USER>, M, USER>;\n\n/**\n * Flatten the admin block onto one member of the collection union at a time.\n *\n * `CollectionConfig` is a union discriminated on `engine`\n * (Postgres | Firestore | MongoDB), and a bare `Omit<Union, \"admin\">` collapses it\n * into a single object type with the discriminant widened. The result stops being\n * assignable back to `CollectionConfig`, so every call that hands a resolved\n * collection to a core function fails — which is exactly what happened. The\n * `C extends unknown` clause makes the mapping distributive, so each member keeps\n * its literal `engine` and stays assignable to its counterpart.\n */\ntype WithFlatAdmin<C, M extends Record<string, unknown>, USER extends User> =\n    C extends unknown\n        ? Omit<C, \"admin\"> & AdminCollectionOptions<M, USER> & { admin?: AdminCollectionOptions<M, USER> }\n        : never;\n\n/** {@link AdminCollection} for a Postgres collection. @group Models */\nexport type AdminPostgresCollection<\n    M extends Record<string, unknown> = Record<string, unknown>,\n    USER extends User = User\n> = Omit<PostgresCollectionConfig<M, USER>, \"admin\">\n    & AdminCollectionOptions<M, USER>\n    & { admin?: AdminCollectionOptions<M, USER> };\n\n/**\n * Flatten a collection's `admin` block onto it, producing the panel's view model.\n *\n * Shallow by design: the block's fields are independent, so a deep merge would\n * only create opportunities for a nested object to be half from one source and\n * half from the other. `admin` survives on the result.\n *\n * Idempotent — flattening an already-flat collection returns an equivalent one —\n * because the panel resolves collections at more than one entry point (the\n * registry, `<Rebase collections>`, a plugin's `modifyCollection`) and they must\n * not fight over which has run.\n */\nexport function resolveAdminCollection<\n    M extends Record<string, unknown> = Record<string, unknown>,\n    USER extends User = User\n>(collection: CollectionConfig<M, USER> | AdminCollection<M, USER>): AdminCollection<M, USER> {\n    const block = (collection as { admin?: AdminCollectionOptions<M, USER> }).admin;\n    if (!block) return collection as AdminCollection<M, USER>;\n    return { ...(collection as AdminCollection<M, USER>), ...block, admin: block };\n}\n\n/**\n * The inverse: lift flattened admin fields back into the block.\n *\n * Used on the way out — persisting from the collection editor, or handing a\n * collection to anything that expects the authoring shape. Any key in\n * {@link ADMIN_COLLECTION_KEYS} found at the top level is moved down, so a\n * round trip through the panel does not leave the file flat.\n */\nexport function toAdminCollectionConfig<\n    M extends Record<string, unknown> = Record<string, unknown>,\n    USER extends User = User\n>(collection: AdminCollection<M, USER> | CollectionConfig<M, USER>): CollectionConfig<M, USER> {\n    const source = collection as Record<string, unknown>;\n    const top: Record<string, unknown> = {};\n    const block: Record<string, unknown> = { ...(source.admin as object ?? {}) };\n\n    for (const [key, value] of Object.entries(source)) {\n        if (key === \"admin\") continue;\n        if ((ADMIN_COLLECTION_KEYS as readonly string[]).includes(key)) block[key] = value;\n        else top[key] = value;\n    }\n\n    if (Object.keys(block).length > 0) top.admin = block;\n    return top as unknown as CollectionConfig<M, USER>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,eAAkB,WAAoD;CAClF,OAAO;AACX;;;;;;AAOA,SAAgB,iBAAoB,WAAqD;CACrF,OAAO;AACX;;;;ACqZA,SAAgB,iBAAiB,YAAgD;CAC7E,OAAO;AACX;;;;;;;;;;AAuBA,IAAa,wBAAwB;;;;;;;;;;;;;AAmErC,SAAgB,uBAGd,YAA4F;CAC1F,MAAM,QAAS,WAA2D;CAC1E,IAAI,CAAC,OAAO,OAAO;CACnB,OAAO;EAAE,GAAI;EAAyC,GAAG;EAAO,OAAO;CAAM;AACjF;;;;;;;;;AAUA,SAAgB,wBAGd,YAA6F;CAC3F,MAAM,SAAS;CACf,MAAM,MAA+B,CAAC;CACtC,MAAM,QAAiC,EAAE,GAAI,OAAO,SAAmB,CAAC,EAAG;CAE3E,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,GAAG;EAC/C,IAAI,QAAQ,SAAS;EACrB,IAAK,sBAA4C,SAAS,GAAG,GAAG,MAAM,OAAO;OACxE,IAAI,OAAO;CACpB;CAEA,IAAI,OAAO,KAAK,KAAK,EAAE,SAAS,GAAG,IAAI,QAAQ;CAC/C,OAAO;AACX"}