@rebasepro/admin 0.0.1-canary.eae7889 → 0.0.1-canary.eb08332

package/dist/collection_editor/serializable_types.d.ts

@@ -0,0 +1,370 @@
+/**
+ * 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 `toSerializableCollectionConfig` / `fromSerializableCollectionConfig` from
+ * `./serializable_utils` to convert between the original and serializable forms.
+ *
+ * @module
+ */
+import type { ArrayPropertyValidationSchema, CollectionSize, EnumValues, FileType, FilterPreset, FilterValues, ImageResize, JoinStep, KanbanConfig, NavigationGroupMapping, NumberPropertyValidationSchema, OnAction, PropertyConditions, PropertyValidationSchema, SecurityRule, ViewMode } 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;
+    /** Key of the named storage backend to use (see `StorageConfig.storageSource`). */
+    storageSource?: string;
+}
+/** 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;
+    storage?: SerializableStorageConfig;
+    userSelect?: boolean;
+    email?: 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";
+}
+/** 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
+ * `() => CollectionConfig` 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 `CollectionConfig` / `BaseCollectionConfig`.
+ *
+ * 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 SerializableCollectionConfig {
+    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;
+    engine?: string;
+    dataSource?: 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?: readonly 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<SerializableCollectionConfig[]>;
+    /** Save (create or update) a single collection by its slug. */
+    save(slug: string, data: SerializableCollectionConfig): 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.
+ *
+ * - `toSerializableCollectionConfig` / `toSerializableProperty` — strip non-serializable fields
+ * - `fromSerializableCollectionConfig` / `fromSerializableProperty` — reconstruct original types
+ *
+ * @module
+ */
+import type { CollectionConfig, Properties, Property } from "@rebasepro/types";
+import type { SerializableCollectionConfig, SerializableProperties, SerializableProperty } 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 `CollectionConfig` 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 toSerializableCollectionConfig(collection: CollectionConfig): SerializableCollectionConfig;
+/**
+ * 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 `SerializableCollectionConfig` back to an `CollectionConfig`.
+ *
+ * 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 fromSerializableCollectionConfig(serialized: SerializableCollectionConfig): CollectionConfig;

package/dist/collection_editor/types/collection_editor_controller.d.ts

@@ -1,6 +1,5 @@
-import { CollectionEditorPermissionsBuilder } from "./config_permissions";
 import { CollectionsConfigController } from "./config_controller";
-import { Entity, EntityCollection, Property } from "@rebasepro/types";
+import { Entity, CollectionConfig, Property } from "@rebasepro/types";
 /**
  * Controller to open the collection editor dialog.
  * @group Hooks and utilities
@@ -9,8 +8,9 @@ export interface CollectionEditorController {
     editCollection: (props: {
         id?: string;
         path?: string;
-        parentCollectionIds: string[];
-        parentCollection?: EntityCollection;
+        parentCollectionSlugs: string[];
+        parentEntityIds: string[];
+        parentCollection?: CollectionConfig;
         existingEntities?: Entity<any>[];
         /**
          * Initial view to open: "general", "display", or "properties"
@@ -32,9 +32,10 @@ export interface CollectionEditorController {
          * A collection to duplicate from. If provided, the new collection will be
          * pre-populated with the same properties (but with empty name, path, and id).
          */
-        copyFrom?: EntityCollection;
-        parentCollectionIds: string[];
-        parentCollection?: EntityCollection;
+        copyFrom?: CollectionConfig;
+        parentCollectionSlugs: string[];
+        parentEntityIds: string[];
+        parentCollection?: CollectionConfig;
         redirect: boolean;
         sourceClick?: string;
     }) => void;
@@ -43,14 +44,14 @@ export interface CollectionEditorController {
         property?: Property;
         currentPropertiesOrder?: string[];
         editedCollectionId: string;
-        parentCollectionIds: string[];
-        collection: EntityCollection;
+        parentCollectionSlugs: string[];
+        parentEntityIds: string[];
+        collection: CollectionConfig;
         existingEntities: Entity<any>[];
     }) => void;
     /**
      * The config controller that this editor represents.
      */
     configController: CollectionsConfigController;
-    configPermissions: CollectionEditorPermissionsBuilder;
     pathSuggestions: string[] | undefined;
 }

package/dist/collection_editor/types/collection_inference.d.ts

