@firecms/collection_editor 3.0.0-alpha.9 → 3.0.0-beta.10

package/dist/types/collection_editor_controller.d.ts

@@ -1,20 +1,48 @@
+import React from "react";
 import { CollectionEditorPermissionsBuilder } from "./config_permissions";
-import { EntityCollection } from "@firecms/core";
+import { Entity, Property } from "@firecms/core";
+import { PersistedCollection } from "./persisted_collection";
 /**
  * Controller to open the collection editor dialog.
- * @category Hooks and utilities
+ * @group Hooks and utilities
  */
 export interface CollectionEditorController {
     editCollection: (props: {
-        path?: string;
+        id?: string;
         fullPath?: string;
-        parentPathSegments: string[];
-        parentCollection?: EntityCollection<any, any, any>;
+        parentCollectionIds: string[];
+        parentCollection?: PersistedCollection;
+        existingEntities?: Entity<any>[];
     }) => void;
     createCollection: (props: {
-        group?: string;
-        parentPathSegments: string[];
-        parentCollection?: EntityCollection<any, any, any>;
+        initialValues?: {
+            group?: string;
+            path?: string;
+            name?: string;
+        };
+        parentCollectionIds: string[];
+        parentCollection?: PersistedCollection;
+        redirect: boolean;
+        sourceClick?: string;
+    }) => void;
+    editProperty: (props: {
+        propertyKey?: string;
+        property?: Property;
+        currentPropertiesOrder?: string[];
+        editedCollectionId: string;
+        parentCollectionIds: string[];
+        collection: PersistedCollection;
+        existingEntities: Entity<any>[];
     }) => void;
     configPermissions: CollectionEditorPermissionsBuilder;
+    getPathSuggestions?: (path: string) => Promise<string[]>;
+    components?: {
+        /**
+         * Custom component to render the database field
+         */
+        DatabaseField?: React.ComponentType<{
+            databaseId?: string;
+            onDatabaseIdUpdate: (databaseId: string) => void;
+        }>;
+    };
 }

package/dist/types/collection_inference.d.ts

@@ -1,2 +1,2 @@
 import { EntityCollection } from "@firecms/core";
-export type CollectionInference = (path: string, collectionGroup: boolean, parentPathSegments: string[]) => Promise<EntityCollection | null>;
+export type CollectionInference = (path: string, collectionGroup: boolean, parentCollectionPaths: string[]) => Promise<Partial<EntityCollection> | null>;

package/dist/types/config_controller.d.ts

