@rebasepro/admin 0.6.1 → 0.7.0

package/dist/collection_editor/serializable_types.d.ts

@@ -0,0 +1,374 @@
+/**
+ * JSON-serializable versions of Rebase collection and property types.
+ *
+ * These types strip all non-serializable fields (functions, React nodes,
+ * class instances) from the original types in `@rebasepro/types`, making
+ * them safe for `JSON.stringify()` / database storage.
+ *
+ * Use `toSerializableCollection` / `fromSerializableCollection` from
+ * `./serializable_utils` to convert between the original and serializable forms.
+ *
+ * @module
+ */
+import type { EnumValues, PropertyValidationSchema, NumberPropertyValidationSchema, ArrayPropertyValidationSchema, PropertyConditions, ImageResize, FileType } from "@rebasepro/types";
+import type { ViewMode, CollectionSize, SecurityRule, FilterValues, FilterPreset, KanbanConfig, NavigationGroupMapping } from "@rebasepro/types";
+import type { OnAction, JoinStep } from "@rebasepro/types";
+/**
+ * JSON-serializable version of `BaseUIConfig`.
+ * Drops `Field` and `Preview` (ComponentRef — functions/components).
+ */
+export interface SerializableBaseUIConfig {
+    columnWidth?: number;
+    hideFromCollection?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean | SerializablePropertyDisabledConfig;
+    widthPercentage?: number;
+    customProps?: unknown;
+}
+/** JSON-serializable version of `PropertyDisabledConfig`. Already serializable. */
+export interface SerializablePropertyDisabledConfig {
+    clearOnDisabled?: boolean;
+    disabledMessage?: string;
+    hidden?: boolean;
+}
+/**
+ * JSON-serializable version of `StringPropertyValidationSchema`.
+ * `matches` is forced to `string` (no RegExp).
+ */
+export interface SerializableStringValidation extends PropertyValidationSchema {
+    length?: number;
+    min?: number;
+    max?: number;
+    /** Regex pattern as a string. RegExp objects are converted to their `.source`. */
+    matches?: string;
+    matchesMessage?: string;
+    trim?: boolean;
+    lowercase?: boolean;
+    uppercase?: boolean;
+}
+/**
+ * JSON-serializable version of `DatePropertyValidationSchema`.
+ * `min` and `max` are ISO 8601 strings instead of `Date` objects.
+ */
+export interface SerializableDateValidation extends PropertyValidationSchema {
+    /** Minimum date as ISO 8601 string. */
+    min?: string;
+    /** Maximum date as ISO 8601 string. */
+    max?: string;
+}
+/**
+ * JSON-serializable version of `StorageConfig`.
+ * Drops all function fields: `processFile`, `postProcess`, `previewUrl`.
+ * `storagePath` and `fileName` are string-only (no function variant).
+ */
+export interface SerializableStorageConfig {
+    acceptedFiles?: FileType[];
+    imageResize?: ImageResize;
+    metadata?: Record<string, unknown>;
+    /** String template only. Function variant is not serializable. */
+    fileName?: string;
+    /** String template only. Function variant is not serializable. */
+    storagePath: string;
+    includeBucketUrl?: boolean;
+    storeUrl?: boolean;
+    maxSize?: number;
+}
+/** JSON-serializable version of `StringUIConfig`. */
+export interface SerializableStringUIConfig extends SerializableBaseUIConfig {
+    multiline?: boolean;
+    markdown?: boolean;
+    previewAsTag?: boolean;
+    clearable?: boolean;
+    url?: boolean | "image" | "video" | "audio" | "file";
+}
+/** JSON-serializable version of `NumberUIConfig`. */
+export interface SerializableNumberUIConfig extends SerializableBaseUIConfig {
+    clearable?: boolean;
+}
+/** JSON-serializable version of `DateUIConfig`. */
+export interface SerializableDateUIConfig extends SerializableBaseUIConfig {
+    clearable?: boolean;
+}
+/** JSON-serializable version of `VectorUIConfig`. */
+export interface SerializableVectorUIConfig extends SerializableBaseUIConfig {
+    clearable?: boolean;
+}
+/** JSON-serializable version of `ReferenceUIConfig`. */
+export interface SerializableReferenceUIConfig extends SerializableBaseUIConfig {
+    previewProperties?: string[];
+}
+/** JSON-serializable version of `RelationUIConfig`. */
+export interface SerializableRelationUIConfig extends SerializableBaseUIConfig {
+    previewProperties?: string[];
+    widget?: "select" | "dialog";
+}
+/** JSON-serializable version of `ArrayUIConfig`. */
+export interface SerializableArrayUIConfig extends SerializableBaseUIConfig {
+    expanded?: boolean;
+    minimalistView?: boolean;
+}
+/** JSON-serializable version of `MapUIConfig`. */
+export interface SerializableMapUIConfig extends SerializableBaseUIConfig {
+    expanded?: boolean;
+    minimalistView?: boolean;
+    spreadChildren?: boolean;
+}
+/**
+ * JSON-serializable version of `BaseProperty`.
+ * Drops: `dynamicProps` (function), `callbacks` (functions).
+ * Keeps: `conditions` (JSON Logic — already serializable by design).
+ */
+export interface SerializableBaseProperty {
+    ui?: SerializableBaseUIConfig;
+    name: string;
+    description?: string;
+    propertyConfig?: string;
+    columnName?: string;
+    validation?: PropertyValidationSchema;
+    defaultValue?: unknown;
+    /**
+     * JSON Logic conditions — fully serializable by design.
+     * These are the declarative alternative to `dynamicProps` functions.
+     */
+    conditions?: PropertyConditions;
+    /**
+     * Arbitrary key-value metadata for external consumers.
+     * Not interpreted by Rebase — passed through serialization unchanged.
+     */
+    metadata?: Record<string, unknown>;
+}
+/** JSON-serializable `StringProperty`. */
+export interface SerializableStringProperty extends SerializableBaseProperty {
+    ui?: SerializableStringUIConfig;
+    type: "string";
+    columnType?: "varchar" | "text" | "char" | "uuid";
+    validation?: SerializableStringValidation;
+    isId?: boolean | "manual" | "uuid" | "cuid" | string;
+    enum?: EnumValues;
+    multiline?: boolean;
+    markdown?: boolean;
+    storage?: SerializableStorageConfig;
+    userSelect?: boolean;
+    url?: boolean | "image" | "video" | "audio" | "file";
+    email?: boolean;
+    previewAsTag?: boolean;
+    reference?: SerializableReferenceProperty;
+}
+/** JSON-serializable `NumberProperty`. */
+export interface SerializableNumberProperty extends SerializableBaseProperty {
+    ui?: SerializableNumberUIConfig;
+    type: "number";
+    columnType?: "integer" | "real" | "double precision" | "numeric" | "bigint" | "serial" | "bigserial";
+    validation?: NumberPropertyValidationSchema;
+    isId?: boolean | "manual" | "increment" | string;
+    enum?: EnumValues;
+}
+/** JSON-serializable `BooleanProperty`. */
+export interface SerializableBooleanProperty extends SerializableBaseProperty {
+    ui?: SerializableBaseUIConfig;
+    type: "boolean";
+    validation?: PropertyValidationSchema;
+}
+/** JSON-serializable `DateProperty`. */
+export interface SerializableDateProperty extends SerializableBaseProperty {
+    ui?: SerializableDateUIConfig;
+    type: "date";
+    columnType?: "timestamp" | "date" | "time";
+    validation?: SerializableDateValidation;
+    mode?: "date" | "date_time";
+    timezone?: string;
+    autoValue?: "on_create" | "on_update";
+    clearable?: boolean;
+}
+/** JSON-serializable `GeopointProperty`. */
+export interface SerializableGeopointProperty extends SerializableBaseProperty {
+    ui?: SerializableBaseUIConfig;
+    type: "geopoint";
+    validation?: PropertyValidationSchema;
+}
+/** JSON-serializable `VectorProperty`. */
+export interface SerializableVectorProperty extends SerializableBaseProperty {
+    ui?: SerializableVectorUIConfig;
+    type: "vector";
+    dimensions: number;
+    validation?: PropertyValidationSchema;
+}
+/** JSON-serializable `BinaryProperty`. */
+export interface SerializableBinaryProperty extends SerializableBaseProperty {
+    type: "binary";
+    validation?: PropertyValidationSchema;
+}
+/**
+ * JSON-serializable `ReferenceProperty`.
+ * Already largely serializable; just inherits the serializable base.
+ */
+export interface SerializableReferenceProperty extends SerializableBaseProperty {
+    ui?: SerializableReferenceUIConfig;
+    type: "reference";
+    isId?: boolean;
+    path?: string;
+    fixedFilter?: FilterValues<string>;
+    includeId?: boolean;
+    includeEntityLink?: boolean;
+}
+/**
+ * JSON-serializable `RelationProperty`.
+ * `target` is string-only (collection slug). The function variant
+ * `() => EntityCollection` is not serializable.
+ */
+export interface SerializableRelationProperty extends SerializableBaseProperty {
+    ui?: SerializableRelationUIConfig;
+    type: "relation";
+    isId?: boolean;
+    /** Target collection slug. Function variant is not serializable. */
+    target?: string;
+    cardinality?: "one" | "many";
+    direction?: "owning" | "inverse";
+    inverseRelationName?: string;
+    localKey?: string;
+    foreignKeyOnTarget?: string;
+    through?: {
+        table: string;
+        sourceColumn: string;
+        targetColumn: string;
+    };
+    joinPath?: JoinStep[];
+    onUpdate?: OnAction;
+    onDelete?: OnAction;
+    relationName?: string;
+    fixedFilter?: FilterValues<string>;
+    includeId?: boolean;
+    includeEntityLink?: boolean;
+    widget?: "select" | "dialog";
+}
+/** JSON-serializable `ArrayProperty`. */
+export interface SerializableArrayProperty extends SerializableBaseProperty {
+    ui?: SerializableArrayUIConfig;
+    type: "array";
+    columnType?: "json" | "jsonb" | "text[]" | "integer[]" | "boolean[]" | "numeric[]";
+    of?: SerializableProperty | SerializableProperty[];
+    oneOf?: {
+        properties: SerializableProperties;
+        propertiesOrder?: string[];
+        typeField?: string;
+        valueField?: string;
+    };
+    validation?: ArrayPropertyValidationSchema;
+    sortable?: boolean;
+    canAddElements?: boolean;
+}
+/** JSON-serializable `MapProperty`. */
+export interface SerializableMapProperty extends SerializableBaseProperty {
+    ui?: SerializableMapUIConfig;
+    type: "map";
+    columnType?: "json" | "jsonb";
+    properties?: SerializableProperties;
+    propertiesOrder?: string[];
+    validation?: PropertyValidationSchema;
+    previewProperties?: string[];
+    keyValue?: boolean;
+}
+/**
+ * Union of all JSON-serializable property types.
+ * Mirrors `Property` from `@rebasepro/types` but with all non-serializable
+ * fields stripped.
+ */
+export type SerializableProperty = SerializableStringProperty | SerializableNumberProperty | SerializableBooleanProperty | SerializableDateProperty | SerializableGeopointProperty | SerializableReferenceProperty | SerializableRelationProperty | SerializableArrayProperty | SerializableMapProperty | SerializableVectorProperty | SerializableBinaryProperty;
+/** Record of serializable properties, keyed by property key. */
+export type SerializableProperties = {
+    [key: string]: SerializableProperty;
+};
+/**
+ * JSON-serializable version of `EntityCollection` / `BaseEntityCollection`.
+ *
+ * Strips all non-serializable fields:
+ * - Functions: `callbacks`, `childCollections`, `additionalFields`, `defaultSelectedView` (fn)
+ * - React nodes: `icon` (ReactNode variant), `entityViews`, `formView`
+ * - Runtime objects: `selectionController`, `overrides`
+ * - Component refs: `Actions`, `components`, `entityActions`
+ * - `exportable` when it's an `ExportConfig` (contains functions)
+ * - `auth` when it's an `AuthCollectionConfig` (contains functions)
+ *
+ * Keeps all data-describing fields that the collection editor works with.
+ */
+export interface SerializableCollection {
+    slug: string;
+    name: string;
+    singularName?: string;
+    description?: string;
+    /**
+     * Icon name as a string (e.g. Lucide icon key).
+     * React.ReactNode variant is not serializable and is stripped.
+     */
+    icon?: string;
+    group?: string;
+    driver?: string;
+    databaseId?: string;
+    properties: SerializableProperties;
+    propertiesOrder?: string[];
+    previewProperties?: string[];
+    listProperties?: string[];
+    titleProperty?: string;
+    openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
+    defaultEntityAction?: "view" | "edit";
+    defaultViewMode?: ViewMode;
+    enabledViews?: ViewMode[];
+    kanban?: KanbanConfig<Record<string, unknown>>;
+    defaultSize?: CollectionSize;
+    sideDialogWidth?: number | string;
+    pagination?: boolean | number;
+    selectionEnabled?: boolean;
+    inlineEditing?: boolean;
+    hideFromNavigation?: boolean;
+    hideIdFromForm?: boolean;
+    hideIdFromCollection?: boolean;
+    formAutoSave?: boolean;
+    alwaysApplyDefaultValues?: boolean;
+    includeJsonView?: boolean;
+    history?: boolean;
+    localChangesBackup?: "manual_apply" | "auto_apply" | false;
+    exportable?: boolean;
+    auth?: boolean;
+    /**
+     * Default selected view as a string key.
+     * The function variant (`DefaultSelectedViewBuilder`) is not serializable.
+     */
+    defaultSelectedView?: string;
+    fixedFilter?: FilterValues<string>;
+    defaultFilter?: FilterValues<string>;
+    filterPresets?: FilterPreset<string>[];
+    sort?: [string, "asc" | "desc"];
+    orderProperty?: string;
+    disableDefaultActions?: ("edit" | "copy" | "delete")[];
+    table?: string;
+    schema?: string;
+    securityRules?: SecurityRule[];
+    ownerId?: string;
+    /**
+     * Arbitrary key-value metadata for external consumers.
+     * Not interpreted by Rebase — passed through serialization unchanged.
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Adapter interface for persisting serializable collections to a JSON backend.
+ * Implement this to store collection configs in a database, API, localStorage, etc.
+ */
+export interface JsonCollectionStore {
+    /** Load all persisted collections. */
+    load(): Promise<SerializableCollection[]>;
+    /** Save (create or update) a single collection by its slug. */
+    save(slug: string, data: SerializableCollection): Promise<void>;
+    /** Delete a collection by its slug. */
+    delete(slug: string): Promise<void>;
+    /**
+     * Optional: save navigation group mappings.
+     * If not implemented, navigation entries are not persisted.
+     */
+    saveNavigationEntries?(entries: NavigationGroupMapping[]): Promise<void>;
+    /**
+     * Optional: load navigation group mappings.
+     * If not implemented, an empty array is used.
+     */
+    loadNavigationEntries?(): Promise<NavigationGroupMapping[]>;
+}

package/dist/collection_editor/serializable_utils.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Conversion utilities between the full Rebase types and their
+ * JSON-serializable counterparts.
+ *
+ * - `toSerializableCollection` / `toSerializableProperty` — strip non-serializable fields
+ * - `fromSerializableCollection` / `fromSerializableProperty` — reconstruct original types
+ *
+ * @module
+ */
+import type { EntityCollection, Property, Properties } from "@rebasepro/types";
+import type { SerializableCollection, SerializableProperty, SerializableProperties } from "./serializable_types";
+/**
+ * Convert a single `Property` to its JSON-serializable form.
+ * Strips functions, converts RegExp to string, Date to ISO string.
+ */
+export declare function toSerializableProperty(property: Property): SerializableProperty;
+/**
+ * Convert a `Properties` record to its serializable form.
+ */
+export declare function toSerializableProperties(properties: Properties): SerializableProperties;
+/**
+ * Convert an `EntityCollection` to its JSON-serializable form.
+ *
+ * Strips all non-serializable fields (functions, React nodes, class instances)
+ * while preserving the structural schema that the collection editor works with.
+ *
+ * The result is safe for `JSON.stringify()` and database storage.
+ */
+export declare function toSerializableCollection(collection: EntityCollection): SerializableCollection;
+/**
+ * Convert a serializable property back to the original `Property` type.
+ *
+ * This is a mostly pass-through operation since serializable properties
+ * are a subset of the original types. The main conversions are:
+ * - `validation.matches` (string) stays as string (compatible with Property)
+ * - `validation.min/max` on dates: ISO strings → Date objects
+ */
+export declare function fromSerializableProperty(serialized: SerializableProperty): Property;
+/**
+ * Convert a `SerializableProperties` record back to `Properties`.
+ */
+export declare function fromSerializableProperties(serialized: SerializableProperties): Properties;
+/**
+ * Convert a `SerializableCollection` back to an `EntityCollection`.
+ *
+ * The result will NOT contain any of the non-serializable fields
+ * (callbacks, entityActions, etc.) — those must be re-attached by the
+ * consumer if needed.
+ */
+export declare function fromSerializableCollection(serialized: SerializableCollection): EntityCollection;

package/dist/collection_editor/ui/collection_editor/CollectionEditorDialog.d.ts

@@ -4,7 +4,8 @@ import { CollectionsConfigController } from "../../types/config_controller";
 import { CollectionInference } from "../../types/collection_inference";
 import { CollectionGenerationCallback } from "../../api/generateCollectionApi";
 import { TableMetadata } from "@rebasepro/types";
-export interface CollectionEditorDialogProps {
+import type { CollectionEditorExtensionProps } from "../../extensibility_types";
+export interface CollectionEditorDialogProps extends CollectionEditorExtensionProps {
     open: boolean;
     isNewCollection: boolean;
     initialValues?: {

package/dist/collection_editor/ui/collection_editor/CollectionPropertiesEditorForm.d.ts

@@ -1,5 +1,7 @@
 import React from "react";
 import { EntityCollection, PropertyConfig, User } from "@rebasepro/types";
+import type { PropertyTypePreset, PropertyType } from "../../extensibility_types";
+import type { SerializableProperty, SerializableCollection } from "../../serializable_types";
 type CollectionEditorFormProps = {
     showErrors: boolean;
     isNewCollection: boolean;
@@ -11,6 +13,15 @@ type CollectionEditorFormProps = {
     getData?: () => Promise<object[]>;
     doCollectionInference?: (collection: EntityCollection) => Promise<Partial<EntityCollection> | null> | undefined;
     propertyConfigs: Record<string, PropertyConfig>;
+    propertyTypePresets?: PropertyTypePreset[];
+    hiddenPropertyTypes?: PropertyType[];
+    renderExtraPropertyFields?: (params: {
+        metadata: Record<string, unknown>;
+        onMetadataChange: (key: string, value: unknown) => void;
+        property: SerializableProperty;
+        collection: SerializableCollection;
+    }) => React.ReactNode;
+    standalone?: boolean;
 };
-export declare function CollectionPropertiesEditorForm({ showErrors, isNewCollection, propertyErrorsRef, onPropertyError, setDirty, extraIcon, getUser, getData, doCollectionInference, propertyConfigs }: CollectionEditorFormProps): React.JSX.Element;
+export declare function CollectionPropertiesEditorForm({ showErrors, isNewCollection, propertyErrorsRef, onPropertyError, setDirty, extraIcon, getUser, getData, doCollectionInference, propertyConfigs, propertyTypePresets, hiddenPropertyTypes, renderExtraPropertyFields, standalone, }: CollectionEditorFormProps): React.JSX.Element;
 export {};

package/dist/collection_editor/ui/collection_editor/CollectionStudioView.d.ts

@@ -1,6 +1,18 @@
 import * as React from "react";
 import { CollectionEditorDialogProps } from "./CollectionEditorDialog";
+import type { EntityCollection } from "@rebasepro/types";
 export type CollectionStudioViewProps = Omit<CollectionEditorDialogProps, "open" | "isNewCollection" | "editedCollectionId" | "handleClose" | "handleCancel"> & {
     collectionId?: string | "new";
+    /**
+     * Called after a successful save.
+     * Receives the saved collection (or undefined if dismissed without saving).
+     * When not provided, save completes silently.
+     */
+    onSave?: (collection?: EntityCollection) => void;
+    /**
+     * Called when the user cancels editing.
+     * When not provided, cancel is a no-op.
+     */
+    onCancel?: () => void;
 };
-export declare function CollectionStudioView({ collectionId, ...props }: CollectionStudioViewProps): React.JSX.Element;
+export declare function CollectionStudioView({ collectionId, onSave, onCancel, ...props }: CollectionStudioViewProps): React.JSX.Element;

package/dist/collection_editor/ui/collection_editor/CollectionsStudioView.d.ts

@@ -1,6 +1,28 @@
 import React from "react";
+import type { EntityCollection } from "@rebasepro/types";
 import { CollectionsConfigController } from "../../types/config_controller";
-export interface CollectionsStudioViewProps {
+import type { CollectionEditorExtensionProps } from "../../extensibility_types";
+export interface CollectionsStudioViewProps extends CollectionEditorExtensionProps {
     configController: CollectionsConfigController;
+    /**
+     * Collections to show in the sidebar.
+     * When provided, overrides the collections from `configController`.
+     * Use this to control exactly which collections the editor displays.
+     */
+    collections?: EntityCollection[];
+    /**
+     * Controlled active collection ID.
+     * When provided together with `onActiveCollectionChange`,
+     * navigation is fully external — no internal state is used.
+     */
+    activeCollectionId?: string;
+    /**
+     * Called when the user clicks a collection, "new", or navigates.
+     * When provided, the component is fully controlled (no internal state).
+     * When not provided, the component manages selection via internal state.
+     *
+     * Pass `"new"` to create a new collection. Pass `undefined` to deselect.
+     */
+    onActiveCollectionChange?: (collectionId: string | undefined) => void;
 }
-export declare function CollectionsStudioView({ configController }: CollectionsStudioViewProps): React.JSX.Element;
+export declare function CollectionsStudioView({ configController, collections: collectionsProp, activeCollectionId: controlledActiveId, onActiveCollectionChange, propertyTypePresets, hiddenPropertyTypes, renderExtraPropertyFields, renderExtraCollectionFields, visibleTabs, standalone, }: CollectionsStudioViewProps): React.JSX.Element;

package/dist/collection_editor/ui/collection_editor/DisplaySettingsForm.d.ts

@@ -1,4 +1,5 @@
 import React from "react";
-export declare function DisplaySettingsForm({ expandKanban }: {
+export declare function DisplaySettingsForm({ expandKanban, standalone, }: {
     expandKanban?: boolean;
+    standalone?: boolean;
 }): React.JSX.Element;

package/dist/collection_editor/ui/collection_editor/GeneralSettingsForm.d.ts

@@ -1,8 +1,11 @@
 import React from "react";
 import type { EntityCollection } from "@rebasepro/types";
-export declare function GeneralSettingsForm({ isNewCollection, existingPaths, existingIds, parentCollection }: {
+import type { ExtraCollectionFieldsParams } from "../../extensibility_types";
+export declare function GeneralSettingsForm({ isNewCollection, existingPaths, existingIds, parentCollection, renderExtraCollectionFields, standalone, }: {
     isNewCollection: boolean;
     existingPaths?: string[];
     existingIds?: string[];
     parentCollection?: EntityCollection;
+    renderExtraCollectionFields?: (params: ExtraCollectionFieldsParams) => React.ReactNode;
+    standalone?: boolean;
 }): React.JSX.Element;

package/dist/collection_editor/ui/collection_editor/PropertyEditView.d.ts

@@ -1,6 +1,8 @@
 import React from "react";
 import { FormexController } from "@rebasepro/formex";
-import { Property, PropertyConfig } from "@rebasepro/types";
+import { EntityCollection, Property, PropertyConfig } from "@rebasepro/types";
+import type { PropertyTypePreset, PropertyType } from "../../extensibility_types";
+import type { SerializableProperty, SerializableCollection } from "../../serializable_types";
 export type PropertyWithId = Property & {
     id?: string;
     conditions?: import("@rebasepro/types").PropertyConditions;
@@ -32,6 +34,15 @@ export type PropertyFormProps = {
     getData?: () => Promise<object[]>;
     getController?: (formex: FormexController<PropertyWithId>) => void;
     propertyConfigs: Record<string, PropertyConfig>;
+    propertyTypePresets?: PropertyTypePreset[];
+    hiddenPropertyTypes?: PropertyType[];
+    renderExtraPropertyFields?: (params: {
+        metadata: Record<string, unknown>;
+        onMetadataChange: (key: string, value: unknown) => void;
+        property: SerializableProperty;
+        collection: SerializableCollection;
+    }) => React.ReactNode;
+    collectionValues?: EntityCollection;
 };
 export declare const PropertyForm: React.MemoExoticComponent<(props: PropertyFormProps) => React.JSX.Element>;
 export declare function PropertyFormDialog({ open, onCancel, onOkClicked, onPropertyChanged, getData, ...formProps }: PropertyFormProps & {

package/dist/collection_editor/ui/collection_editor/RouterCollectionStudioView.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Router-aware wrapper around CollectionStudioView.
+ *
+ * This component provides the react-router-based navigation behavior
+ * that Rebase Studio expects: cancel navigates to the root path,
+ * save navigates to the saved collection's slug, and a snackbar
+ * toast is shown on success.
+ *
+ * External consumers should use `CollectionStudioView` directly
+ * (which has no react-router dependency).
+ */
+import React from "react";
+import { CollectionStudioViewProps } from "./CollectionStudioView";
+export type RouterCollectionStudioViewProps = Omit<CollectionStudioViewProps, "onSave" | "onCancel">;
+export declare function RouterCollectionStudioView(props: RouterCollectionStudioViewProps): React.JSX.Element;

package/dist/collection_editor/ui/collection_editor/RouterCollectionsStudioView.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Router-aware wrapper around CollectionsStudioView.
+ *
+ * This component provides the react-router-based navigation behavior
+ * that Rebase Studio expects: the active collection is derived from the
+ * URL, and clicking a collection navigates via react-router.
+ *
+ * External consumers should use `CollectionsStudioView` directly
+ * (which has no react-router dependency).
+ */
+import React from "react";
+import { CollectionsStudioViewProps } from "./CollectionsStudioView";
+export type RouterCollectionsStudioViewProps = Omit<CollectionsStudioViewProps, "activeCollectionId" | "onActiveCollectionChange">;
+export declare function RouterCollectionsStudioView(props: RouterCollectionsStudioViewProps): React.JSX.Element;

package/dist/collection_editor/useJsonCollectionsConfigController.d.ts

@@ -0,0 +1,37 @@
+import type { CollectionsConfigController } from "./types/config_controller";
+import type { JsonCollectionStore } from "./serializable_types";
+export interface UseJsonCollectionsConfigControllerOptions {
+    /**
+     * The store adapter for persisting/loading collections.
+     */
+    store: JsonCollectionStore;
+    /**
+     * If true, the configuration cannot be modified.
+     */
+    readOnly?: boolean;
+    /**
+     * If true, collections will be loaded from the store on mount.
+     * Defaults to true.
+     */
+    autoLoad?: boolean;
+}
+/**
+ * A `CollectionsConfigController` implementation that persists collection
+ * configurations as JSON via a pluggable `JsonCollectionStore` adapter.
+ *
+ * Use this when you want to store collection schemas in a database, API,
+ * localStorage, or any other JSON-compatible backend — as opposed to the
+ * default code-based persistence.
+ *
+ * @example
+ * ```tsx
+ * const store: JsonCollectionStore = {
+ *     load: async () => { const res = await fetch('/api/schemas'); return res.json(); },
+ *     save: async (slug, data) => { await fetch(`/api/schemas/${slug}`, { method: 'PUT', body: JSON.stringify(data) }); },
+ *     delete: async (slug) => { await fetch(`/api/schemas/${slug}`, { method: 'DELETE' }); },
+ * };
+ *
+ * const configController = useJsonCollectionsConfigController({ store });
+ * ```
+ */
+export declare function useJsonCollectionsConfigController({ store, readOnly, autoLoad, }: UseJsonCollectionsConfigControllerOptions): CollectionsConfigController;

package/dist/collection_editor/useSafeSnackbarController.d.ts

@@ -0,0 +1,2 @@
+import { useSnackbarController } from "@rebasepro/core";
+export declare function useSafeSnackbarController(): ReturnType<typeof useSnackbarController> | undefined;

package/dist/collection_editor_ui.d.ts

@@ -6,3 +6,7 @@ export { CollectionStudioView } from "./collection_editor/ui/collection_editor/C
 export type { CollectionStudioViewProps } from "./collection_editor/ui/collection_editor/CollectionStudioView";
 export { CollectionsStudioView } from "./collection_editor/ui/collection_editor/CollectionsStudioView";
 export type { CollectionsStudioViewProps } from "./collection_editor/ui/collection_editor/CollectionsStudioView";
+export { RouterCollectionStudioView } from "./collection_editor/ui/collection_editor/RouterCollectionStudioView";
+export type { RouterCollectionStudioViewProps } from "./collection_editor/ui/collection_editor/RouterCollectionStudioView";
+export { RouterCollectionsStudioView } from "./collection_editor/ui/collection_editor/RouterCollectionsStudioView";
+export type { RouterCollectionsStudioViewProps } from "./collection_editor/ui/collection_editor/RouterCollectionsStudioView";