@rebasepro/plugin-data-enhancement 0.2.1 → 0.2.3

package/dist/admin/src/collection_editor/CollectionEditorDialogsContext.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+/**
+ * Holds the dialog state + rendering props that ConfigControllerProvider
+ * sets and CollectionEditorDialogs reads.
+ *
+ * This indirection exists because ConfigControllerProvider is a root-scope
+ * plugin provider that wraps <RebaseShell>, therefore living ABOVE the CMS
+ * context providers (CollectionRegistryContext, NavigationStateContext,
+ * UrlContext).  The actual dialog components need those contexts, so they
+ * must render inside the shell tree.
+ */
+export interface CollectionEditorDialogsState {
+    /** Props for the active CollectionEditorDialog, or undefined when closed. */
+    collectionDialogProps: Record<string, any> | undefined;
+    /** Props for the active PropertyFormDialog, or undefined when closed. */
+    propertyDialogProps: Record<string, any> | undefined;
+}
+export declare const CollectionEditorDialogsContext: React.Context<CollectionEditorDialogsState | undefined>;
+export declare function useCollectionEditorDialogsState(): CollectionEditorDialogsState | undefined;

package/dist/admin/src/collection_editor/ConfigControllerProvider.d.ts

@@ -0,0 +1,41 @@
+import React from "react";
+import { User } from "@rebasepro/types";
+import { CollectionsConfigController } from "./types/config_controller";
+import { CollectionEditorController } from "./types/collection_editor_controller";
+import { CollectionEditorPermissionsBuilder } from "./types/config_permissions";
+import { CollectionInference } from "./types/collection_inference";
+import { CollectionGenerationCallback } from "./api/generateCollectionApi";
+export declare const ConfigControllerContext: React.Context<CollectionsConfigController>;
+export declare const CollectionEditorContext: React.Context<CollectionEditorController>;
+export interface ConfigControllerProviderProps {
+    /**
+     * Controller for managing the collections' config.
+     */
+    collectionConfigController: CollectionsConfigController;
+    /**
+     * Callback used to infer the schema from the data.
+     */
+    collectionInference?: CollectionInference;
+    /**
+     * Use this builder to define the permissions for the configuration per user.
+     */
+    configPermissions?: CollectionEditorPermissionsBuilder;
+    extraView?: {
+        View: React.ComponentType<{
+            path: string;
+        }>;
+        icon: React.ReactNode;
+    };
+    pathSuggestions?: string[];
+    getUser?: (uid: string) => User | null;
+    getData?: (path: string, parentPaths: string[]) => Promise<object[]>;
+    onAnalyticsEvent?: (event: string, params?: object) => void;
+    /**
+     * Callback function for generating/modifying collections.
+     * The plugin is API-agnostic - the consumer provides the implementation.
+     */
+    generateCollection?: CollectionGenerationCallback;
+}
+export declare const ConfigControllerProvider: React.NamedExoticComponent<ConfigControllerProviderProps & {
+    children?: React.ReactNode;
+}>;

package/dist/admin/src/collection_editor/_cms_internals.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Internal re-exports for the collection editor module.
+ * This avoids circular imports by pointing directly at source files
+ * rather than going through the CMS barrel (index.ts).
+ */
+export { useCollectionRegistryController } from "../hooks/navigation/contexts/CollectionRegistryContext";
+export { useNavigationStateController } from "../hooks/navigation/contexts/NavigationStateContext";
+export { useUrlController } from "../hooks/navigation/contexts/UrlContext";
+export { useSideEntityController } from "../hooks/useSideEntityController";
+export { useBreadcrumbsController } from "../hooks/useBreadcrumbsController";
+export { FieldCaption } from "../components/FieldCaption";
+export { SearchIconsView } from "../components/SearchIconsView";
+export { PropertyConfigBadge } from "../components/PropertyConfigBadge";
+export { EntityCollectionTable } from "../components/EntityCollectionTable";
+export { VirtualTableInput } from "../components/EntityCollectionTable/fields/VirtualTableInput";
+export { ArrayContainer } from "../components/ArrayContainer";
+export type { ArrayEntryParams } from "../components/ArrayContainer";
+export { useSelectionController } from "../components/EntityCollectionView/useSelectionController";
+export { ImportFileUpload } from "../data_import/components/ImportFileUpload";
+export { ImportSaveInProgress } from "../data_import/components/ImportSaveInProgress";
+export { useImportConfig } from "../data_import/hooks/useImportConfig";
+export { getInferenceType } from "../data_import/utils/get_import_inference_type";
+export { convertDataToEntity } from "../data_import/utils/data";
+export type { ImportConfig } from "../data_import/types";
+export { DataNewPropertiesMapping } from "../data_import/components/DataNewPropertiesMapping";
+export { ImportNewPropertyFieldPreview } from "../data_import/components/ImportNewPropertyFieldPreview";
+export { getFieldConfig, getFieldId, getDefaultFieldConfig, getDefaultFieldId, DEFAULT_FIELD_CONFIGS } from "../components/field_configs";
+export { getPropertyInPath, getResolvedPropertyInPath, getDefaultPropertiesOrder, getPropertiesWithPropertiesOrder } from "../util/property_utils";
+export { resolveEntityAction, resolveEntityView } from "../util/resolutions";

