@rebasepro/plugin-data-enhancement 0.1.2 → 0.2.3

package/LICENSE

@@ -1,114 +1,22 @@
-Business Source License 1.1
+MIT License
 
-Parameters
+Copyright (c) 2026 Rebase
 
-Licensor:             Rebase S.L.
-Licensed Work:        Rebase CMS packages:
-                      cli
-                      collection_editor
-                      collection_editor_firebase
-                      data_enhancement
-                      data_export
-                      data_export
-                      editor
-                      rebase_cloud
-                      schema_inference
-                      user_management
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-                      The Licensed Work is (c) 2024 Rebase S.L
-Additional Use Grant: You may make use of the Licensed Work, provided that
-                      you may not use the Licensed Work for a CMS Data Enhancement
-                      Service.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-                      A “CMS package” is a commercial offering that
-                      allows third parties (other than your employees and
-                      contractors) to access the functionality of the
-                      Licensed Work by using software to extend the base features of
-                      content management system controlled by such third parties.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
 
-Change Date:         Four years from the date the Licensed Work is published.
-
-Change License:      MIT
-
-For information about alternative licensing arrangements for the Software,
-please visit: https://rebase.pro
-
-Notice
-
-The Business Source License (this document, or the “License”) is not an Open
-Source license. However, the Licensed Work will eventually be made available
-under an Open Source License, as stated in this License.
-
-License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
-“Business Source License” is a trademark of MariaDB Corporation Ab.
-
------------------------------------------------------------------------------
-
-Business Source License 1.1
-
-Terms
-
-The Licensor hereby grants you the right to copy, modify, create derivative
-works, redistribute, and make non-production use of the Licensed Work. The
-Licensor may make an Additional Use Grant, above, permitting limited
-production use.
-
-Effective on the Change Date, or the fourth anniversary of the first publicly
-available distribution of a specific version of the Licensed Work under this
-License, whichever comes first, the Licensor hereby grants you rights under
-the terms of the Change License, and the rights granted in the paragraph
-above terminate.
-
-If your use of the Licensed Work does not comply with the requirements
-currently in effect as described in this License, you must purchase a
-commercial license from the Licensor, its affiliated entities, or authorized
-resellers, or you must refrain from using the Licensed Work.
-
-All copies of the original and modified Licensed Work, and derivative works
-of the Licensed Work, are subject to this License. This License applies
-separately for each version of the Licensed Work and the Change Date may vary
-for each version of the Licensed Work released by Licensor.
-
-You must conspicuously display this License on each original or modified copy
-of the Licensed Work. If you receive the Licensed Work in original or
-modified form from a third party, the terms and conditions set forth in this
-License apply to your use of that work.
-
-Any use of the Licensed Work in violation of this License will automatically
-terminate your rights under this License for the current and all other
-versions of the Licensed Work.
-
-This License does not grant you any right in any trademark or logo of
-Licensor or its affiliates (provided that you may use a trademark or logo of
-Licensor as expressly required by this License).
-
-TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
-AN “AS IS” BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
-EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
-TITLE.
-
-MariaDB hereby grants you permission to use this License’s text to license
-your works, and to refer to it using the trademark “Business Source License”,
-as long as you comply with the Covenants of Licensor below.
-
-Covenants of Licensor
-
-In consideration of the right to use this License’s text and the “Business
-Source License” name and trademark, Licensor covenants to MariaDB, and to all
-other recipients of the licensed work to be provided by Licensor:
-
-1. To specify as the Change License the GPL Version 2.0 or any later version,
-   or a license that is compatible with GPL Version 2.0 or a later version,
-   where “compatible” means that software provided under the Change License can
-   be included in a program with software provided under GPL Version 2.0 or a
-   later version. Licensor may specify additional Change Licenses without
-   limitation.
-
-2. To either: (a) specify an additional grant of rights to use that does not
-   impose any additional restriction on the right granted in this License, as
-   the Additional Use Grant; or (b) insert the text “None”.
-
-3. To specify a Change Date.
-
-4. Not to modify this License in any other way.

package/README.md

@@ -25,7 +25,7 @@ No need to add any subscription key or anything like that.
 ```tsx
 import React from "react";
 import { Rebase } from "@rebasepro/core";
-import "typeface-rubik";
+import "@fontsource/rubik";
 import "@fontsource/jetbrains-mono";
 
 import { useDataEnhancementPlugin } from "@rebasepro/data_enhancement";

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;