@@ -1,4 +1,4 @@
-import { EntityCollection, FilterValues } from "@rebasepro/types";
+import { CollectionConfig, FilterValues } from "@rebasepro/types";
 /**
  * This function is used to infer the configuration of a collection given its path.
  * @param path - The path of the collection
@@ -7,4 +7,4 @@ import { EntityCollection, FilterValues } from "@rebasepro/types";
  * @param initialFilter - Optional filter values from the collection configuration
  * @param initialSort - Optional sort configuration from the collection
  */
-export type CollectionInference = (path: string, parentCollectionPaths: string[], databaseId?: string, initialFilter?: FilterValues<string>, initialSort?: [string, "asc" | "desc"]) => Promise<Partial<EntityCollection> | null>;
+export type CollectionInference = (path: string, parentCollectionPaths: string[], databaseId?: string, initialFilter?: FilterValues<string>, initialSort?: [string, "asc" | "desc"]) => Promise<Partial<CollectionConfig> | null>;

package/dist/collection_editor/types/config_controller.d.ts

@@ -1,4 +1,4 @@
-import { EntityCollection, NavigationGroupMapping, Property } from "@rebasepro/types";
+import { CollectionConfig, NavigationGroupMapping, Property } from "@rebasepro/types";
 export interface CollectionsSetupInfo {
     status: "ongoing" | "complete" | "error";
     error: string | null;
@@ -9,7 +9,7 @@ export interface CollectionsSetupInfo {
  */
 export interface CollectionsConfigController {
     loading: boolean;
-    collections?: EntityCollection[];
+    collections?: CollectionConfig[];
     /**
      * If true, the configuration cannot be modified.
      * Use readOnlyReason to explain why.
@@ -24,7 +24,7 @@ export interface CollectionsConfigController {
      * Stored in the project config document at `collectionsSetup`.
      */
     collectionsSetup?: CollectionsSetupInfo;
-    getCollection: (id: string) => EntityCollection;
+    getCollection: (id: string) => CollectionConfig;
     saveCollection: <M extends {
         [Key: string]: any;
     }>(params: SaveCollectionParams<M>) => Promise<void>;
@@ -47,15 +47,17 @@ export interface CollectionsConfigController {
 }
 export type UpdateCollectionParams<M extends Record<string, unknown> = Record<string, unknown>> = {
     id: string;
-    collectionData: Partial<EntityCollection<M>>;
+    collectionData: Partial<CollectionConfig<M>>;
     previousId?: string;
-    parentCollectionIds?: string[];
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
 };
 export type SaveCollectionParams<M extends Record<string, unknown> = Record<string, unknown>> = {
     id: string;
-    collectionData: EntityCollection<M>;
+    collectionData: CollectionConfig<M>;
     previousId?: string;
-    parentCollectionIds?: string[];
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
 };
 export type SavePropertyParams = {
     path: string;
@@ -63,29 +65,34 @@ export type SavePropertyParams = {
     namespace?: string;
     newPropertiesOrder?: string[];
     property: Property;
-    parentCollectionIds?: string[];
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
 };
 export type DeletePropertyParams = {
     path: string;
     propertyKey: string;
     namespace?: string;
     newPropertiesOrder?: string[];
-    parentCollectionIds?: string[];
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
 };
 export type DeleteCollectionParams = {
     id: string;
-    parentCollectionIds?: string[];
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
 };
 export type UpdatePropertiesOrderParams = {
     fullPath: string;
-    parentCollectionIds: string[];
-    collection: EntityCollection;
+    parentCollectionSlugs: string[];
+    parentEntityIds: string[];
+    collection: CollectionConfig;
     newPropertiesOrder: string[];
 };
 export type UpdateKanbanColumnsOrderParams = {
     fullPath: string;
-    parentCollectionIds: string[];
-    collection: EntityCollection;
+    parentCollectionSlugs: string[];
+    parentEntityIds: string[];
+    collection: CollectionConfig;
     kanbanColumnProperty: string;
     newColumnsOrder: string[];
 };

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

@@ -1,11 +1,13 @@
-import { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { CollectionConfig } from "@rebasepro/types";
 /**
  * Component rendered at the end of the Kanban board to add new columns (enum values).
  * Opens a dialog to input a new enum value for the column property.
  */
-export declare function AddKanbanColumnAction({ collection, fullPath, parentCollectionIds, columnProperty }: {
-    collection: EntityCollection;
+export declare function AddKanbanColumnAction({ collection, fullPath, parentCollectionSlugs, parentEntityIds, columnProperty }: {
+    collection: CollectionConfig;
     fullPath: string;
-    parentCollectionIds: string[];
+    parentCollectionSlugs: string[];
+    parentEntityIds: string[];
     columnProperty: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): React.JSX.Element;

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

@@ -1,10 +1,12 @@
-import { EntityCollection, EntityTableController, Property } from "@rebasepro/types";
-export declare function CollectionViewHeaderAction({ propertyKey, onHover, property, path, parentCollectionIds, collection, tableController }: {
+import { CollectionConfig, EntityTableController, Property } from "@rebasepro/types";
+import React from "react";
+export declare function CollectionViewHeaderAction({ propertyKey, onHover, property, path, parentCollectionSlugs, parentEntityIds, collection, tableController }: {
     property: Property;
     propertyKey: string;
     onHover: boolean;
     path: string;
-    parentCollectionIds: string[];
-    collection: EntityCollection;
+    parentCollectionSlugs: string[];
+    parentEntityIds: string[];
+    collection: CollectionConfig;
     tableController: EntityTableController;
-}): import("react/jsx-runtime").JSX.Element;
+}): React.JSX.Element;

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

@@ -1,2 +1,2 @@
 import { CollectionActionsProps } from "@rebasepro/types";
-export declare function EditorCollectionAction({ path, parentCollectionIds, collection, tableController }: CollectionActionsProps): import("react/jsx-runtime").JSX.Element;
+export declare function EditorCollectionAction({ path, parentCollectionSlugs, parentEntityIds, collection, tableController }: CollectionActionsProps): import("react").JSX.Element;

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

@@ -1,2 +1,2 @@
 import { CollectionActionsProps } from "@rebasepro/types";
-export declare function EditorCollectionActionStart({ path, parentCollectionIds, collection, tableController }: CollectionActionsProps): import("react/jsx-runtime").JSX.Element;
+export declare function EditorCollectionActionStart({ path, parentCollectionSlugs, parentEntityIds, collection, tableController }: CollectionActionsProps): import("react").JSX.Element;

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

@@ -1,2 +1,2 @@
 import { PluginFormActionProps } from "@rebasepro/types";
-export declare function EditorEntityAction({ path, parentCollectionIds, collection, formContext }: PluginFormActionProps): import("react/jsx-runtime").JSX.Element;
+export declare function EditorEntityAction({ path, parentCollectionSlugs, parentEntityIds, collection, formContext }: PluginFormActionProps): import("react").JSX.Element;

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

@@ -1,2 +1,2 @@
 import { PluginHomePageActionsProps } from "@rebasepro/types";
-export declare function HomePageEditorCollectionAction({ slug, collection }: PluginHomePageActionsProps): import("react/jsx-runtime").JSX.Element;
+export declare function HomePageEditorCollectionAction({ slug, collection }: PluginHomePageActionsProps): import("react").JSX.Element;

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

@@ -1,10 +1,12 @@
-import { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { CollectionConfig } from "@rebasepro/types";
 /**
  * Component rendered when Kanban view is missing orderProperty configuration.
  * Provides a CTA button to open the collection editor to configure Kanban.
  */
-export declare function KanbanSetupAction({ collection, fullPath, parentCollectionIds }: {
-    collection: EntityCollection;
+export declare function KanbanSetupAction({ collection, fullPath, parentCollectionSlugs, parentEntityIds }: {
+    collection: CollectionConfig;
     fullPath: string;
-    parentCollectionIds: string[];
-}): import("react/jsx-runtime").JSX.Element;
+    parentCollectionSlugs: string[];
+    parentEntityIds: string[];
+}): React.JSX.Element;

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

@@ -1,3 +1,3 @@
 export declare function MissingReferenceWidget({ path: pathProp }: {
     path: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

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

@@ -1 +1 @@
-export declare function NewCollectionButton(): import("react/jsx-runtime").JSX.Element | null;
+export declare function NewCollectionButton(): import("react").JSX.Element | null;

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

@@ -1,2 +1,2 @@
 import { PluginHomePageAdditionalCardsProps } from "@rebasepro/types";
-export declare function NewCollectionCard({ group, context }: PluginHomePageAdditionalCardsProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function NewCollectionCard({ group, context }: PluginHomePageAdditionalCardsProps): import("react").JSX.Element | null;