package/dist/admin/src/collection_editor/api/generateCollectionApi.d.ts

@@ -0,0 +1,77 @@
+import { EntityCollection } from "@rebasepro/types";
+export interface GenerateCollectionRequest {
+    /** User's natural language description of what they want */
+    prompt: string;
+    /** Other collections in the project (for context/relationships). Limit to 30. */
+    existingCollections: Partial<EntityCollection>[];
+    /** Optional for generate, required for modifications. If provided, modifies this collection */
+    existingCollection?: Partial<EntityCollection>;
+}
+/** Operation types for modifying a collection */
+export type CollectionOperationType = "add" | "modify" | "delete";
+/** A single operation describing what changed */
+export interface CollectionOperation {
+    op: CollectionOperationType;
+    path: string;
+    value?: unknown;
+}
+/** Result from collection generation, including optional delta operations */
+export interface GenerateCollectionResult {
+    collection: EntityCollection;
+    operations?: CollectionOperation[];
+}
+/**
+ * Callback type for generating or modifying a collection.
+ * The plugin is API-agnostic - consumers implement the actual API call.
+ */
+export type CollectionGenerationCallback = (request: GenerateCollectionRequest) => Promise<GenerateCollectionResult>;
+export declare class CollectionGenerationApiError extends Error {
+    code?: string;
+    constructor(message: string, code?: string);
+}
+/**
+ * Default endpoint for AI collection generation
+ */
+export declare const DEFAULT_COLLECTION_GENERATION_ENDPOINT = "https://api.rebase.pro/collections/generate";
+/**
+ * Props for building a collection generation callback
+ */
+export interface BuildCollectionGenerationCallbackProps {
+    /**
+     * Function to get the auth token (e.g., from Firebase Auth)
+     * This is typically `authController.getAuthToken` from `@rebasepro/client-firebase`
+     */
+    getAuthToken: () => Promise<string>;
+    /**
+     * Optional custom API endpoint for collection generation.
+     * Defaults to the Rebase SaaS API endpoint.
+     */
+    apiEndpoint?: string;
+}
+/**
+ * Build a callback for AI collection generation.
+ * This helper allows self-hosted Rebase users to enable the AI collection
+ * generation feature.
+ *
+ * @example
+ * ```tsx
+ * import { RebaseCMS } from "@rebasepro/admin";
+ * import { buildCollectionGenerationCallback } from "@rebasepro/admin/collection_editor";
+ * import { useFirebaseAuthController } from "@rebasepro/client-firebase";
+ *
+ * const authController = useFirebaseAuthController({ firebaseApp });
+ *
+ * export function App() {
+ *     return (
+ *         <RebaseCMS
+ *             collectionEditor={{
+ *                 generateCollection: buildCollectionGenerationCallback({
+ *                     getAuthToken: authController.getAuthToken
+ *                 })
+ *             }}
+ *         />
+ *     );
+ * }
+ * ```
+ */
+export declare function buildCollectionGenerationCallback({ getAuthToken, apiEndpoint }: BuildCollectionGenerationCallbackProps): CollectionGenerationCallback;

package/dist/admin/src/collection_editor/index.d.ts