@@ -1,4 +1,4 @@
-import { CMSType, EntityCollection } from "@firecms/core";
+import { CMSType, Property } from "@firecms/core";
 import { PersistedCollection } from "./persisted_collection";
 /**
  * Use this controller to access the configuration that is stored externally,
@@ -7,18 +7,45 @@ import { PersistedCollection } from "./persisted_collection";
 export interface CollectionsConfigController {
     loading: boolean;
     collections?: PersistedCollection[];
+    getCollection: (id: string) => PersistedCollection;
     saveCollection: <M extends {
         [Key: string]: CMSType;
     }>(params: SaveCollectionParams<M>) => Promise<void>;
+    updateCollection: <M extends {
+        [Key: string]: CMSType;
+    }>(params: UpdateCollectionParams<M>) => Promise<void>;
+    saveProperty: (params: SavePropertyParams) => Promise<void>;
+    deleteProperty: (params: DeletePropertyParams) => Promise<void>;
     deleteCollection: (props: DeleteCollectionParams) => Promise<void>;
 }
+export type UpdateCollectionParams<M extends Record<string, any>> = {
+    id: string;
+    collectionData: Partial<PersistedCollection<M>>;
+    previousId?: string;
+    parentCollectionIds?: string[];
+};
 export type SaveCollectionParams<M extends Record<string, any>> = {
+    id: string;
+    collectionData: PersistedCollection<M>;
+    previousId?: string;
+    parentCollectionIds?: string[];
+};
+export type SavePropertyParams = {
     path: string;
-    collectionData: EntityCollection<M>;
-    previousPath?: string;
-    parentPathSegments?: string[];
+    propertyKey: string;
+    namespace?: string;
+    newPropertiesOrder?: string[];
+    property: Property;
+    parentCollectionIds?: string[];
 };
-export type DeleteCollectionParams = {
+export type DeletePropertyParams = {
     path: string;
-    parentPathSegments?: string[];
+    propertyKey: string;
+    namespace?: string;
+    newPropertiesOrder?: string[];
+    parentCollectionIds?: string[];
+};
+export type DeleteCollectionParams = {
+    id: string;
+    parentCollectionIds?: string[];
 };

package/dist/types/persisted_collection.d.ts

@@ -1,4 +1,6 @@
 import { EntityCollection, User } from "@firecms/core";
-export type PersistedCollection<M extends Record<string, any> = any, AdditionalKey extends string = string, UserType extends User = User> = EntityCollection<M, AdditionalKey, UserType> & {
-    ownerId: string;
+export type PersistedCollection<M extends Record<string, any> = any, UserType extends User = User> = Omit<EntityCollection<M, UserType>, "subcollections"> & {
+    ownerId?: string;
+    subcollections?: PersistedCollection<any, any>[];
+    editable?: boolean;
 };

package/dist/ui/CollectionViewHeaderAction.d.ts

@@ -0,0 +1,11 @@
+import { EntityTableController, ResolvedProperty } from "@firecms/core";
+import { PersistedCollection } from "../types/persisted_collection";
+export declare function CollectionViewHeaderAction({ propertyKey, onHover, property, fullPath, parentCollectionIds, collection, tableController }: {
+    property: ResolvedProperty;
+    propertyKey: string;
+    onHover: boolean;
+    fullPath: string;
+    parentCollectionIds: string[];
+    collection: PersistedCollection;
+    tableController: EntityTableController;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/{components → ui}/EditorCollectionAction.d.ts

@@ -1,2 +1,2 @@
 import { CollectionActionsProps } from "@firecms/core";
-export declare function EditorCollectionAction({ path: fullPath, parentPathSegments, collection, tableController }: CollectionActionsProps): import("react/jsx-runtime").JSX.Element;
+export declare function EditorCollectionAction({ path: fullPath, parentCollectionIds, collection, tableController }: CollectionActionsProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/EditorCollectionActionStart.d.ts

@@ -0,0 +1,2 @@
+import { CollectionActionsProps } from "@firecms/core";
+export declare function EditorCollectionActionStart({ path: fullPath, parentCollectionIds, collection, tableController }: CollectionActionsProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/MissingReferenceWidget.d.ts

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

package/dist/ui/NewCollectionButton.d.ts

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

package/dist/ui/PropertyAddColumnComponent.d.ts

@@ -0,0 +1,8 @@
+import { EntityTableController } from "@firecms/core";
+import { PersistedCollection } from "../types/persisted_collection";
+export declare function PropertyAddColumnComponent({ fullPath, parentCollectionIds, collection, tableController }: {
+    fullPath: string;
+    parentCollectionIds: string[];
+    collection: PersistedCollection;
+    tableController: EntityTableController;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/{components → ui}/collection_editor/CollectionDetailsForm.d.ts

@@ -1,9 +1,10 @@
 import { EntityCollection } from "@firecms/core";
-export declare function CollectionDetailsForm({ isNewCollection, reservedGroups, existingPaths, existingAliases, groups, parentCollection }: {
+export declare function CollectionDetailsForm({ isNewCollection, reservedGroups, existingPaths, existingIds, groups, parentCollection }: {
     isNewCollection: boolean;
     reservedGroups?: string[];
     existingPaths?: string[];
-    existingAliases?: string[];
+    existingIds?: string[];
     groups: string[] | null;
     parentCollection?: EntityCollection;
+    parentCollectionIds?: string[];
 }): import("react/jsx-runtime").JSX.Element;

package/dist/{components → ui}/collection_editor/CollectionEditorDialog.d.ts

@@ -1,14 +1,19 @@
 import * as React from "react";
-import { CMSType, EntityCollection, User } from "@firecms/core";
+import { Entity, EntityCollection, User } from "@firecms/core";
 import { CollectionsConfigController } from "../../types/config_controller";
 import { CollectionInference } from "../../types/collection_inference";
+import { PersistedCollection } from "../../types/persisted_collection";
 export interface CollectionEditorDialogProps {
     open: boolean;
     isNewCollection: boolean;
-    group?: string;
-    editedCollectionPath?: string;
+    initialValues?: {
+        group?: string;
+        path?: string;
+        name?: string;
+    };
+    editedCollectionId?: string;
     fullPath?: string;
-    parentPathSegments?: string[];
+    parentCollectionIds?: string[];
     handleClose: (collection?: EntityCollection) => void;
     configController: CollectionsConfigController;
     reservedGroups?: string[];
@@ -19,15 +24,14 @@ export interface CollectionEditorDialogProps {
         }>;
         icon: React.ReactNode;
     };
-    pathSuggestions?: (path: string) => Promise<string[]>;
-    getUser: (uid: string) => User | null;
-    getData?: (path: string) => Promise<object[]>;
-    parentCollection?: EntityCollection;
+    pathSuggestions?: (path?: string) => Promise<string[]>;
+    getUser?: (uid: string) => User | null;
+    getData?: (path: string, parentPaths: string[]) => Promise<object[]>;
+    parentCollection?: PersistedCollection;
+    existingEntities?: Entity<any>[];
 }
 export declare function CollectionEditorDialog(props: CollectionEditorDialogProps): import("react/jsx-runtime").JSX.Element;
-export declare function CollectionEditorDialogInternal<M extends {
-    [Key: string]: CMSType;
-}>({ isNewCollection, group, configController, editedCollectionPath, parentPathSegments, fullPath, collectionInference, handleClose, reservedGroups, extraView, handleCancel, setFormDirty, pathSuggestions, getUser, parentCollection, getData }: CollectionEditorDialogProps & {
+export declare function CollectionEditor(props: CollectionEditorDialogProps & {
     handleCancel: () => void;
     setFormDirty: (dirty: boolean) => void;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/{components → ui}/collection_editor/CollectionEditorWelcomeView.d.ts

@@ -1,11 +1,11 @@
 import React from "react";
 import { EntityCollection } from "@firecms/core";
-export declare function CollectionEditorWelcomeView({ path, pathSuggestions, parentCollection, onContinue, collections }: {
+export declare function CollectionEditorWelcomeView({ path, pathSuggestions, parentCollection, onContinue, existingCollectionPaths }: {
     path: string;
     pathSuggestions?: (path: string) => Promise<string[]>;
     parentCollection?: EntityCollection;
-    onContinue: (importData?: object[]) => void;
-    collections?: EntityCollection[];
+    onContinue: (importData?: object[], propertiesOrder?: string[]) => void;
+    existingCollectionPaths?: string[];
 }): import("react/jsx-runtime").JSX.Element;
 export declare function TemplateButton({ title, subtitle, icon, onClick }: {
     title: string;

package/dist/{components → ui}/collection_editor/CollectionPropertiesEditorForm.d.ts

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

package/dist/{components → ui}/collection_editor/CollectionYupValidation.d.ts

@@ -1,11 +1,14 @@
 import * as Yup from "yup";
 export declare const YupSchema: Yup.ObjectSchema<import("yup/lib/object").Assign<import("yup/lib/object").ObjectShape, {
+    id: import("yup/lib/string").RequiredStringSchema<string | undefined, import("yup/lib/types").AnyObject>;
     name: import("yup/lib/string").RequiredStringSchema<string | undefined, import("yup/lib/types").AnyObject>;
     path: import("yup/lib/string").RequiredStringSchema<string | undefined, import("yup/lib/types").AnyObject>;
 }>, import("yup/lib/object").AnyObject, import("yup/lib/object").TypeOfShape<import("yup/lib/object").Assign<import("yup/lib/object").ObjectShape, {
+    id: import("yup/lib/string").RequiredStringSchema<string | undefined, import("yup/lib/types").AnyObject>;
     name: import("yup/lib/string").RequiredStringSchema<string | undefined, import("yup/lib/types").AnyObject>;
     path: import("yup/lib/string").RequiredStringSchema<string | undefined, import("yup/lib/types").AnyObject>;
 }>>, import("yup/lib/object").AssertsShape<import("yup/lib/object").Assign<import("yup/lib/object").ObjectShape, {
+    id: import("yup/lib/string").RequiredStringSchema<string | undefined, import("yup/lib/types").AnyObject>;
     name: import("yup/lib/string").RequiredStringSchema<string | undefined, import("yup/lib/types").AnyObject>;
     path: import("yup/lib/string").RequiredStringSchema<string | undefined, import("yup/lib/types").AnyObject>;
 }>>>;

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

@@ -0,0 +1,4 @@
+export declare function EntityCustomViewsSelectDialog({ open, onClose }: {
+    open: boolean;
+    onClose: (selectedViewKey?: string) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/{components → ui}/collection_editor/EnumForm.d.ts

@@ -1,4 +1,3 @@
-import React from "react";
 import { EnumValueConfig } from "@firecms/core";
 type EnumFormProps = {
     enumValues: EnumValueConfig[];
@@ -9,5 +8,5 @@ type EnumFormProps = {
     allowDataInference?: boolean;
     getData?: () => Promise<string[]>;
 };
-export declare const EnumForm: React.NamedExoticComponent<EnumFormProps>;
+export declare function EnumForm({ enumValues, onValuesChanged, onError, updateIds, disabled, allowDataInference, getData }: EnumFormProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

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

package/dist/{components → ui}/collection_editor/PropertyEditView.d.ts

@@ -1,38 +1,48 @@
 import React from "react";
-import { FormikErrors, FormikProps } from "formik";
-import { EditableProperty } from "../../types/editable_properties";
-export type PropertyWithId = EditableProperty & {
+import { FormexController } from "@firecms/formex";
+import { Property, PropertyConfig } from "@firecms/core";
+export type PropertyWithId = Property & {
     id?: string;
 };
 export type OnPropertyChangedParams = {
     id?: string;
-    property: EditableProperty;
+    property: Property;
     namespace?: string;
     previousId?: string;
 };
 export type PropertyFormProps = {
     includeIdAndName?: boolean;
-    existing: boolean;
+    existingProperty: boolean;
     autoUpdateId?: boolean;
     autoOpenTypeSelect: boolean;
     inArray: boolean;
     propertyKey?: string;
     propertyNamespace?: string;
-    property?: EditableProperty;
+    property?: Property;
     onPropertyChanged?: (params: OnPropertyChangedParams) => void;
     onPropertyChangedImmediate?: boolean;
+    onDismiss?: () => void;
     onDelete?: (id?: string, namespace?: string) => void;
-    onError?: (id: string, namespace?: string, error?: FormikErrors<any>) => void;
-    initialErrors?: FormikErrors<any>;
-    forceShowErrors?: boolean;
+    onError?: (id: string, namespace?: string, error?: Record<string, any>) => void;
+    initialErrors?: Record<string, any>;
     existingPropertyKeys?: string[];
+    forceShowErrors?: boolean;
     allowDataInference: boolean;
     getData?: () => Promise<object[]>;
-    getHelpers?: (formikProps: FormikProps<PropertyWithId>) => void;
+    getController?: (formex: FormexController<PropertyWithId>) => void;
+    propertyConfigs: Record<string, PropertyConfig>;
+    collectionEditable: boolean;
 };
 export declare const PropertyForm: React.NamedExoticComponent<PropertyFormProps>;
-export declare function PropertyFormDialog({ open, onCancel, onOkClicked, onPropertyChanged, getData, ...formProps }: PropertyFormProps & {
+export declare function PropertyFormDialog({ open, onCancel, onOkClicked, onPropertyChanged, getData, collectionEditable, ...formProps }: PropertyFormProps & {
     open?: boolean;
     onOkClicked?: () => void;
     onCancel?: () => void;
 }): import("react/jsx-runtime").JSX.Element;
+export interface PropertySelectItemProps {
+    onClick?: () => void;
+    initialProperty?: PropertyWithId;
+    propertyConfig: PropertyConfig;
+    existing: boolean;
+}
+export declare function WidgetSelectViewItem({ onClick, initialProperty, propertyConfig, existing }: PropertySelectItemProps): import("react/jsx-runtime").JSX.Element;

package/dist/{components → ui}/collection_editor/PropertyFieldPreview.d.ts

@@ -1,14 +1,15 @@
-import { EditableProperty } from "../../types/editable_properties";
+import { Property, PropertyOrBuilder } from "@firecms/core";
 export declare function PropertyFieldPreview({ property, onClick, hasError, includeName, includeEditButton, selected }: {
-    property: EditableProperty;
+    property: Property;
     hasError?: boolean;
     selected?: boolean;
     includeName?: boolean;
     includeEditButton?: boolean;
     onClick?: () => void;
 }): import("react/jsx-runtime").JSX.Element;
-export declare function PropertyBuilderPreview({ name, selected, onClick }: {
+export declare function NonEditablePropertyPreview({ name, selected, onClick, property }: {
     name: string;
     selected: boolean;
     onClick?: () => void;
+    property?: PropertyOrBuilder;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/{components → ui}/collection_editor/PropertyTree.d.ts

@@ -1,24 +1,27 @@
-import { CMSType, PropertiesOrBuilders } from "@firecms/core";
+import React from "react";
+import { AdditionalFieldDelegate, CMSType, PropertiesOrBuilders, PropertyOrBuilder } from "@firecms/core";
 import { DraggableProvided } from "@hello-pangea/dnd";
-import { EditablePropertyOrBuilder } from "../../types/editable_properties";
-export declare function PropertyTree<M extends {
+export declare const PropertyTree: React.MemoExoticComponent<(<M extends {
     [Key: string]: CMSType;
-}>({ namespace, selectedPropertyKey, onPropertyClick, properties, propertiesOrder: propertiesOrderProp, errors, onPropertyMove, onPropertyRemove, className, inferredPropertyKeys }: {
+}>({ namespace, selectedPropertyKey, onPropertyClick, properties, propertiesOrder: propertiesOrderProp, additionalFields, errors, onPropertyMove, onPropertyRemove, className, inferredPropertyKeys, collectionEditable }: {
     namespace?: string;
     selectedPropertyKey?: string;
     onPropertyClick?: (propertyKey: string, namespace?: string) => void;
     properties: PropertiesOrBuilders<M>;
     propertiesOrder?: string[];
+    additionalFields?: AdditionalFieldDelegate<M>[];
     errors: Record<string, any>;
     onPropertyMove?: (propertiesOrder: string[], namespace?: string) => void;
     onPropertyRemove?: (propertyKey: string, namespace?: string) => void;
     className?: string;
     inferredPropertyKeys?: string[];
-}): import("react/jsx-runtime").JSX.Element;
-export declare function PropertyTreeEntry({ propertyKey, namespace, propertyOrBuilder, provided, selectedPropertyKey, errors, onPropertyClick, onPropertyMove, onPropertyRemove, inferredPropertyKeys }: {
+    collectionEditable: boolean;
+}) => import("react/jsx-runtime").JSX.Element)>;
+export declare function PropertyTreeEntry({ propertyKey, namespace, propertyOrBuilder, additionalField, provided, selectedPropertyKey, errors, onPropertyClick, onPropertyMove, onPropertyRemove, inferredPropertyKeys, collectionEditable }: {
     propertyKey: string;
     namespace?: string;
-    propertyOrBuilder: EditablePropertyOrBuilder;
+    propertyOrBuilder: PropertyOrBuilder;
+    additionalField?: AdditionalFieldDelegate<any>;
     selectedPropertyKey?: string;
     provided: DraggableProvided;
     errors: Record<string, any>;
@@ -26,4 +29,5 @@ export declare function PropertyTreeEntry({ propertyKey, namespace, propertyOrBu
     onPropertyMove?: (propertiesOrder: string[], namespace?: string) => void;
     onPropertyRemove?: (propertyKey: string, namespace?: string) => void;
     inferredPropertyKeys?: string[];
+    collectionEditable: boolean;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/{components → ui}/collection_editor/SubcollectionsEditTab.d.ts

@@ -2,11 +2,11 @@ import { EntityCollection, User } from "@firecms/core";
 import { CollectionsConfigController } from "../../types/config_controller";
 import { PersistedCollection } from "../../types/persisted_collection";
 import { CollectionInference } from "../../types/collection_inference";
-export declare function SubcollectionsEditTab({ collection, parentCollection, configController, collectionInference, getUser, parentPathSegments }: {
+export declare function SubcollectionsEditTab({ collection, parentCollection, configController, collectionInference, getUser, parentCollectionIds }: {
     collection: PersistedCollection;
     parentCollection?: EntityCollection;
     configController: CollectionsConfigController;
     collectionInference?: CollectionInference;
-    getUser: (uid: string) => User | null;
-    parentPathSegments?: string[];
+    getUser?: (uid: string) => User | null;
+    parentCollectionIds?: string[];
 }): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,8 @@
+import { FormexFieldProps } from "@firecms/formex";
+export declare function SwitchControl({ field, form, label, tooltip, disabled, size, allowIndeterminate }: FormexFieldProps & {
+    label: string;
+    tooltip?: string;
+    disabled?: boolean;
+    size?: "small" | "medium";
+    allowIndeterminate?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/{components → ui}/collection_editor/import/CollectionEditorImportDataPreview.d.ts

@@ -1,4 +1,4 @@
-import { ImportConfig } from "@firecms/data_import";
+import { ImportConfig } from "@firecms/data_import_export";
 import { Properties } from "@firecms/core";
 export declare function CollectionEditorImportDataPreview({ importConfig, properties, propertiesOrder }: {
     importConfig: ImportConfig;

package/dist/ui/collection_editor/import/CollectionEditorImportMapping.d.ts

@@ -0,0 +1,14 @@
+import { ImportConfig } from "@firecms/data_import_export";
+import { PropertyConfig } from "@firecms/core";
+export declare function CollectionEditorImportMapping({ importConfig, propertyConfigs, collectionEditable }: {
+    importConfig: ImportConfig;
+    propertyConfigs: Record<string, PropertyConfig>;
+    collectionEditable: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export interface PropertySelectItemProps {
+    value: string;
+    optionDisabled: boolean;
+    propertyConfig: PropertyConfig;
+    existing: boolean;
+}
+export declare function PropertySelectItem({ value, optionDisabled, propertyConfig, existing }: PropertySelectItemProps): import("react/jsx-runtime").JSX.Element;

package/dist/{components → ui}/collection_editor/import/clean_import_data.d.ts

@@ -1,5 +1,5 @@
 import { Properties } from "@firecms/core";
-import { ImportConfig } from "@firecms/data_import";
+import { ImportConfig } from "@firecms/data_import_export";
 export declare function cleanPropertiesFromImport(properties: Properties, parentSlug?: string): {
     headersMapping: ImportConfig["headersMapping"];
     properties: Properties;

package/dist/{components → ui}/collection_editor/properties/BlockPropertyField.d.ts

@@ -1,5 +1,8 @@
-export declare function BlockPropertyField({ disabled, getData, allowDataInference }: {
+import { PropertyConfig } from "@firecms/core";
+export declare function BlockPropertyField({ disabled, getData, allowDataInference, propertyConfigs, collectionEditable }: {
     disabled: boolean;
     getData?: () => Promise<object[]>;
     allowDataInference: boolean;
+    propertyConfigs: Record<string, PropertyConfig>;
+    collectionEditable: boolean;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/{components → ui}/collection_editor/properties/CommonPropertyFields.d.ts

@@ -2,9 +2,9 @@ import React from "react";
 type CommonPropertyFieldsProps = {
     showErrors: boolean;
     disabledId: boolean;
-    existingPropertyKeys?: string[];
     disabled: boolean;
     isNewProperty: boolean;
+    autoUpdateId: boolean;
 };
 export declare const CommonPropertyFields: React.ForwardRefExoticComponent<CommonPropertyFieldsProps & React.RefAttributes<HTMLDivElement>>;
 export {};

package/dist/{components → ui}/collection_editor/properties/MapPropertyField.d.ts

@@ -1,5 +1,8 @@
-export declare function MapPropertyField({ disabled, getData, allowDataInference }: {
+import { PropertyConfig } from "@firecms/core";
+export declare function MapPropertyField({ disabled, getData, allowDataInference, propertyConfigs, collectionEditable }: {
     disabled: boolean;
     getData?: () => Promise<object[]>;
     allowDataInference: boolean;
+    propertyConfigs: Record<string, PropertyConfig>;
+    collectionEditable: boolean;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/ui/collection_editor/properties/MarkdownPropertyField.d.ts

@@ -0,0 +1,4 @@
+export declare function MarkdownPropertyField({ disabled, showErrors }: {
+    disabled: boolean;
+    showErrors: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/{components → ui}/collection_editor/properties/RepeatPropertyField.d.ts

@@ -1,7 +1,10 @@
-export declare function RepeatPropertyField({ showErrors, existing, disabled, getData, allowDataInference }: {
+import { PropertyConfig } from "@firecms/core";
+export declare function RepeatPropertyField({ showErrors, existing, disabled, getData, allowDataInference, propertyConfigs, collectionEditable }: {
     showErrors: boolean;
     existing: boolean;
     disabled: boolean;
     getData?: () => Promise<object[]>;
     allowDataInference: boolean;
+    propertyConfigs: Record<string, PropertyConfig>;
+    collectionEditable: boolean;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/{components → ui}/collection_editor/properties/StringPropertyField.d.ts

@@ -1,5 +1,5 @@
 export declare function StringPropertyField({ widgetId, disabled, showErrors }: {
-    widgetId: "text_field" | "multiline" | "markdown" | "url" | "email";
+    widgetId: "text_field" | "multiline" | "email";
     disabled: boolean;
     showErrors: boolean;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/ui/collection_editor/properties/UrlPropertyField.d.ts

@@ -0,0 +1,4 @@
+export declare function UrlPropertyField({ disabled, showErrors }: {
+    disabled: boolean;
+    showErrors: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/ui/collection_editor/templates/blog_template.d.ts

@@ -0,0 +1,2 @@
+import { EntityCollection } from "@firecms/core";
+export declare const blogCollectionTemplate: EntityCollection;

package/dist/ui/collection_editor/templates/pages_template.d.ts

@@ -0,0 +1,2 @@
+import { EntityCollection } from "@firecms/core";
+export declare const pagesCollectionTemplate: EntityCollection;

package/dist/ui/collection_editor/templates/products_template.d.ts

@@ -0,0 +1,2 @@
+import { EntityCollection } from "@firecms/core";
+export declare const productsCollectionTemplate: EntityCollection;

package/dist/ui/collection_editor/templates/users_template.d.ts

@@ -0,0 +1,2 @@
+import { EntityCollection } from "@firecms/core";
+export declare const usersCollectionTemplate: EntityCollection;

package/dist/{components → ui}/collection_editor/util.d.ts

@@ -2,3 +2,4 @@ export declare function idToPropertiesPath(id: string): string;
 export declare function namespaceToPropertiesPath(namespace?: string): string;
 export declare function namespaceToPropertiesOrderPath(namespace?: string): string;
 export declare function getFullId(propertyKey: string, propertyNamespace?: string): string;
+export declare function getFullIdPath(propertyKey: string, propertyNamespace?: string): string;

package/dist/ui/collection_editor/utils/strings.d.ts

@@ -0,0 +1 @@
+export declare function camelCase(str: string): string;

package/dist/ui/collection_editor/utils/supported_fields.d.ts

@@ -0,0 +1,3 @@
+import { PropertyConfigId, PropertyConfig } from "@firecms/core";
+export declare const supportedFieldsIds: PropertyConfigId[];
+export declare const supportedFields: Record<string, PropertyConfig>;

package/dist/ui/collection_editor/utils/update_property_for_widget.d.ts

@@ -0,0 +1,2 @@
+import { Property, PropertyConfig } from "@firecms/core";
+export declare function updatePropertyFromWidget(propertyData: any, selectedWidgetId: string | undefined, propertyConfigs: Record<string, PropertyConfig>): Property;