@@ -0,0 +1,16 @@
+export { useCollectionEditorController } from "./useCollectionEditorController";
+export { useCollectionsConfigController } from "./useCollectionsConfigController";
+export { useLocalCollectionsConfigController } from "./useLocalCollectionsConfigController";
+export { validateCollectionJson, type CollectionValidationError, type CollectionValidationResult } from "./validateCollectionJson";
+export type { CollectionsConfigController, DeleteCollectionParams, SaveCollectionParams, UpdateCollectionParams, CollectionsSetupInfo, UpdatePropertiesOrderParams, UpdateKanbanColumnsOrderParams } from "./types/config_controller";
+export type { CollectionEditorController } from "./types/collection_editor_controller";
+export type { CollectionEditorPermissions, CollectionEditorPermissionsBuilder } from "./types/config_permissions";
+export type { CollectionInference } from "./types/collection_inference";
+export { buildCollectionGenerationCallback, CollectionGenerationApiError, DEFAULT_COLLECTION_GENERATION_ENDPOINT } from "./api/generateCollectionApi";
+export type { CollectionGenerationCallback, GenerateCollectionRequest, GenerateCollectionResult, CollectionOperation, CollectionOperationType, BuildCollectionGenerationCallbackProps } from "./api/generateCollectionApi";
+export { MissingReferenceWidget } from "./ui/MissingReferenceWidget";
+export * from "./ui/collection_editor/util";
+export type { CollectionEditorDialogProps } from "./ui/collection_editor/CollectionEditorDialog";
+export type { CollectionStudioViewProps } from "./ui/collection_editor/CollectionStudioView";
+export type { CollectionsStudioViewProps } from "./ui/collection_editor/CollectionsStudioView";
+export type { PropertyFormProps, OnPropertyChangedParams } from "./ui/collection_editor/PropertyEditView";

package/dist/admin/src/collection_editor/pgColumnToProperty.d.ts

@@ -0,0 +1,6 @@
+import { EntityCollection, TableMetadata } from "@rebasepro/types";
+/**
+ * Builds a partial EntityCollection from PostgreSQL table metadata.
+ * This is used when creating a new collection from an existing database table.
+ */
+export declare function buildCollectionFromTableMetadata(tableName: string, metadata: TableMetadata): Partial<EntityCollection>;

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

@@ -0,0 +1,59 @@
+import { CollectionEditorPermissionsBuilder } from "./config_permissions";
+import { CollectionsConfigController } from "./config_controller";
+import { Entity, EntityCollection, Property } from "@rebasepro/types";
+/**
+ * Controller to open the collection editor dialog.
+ * @group Hooks and utilities
+ */
+export interface CollectionEditorController {
+    editCollection: (props: {
+        id?: string;
+        path?: string;
+        parentCollectionSlugs: string[];
+        parentEntityIds: string[];
+        parentCollection?: EntityCollection;
+        existingEntities?: Entity<any>[];
+        /**
+         * Initial view to open: "general", "display", or "properties"
+         */
+        initialView?: "general" | "display" | "properties";
+        /**
+         * If true, expand the Kanban configuration section
+         */
+        expandKanban?: boolean;
+    }) => void;
+    createCollection: (props: {
+        initialValues?: {
+            group?: string;
+            path?: string;
+            name?: string;
+            databaseId?: string;
+        };
+        /**
+         * 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;
+        parentCollectionSlugs: string[];
+        parentEntityIds: string[];
+        parentCollection?: EntityCollection;
+        redirect: boolean;
+        sourceClick?: string;
+    }) => void;
+    editProperty: (props: {
+        propertyKey?: string;
+        property?: Property;
+        currentPropertiesOrder?: string[];
+        editedCollectionId: string;
+        parentCollectionSlugs: string[];
+        parentEntityIds: string[];
+        collection: EntityCollection;
+        existingEntities: Entity<any>[];
+    }) => void;
+    /**
+     * The config controller that this editor represents.
+     */
+    configController: CollectionsConfigController;
+    configPermissions: CollectionEditorPermissionsBuilder;
+    pathSuggestions: string[] | undefined;
+}

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

@@ -0,0 +1,10 @@
+import { EntityCollection, 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
+ * @param parentCollectionPaths - Array of parent collection paths for subcollections
+ * @param databaseId - Optional database ID for multi-database setups
+ * @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>;

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

@@ -0,0 +1,98 @@
+import { EntityCollection, NavigationGroupMapping, Property } from "@rebasepro/types";
+export interface CollectionsSetupInfo {
+    status: "ongoing" | "complete" | "error";
+    error: string | null;
+}
+/**
+ * Use this controller to access the configuration that is stored externally,
+ * and not defined in code.
+ */
+export interface CollectionsConfigController {
+    loading: boolean;
+    collections?: EntityCollection[];
+    /**
+     * If true, the configuration cannot be modified.
+     * Use readOnlyReason to explain why.
+     */
+    readOnly?: boolean;
+    /**
+     * Reason why the configuration is read-only.
+     */
+    readOnlyReason?: string;
+    /**
+     * Status information about the automatic collections setup process.
+     * Stored in the project config document at `collectionsSetup`.
+     */
+    collectionsSetup?: CollectionsSetupInfo;
+    getCollection: (id: string) => EntityCollection;
+    saveCollection: <M extends {
+        [Key: string]: any;
+    }>(params: SaveCollectionParams<M>) => Promise<void>;
+    updateCollection: <M extends {
+        [Key: string]: any;
+    }>(params: UpdateCollectionParams<M>) => Promise<void>;
+    saveProperty: (params: SavePropertyParams) => Promise<void>;
+    deleteProperty: (params: DeletePropertyParams) => Promise<void>;
+    deleteCollection: (props: DeleteCollectionParams) => Promise<void>;
+    /**
+     * Update the properties order of a collection (used for column reordering).
+     */
+    updatePropertiesOrder: (params: UpdatePropertiesOrderParams) => Promise<void>;
+    /**
+     * Update the Kanban columns order for a collection.
+     */
+    updateKanbanColumnsOrder: (params: UpdateKanbanColumnsOrderParams) => Promise<void>;
+    navigationEntries: NavigationGroupMapping[];
+    saveNavigationEntries: (entries: NavigationGroupMapping[]) => Promise<void>;
+}
+export type UpdateCollectionParams<M extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    collectionData: Partial<EntityCollection<M>>;
+    previousId?: string;
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
+};
+export type SaveCollectionParams<M extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    collectionData: EntityCollection<M>;
+    previousId?: string;
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
+};
+export type SavePropertyParams = {
+    path: string;
+    propertyKey: string;
+    namespace?: string;
+    newPropertiesOrder?: string[];
+    property: Property;
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
+};
+export type DeletePropertyParams = {
+    path: string;
+    propertyKey: string;
+    namespace?: string;
+    newPropertiesOrder?: string[];
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
+};
+export type DeleteCollectionParams = {
+    id: string;
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
+};
+export type UpdatePropertiesOrderParams = {
+    fullPath: string;
+    parentCollectionSlugs: string[];
+    parentEntityIds: string[];
+    collection: EntityCollection;
+    newPropertiesOrder: string[];
+};
+export type UpdateKanbanColumnsOrderParams = {
+    fullPath: string;
+    parentCollectionSlugs: string[];
+    parentEntityIds: string[];
+    collection: EntityCollection;
+    kanbanColumnProperty: string;
+    newColumnsOrder: string[];
+};

package/dist/admin/src/collection_editor/types/config_permissions.d.ts

@@ -0,0 +1,19 @@
+import { EntityCollection } from "@rebasepro/types";
+export type CollectionEditorPermissionsBuilder<USER = any, EC extends EntityCollection = EntityCollection> = (params: {
+    user: USER | null;
+    collection?: EC;
+}) => CollectionEditorPermissions;
+export type CollectionEditorPermissions = {
+    /**
+     * Is the user allowed to create new collections.
+     */
+    createCollections: boolean;
+    /**
+     * Is the user allowed to modify this collection
+     */
+    editCollections: boolean;
+    /**
+     * Is the user allowed to delete this collection
+     */
+    deleteCollections: boolean;
+};

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

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

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

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

package/dist/admin/src/collection_editor/ui/collection_editor/AICollectionGeneratorPopover.d.ts

@@ -0,0 +1,36 @@
+import React from "react";
+import { EntityCollection } from "@rebasepro/types";
+import { CollectionGenerationCallback, CollectionOperation } from "../../api/generateCollectionApi";
+export interface AICollectionGeneratorPopoverProps {
+    /**
+     * Current collection being edited (if modifying an existing collection)
+     */
+    existingCollection?: EntityCollection<any>;
+    /**
+     * Callback when a collection is generated or modified.
+     * Includes the collection and optionally the operations that were applied.
+     */
+    onGenerated: (collection: EntityCollection, operations?: CollectionOperation[]) => void;
+    /**
+     * Callback function for generating/modifying collections.
+     * The plugin is API-agnostic - the consumer provides the implementation.
+     */
+    generateCollection: CollectionGenerationCallback;
+    /**
+     * Optional custom trigger button. If not provided, a default AI button is used.
+     */
+    trigger?: React.ReactNode | any;
+    /**
+     * Size of the button
+     */
+    size?: "small" | "medium" | "large";
+    /**
+     * Whether to show the label text
+     */
+    showLabel?: boolean;
+    /**
+     * Optional analytics callback
+     */
+    onAnalyticsEvent?: (event: string, params?: object) => void;
+}
+export declare function AICollectionGeneratorPopover({ existingCollection, onGenerated, generateCollection, trigger, size, showLabel, onAnalyticsEvent }: AICollectionGeneratorPopoverProps): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/collection_editor/ui/collection_editor/AIModifiedPathsContext.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import { CollectionOperation } from "../../api/generateCollectionApi";
+export interface AIModifiedPathsContextType {
+    /** Set of paths that were modified by AI */
+    modifiedPaths: Set<string>;
+    /** Counter that increments each time AI modifies the collection - use in keys to force remount */
+    generationCounter: number;
+    /** Add paths from operations */
+    addModifiedPaths: (operations: CollectionOperation[]) => void;
+    /** Clear a specific path (when user edits that field) */
+    clearPath: (path: string) => void;
+    /** Clear all paths (on save or cancel) */
+    clearAllPaths: () => void;
+    /** Check if a path is modified */
+    isPathModified: (path: string) => boolean;
+}
+export declare function AIModifiedPathsProvider({ children }: {
+    children: React.ReactNode | any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useAIModifiedPaths(): AIModifiedPathsContextType | null;

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

@@ -0,0 +1,71 @@
+import * as React from "react";
+import { Entity, EntityCollection, User } from "@rebasepro/types";
+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 {
+    open: boolean;
+    isNewCollection: boolean;
+    initialValues?: {
+        slug?: string;
+        name?: string;
+    };
+    /**
+     * 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;
+    editedCollectionId?: string;
+    path?: string;
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
+    handleClose: (collection?: EntityCollection) => void;
+    configController: CollectionsConfigController;
+    collectionInference?: CollectionInference;
+    extraView?: {
+        View: React.ComponentType<{
+            path: string;
+        }>;
+        icon: React.ReactNode | any;
+    };
+    getUser?: (uid: string) => User | null;
+    getData?: (path: string, parentPaths: string[]) => Promise<object[]>;
+    parentCollection?: EntityCollection;
+    existingEntities?: Entity<any>[];
+    /**
+     * Initial view to open when editing: "general", "display", or "properties".
+     * For new collections, this is ignored.
+     */
+    initialView?: "general" | "display" | "properties";
+    /**
+     * If true, auto-expand the Kanban configuration section.
+     */
+    expandKanban?: boolean;
+    /**
+     * Callback function for generating/modifying collections.
+     * The plugin is API-agnostic - the consumer provides the implementation.
+     */
+    generateCollection?: CollectionGenerationCallback;
+    /**
+     * Optional analytics callback
+     */
+    onAnalyticsEvent?: (event: string, params?: object) => void;
+    /**
+     * If true, it indicates that the editor is rendered inline (not in a dialog) and therefore updates headers and footers to adapt to the layout.
+     */
+    fullScreen?: boolean;
+    /**
+     * List of unmapped database tables available for import.
+     */
+    unmappedTables?: string[];
+    /**
+     * Callback to fetch column metadata for a table.
+     */
+    onFetchTableMetadata?: (tableName: string) => Promise<TableMetadata | undefined>;
+}
+export declare function CollectionEditorDialog(props: CollectionEditorDialogProps): import("react/jsx-runtime").JSX.Element;
+export declare function CollectionEditor(props: CollectionEditorDialogProps & {
+    handleCancel: () => void;
+    setFormDirty: (dirty: boolean) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/collection_editor/ui/collection_editor/CollectionEditorWelcomeView.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+import { EntityCollection } from "@rebasepro/types";
+import { CollectionGenerationCallback } from "../../api/generateCollectionApi";
+export declare function CollectionEditorWelcomeView({ path, parentCollection, onContinue, existingCollectionPaths, generateCollection, onAnalyticsEvent, unmappedTables, onImportFromTable }: {
+    path: string;
+    parentCollection?: EntityCollection;
+    onContinue: (importData?: object[], propertiesOrder?: string[]) => void;
+    existingCollectionPaths?: string[];
+    generateCollection?: CollectionGenerationCallback;
+    onAnalyticsEvent?: (event: string, params?: object) => void;
+    unmappedTables?: string[];
+    onImportFromTable?: (tableName: string) => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function TemplateButton({ title, subtitle, icon, onClick }: {
+    title: string;
+    icon: React.ReactNode | any;
+    subtitle: string;
+    onClick?: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/collection_editor/ui/collection_editor/CollectionJsonImportDialog.d.ts

@@ -0,0 +1,7 @@
+import { EntityCollection } from "@rebasepro/types";
+export interface CollectionJsonImportDialogProps {
+    open: boolean;
+    onClose: () => void;
+    onImport: (collection: EntityCollection) => void;
+}
+export declare function CollectionJsonImportDialog({ open, onClose, onImport }: CollectionJsonImportDialogProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,16 @@
+import React from "react";
+import { EntityCollection, PropertyConfig, User } from "@rebasepro/types";
+type CollectionEditorFormProps = {
+    showErrors: boolean;
+    isNewCollection: boolean;
+    propertyErrorsRef?: React.MutableRefObject<any>;
+    onPropertyError: (propertyKey: string, namespace: string | undefined, error?: Record<string, any>) => void;
+    setDirty?: (dirty: boolean) => void;
+    extraIcon: React.ReactNode | any;
+    getUser?: (uid: string) => User | null;
+    getData?: () => Promise<object[]>;
+    doCollectionInference?: (collection: EntityCollection) => Promise<Partial<EntityCollection> | null> | undefined;
+    propertyConfigs: Record<string, PropertyConfig>;
+};
+export declare function CollectionPropertiesEditorForm({ showErrors, isNewCollection, propertyErrorsRef, onPropertyError, setDirty, extraIcon, getUser, getData, doCollectionInference, propertyConfigs }: CollectionEditorFormProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/collection_editor/ui/collection_editor/CollectionRLSTab.d.ts

@@ -0,0 +1,12 @@
+/** Postgres RLS policy shape — defined inline to avoid depending on @rebasepro/studio */
+export interface PostgresPolicy {
+    policyname: string;
+    tablename: string;
+    permissive: "PERMISSIVE" | "RESTRICTIVE";
+    roles: string[];
+    cmd: "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "ALL";
+    qual: string | null;
+    with_check: string | null;
+    status?: "live" | "code_only" | "both";
+}
+export declare function CollectionRLSTab(): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,5 @@
+import { CollectionEditorDialogProps } from "./CollectionEditorDialog";
+export type CollectionStudioViewProps = Omit<CollectionEditorDialogProps, "open" | "isNewCollection" | "editedCollectionId" | "handleClose" | "handleCancel"> & {
+    collectionId?: string | "new";
+};
+export declare function CollectionStudioView({ collectionId, ...props }: CollectionStudioViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/collection_editor/ui/collection_editor/CollectionYupValidation.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare const CollectionEditorSchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    table: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    table: string;
+    slug: string;
+}, {
+    name: string;
+    table: string;
+    slug: string;
+}>;

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

@@ -0,0 +1,5 @@
+import { CollectionsConfigController } from "../../types/config_controller";
+export interface CollectionsStudioViewProps {
+    configController: CollectionsConfigController;
+}
+export declare function CollectionsStudioView({ configController }: CollectionsStudioViewProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,3 @@
+export declare function DisplaySettingsForm({ expandKanban }: {
+    expandKanban?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/collection_editor/ui/collection_editor/EnumForm.d.ts

@@ -0,0 +1,12 @@
+import { EnumValueConfig } from "@rebasepro/types";
+type EnumFormProps = {
+    enumValues: EnumValueConfig[];
+    onValuesChanged?: (enumValues: EnumValueConfig[]) => void;
+    onError?: (error: boolean) => void;
+    updateIds: boolean;
+    disabled: boolean;
+    allowDataInference?: boolean;
+    getData?: () => Promise<string[]>;
+};
+export declare function EnumForm({ enumValues, onValuesChanged, onError, updateIds, disabled, allowDataInference, getData }: EnumFormProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+import type { EntityCollection } from "@rebasepro/types";
+export declare function GeneralSettingsForm({ isNewCollection, existingPaths, existingIds, parentCollection }: {
+    isNewCollection: boolean;
+    existingPaths?: string[];
+    existingIds?: string[];
+    parentCollection?: EntityCollection;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/collection_editor/ui/collection_editor/GetCodeDialog.d.ts

@@ -0,0 +1,6 @@
+import { EntityCollection } from "@rebasepro/types";
+export declare function GetCodeDialog({ collection, onOpenChange, open }: {
+    onOpenChange: (open: boolean) => void;
+    collection: EntityCollection;
+    open: boolean;
+}): import("react/jsx-runtime").JSX.Element;