@rebasepro/plugin-data-enhancement 0.2.3 → 0.2.5

package/dist/ui/src/components/VirtualTable/VirtualTableProps.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 import { FilterFormFieldProps } from "./VirtualTableHeader";
-export type OnRowClickParams<T extends Record<string, any>> = {
+export type OnRowClickParams<T extends Record<string, unknown>> = {
     rowData: T;
     rowIndex: number;
     event: React.SyntheticEvent;
@@ -9,7 +9,7 @@ export type OnRowClickParams<T extends Record<string, any>> = {
  * @see Table
  * @group Components
  */
-export interface VirtualTableProps<T extends Record<string, any>> {
+export interface VirtualTableProps<T extends Record<string, unknown>> {
     /**
      * Array of arbitrary data
      */
@@ -61,12 +61,12 @@ export interface VirtualTableProps<T extends Record<string, any>> {
     /**
      * In case this table should have some filters set by default
      */
-    filter?: VirtualTableFilterValues<any>;
+    filter?: VirtualTableFilterValues<string>;
     /**
      * Callback used when filters are updated
      * @param filter
      */
-    onFilterUpdate?: (filter?: VirtualTableFilterValues<any> | undefined) => void;
+    onFilterUpdate?: (filter?: VirtualTableFilterValues<string> | undefined) => void;
     /**
      * Callback when the table is scrolled
      * @param props
@@ -111,7 +111,7 @@ export interface VirtualTableProps<T extends Record<string, any>> {
      * Callback to create a filter field, displayed in the header as a dropdown
      * @param props
      */
-    createFilterField?: (props: FilterFormFieldProps<any>) => React.ReactNode;
+    createFilterField?: (props: FilterFormFieldProps<unknown>) => React.ReactNode;
     /**
      * Class name applied to the table
      */
@@ -141,9 +141,9 @@ export interface VirtualTableProps<T extends Record<string, any>> {
     /**
      * Extra data passed to the cell renderer
      */
-    extraData?: any;
+    extraData?: unknown;
 }
-export type CellRendererParams<T = any> = {
+export type CellRendererParams<T = unknown> = {
     column: VirtualTableColumn;
     columns: VirtualTableColumn[];
     columnIndex: number;
@@ -153,17 +153,17 @@ export type CellRendererParams<T = any> = {
     isScrolling?: boolean;
     sortableNodeRef?: (node: HTMLElement | null) => void;
     sortableStyle?: React.CSSProperties;
-    sortableAttributes?: Record<string, any>;
+    sortableAttributes?: Record<string, unknown>;
     isDragging?: boolean;
     isDraggable?: boolean;
     frozen?: boolean;
-    extraData?: any;
+    extraData?: unknown;
 };
 /**
  * @see Table
  * @group Components
  */
-export interface VirtualTableColumn<CustomProps = any> {
+export interface VirtualTableColumn<CustomProps = unknown> {
     /**
      * Data key for the cell value, could be "a.b.c"
      */
@@ -233,7 +233,7 @@ export type VirtualTableSort = "asc" | "desc" | undefined;
  * @see Table
  * @group Components
  */
-export type VirtualTableFilterValues<Key extends string> = Partial<Record<Key, [VirtualTableWhereFilterOp, any]>>;
+export type VirtualTableFilterValues<Key extends string> = Partial<Record<Key, [VirtualTableWhereFilterOp, unknown]>>;
 /**
  * Filter conditions in a `Query.where()` clause are specified using the
  * strings `<`, `<=`, `==`, `>=`, `>`, `array-contains`, `in`, and `array-contains-any`.

package/dist/ui/src/components/VirtualTable/VirtualTableRow.d.ts

@@ -1,3 +1,3 @@
 import React from "react";
 import { VirtualTableRowProps } from "./types";
-export declare const VirtualTableRow: React.NamedExoticComponent<VirtualTableRowProps<any>>;
+export declare const VirtualTableRow: React.NamedExoticComponent<VirtualTableRowProps<Record<string, unknown>>>;

package/dist/ui/src/components/VirtualTable/types.d.ts

@@ -1,12 +1,12 @@
 import React from "react";
 import { CellRendererParams, OnRowClickParams, OnVirtualTableColumnResizeParams, VirtualTableColumn, VirtualTableFilterValues, VirtualTableWhereFilterOp } from "./VirtualTableProps";
 import { FilterFormFieldProps } from "./VirtualTableHeader";
-export type VirtualTableRowProps<T> = {
-    style: any;
+export type VirtualTableRowProps<T extends Record<string, unknown>> = {
+    style: React.CSSProperties;
     rowHeight: number;
     rowData: T;
     rowIndex: number;
-    onRowClick?: (props: OnRowClickParams<any>) => void;
+    onRowClick?: (props: OnRowClickParams<Record<string, unknown>>) => void;
     children: React.ReactNode[];
     columns: VirtualTableColumn[];
     hoverRow?: boolean;
@@ -19,20 +19,20 @@ export type VirtualTableContextProps<T> = {
     columns: VirtualTableColumn[];
     cellRenderer: React.ComponentType<CellRendererParams<T>>;
     currentSort: "asc" | "desc" | undefined;
-    filter?: VirtualTableFilterValues<any>;
-    onRowClick?: (props: OnRowClickParams<any>) => void;
-    onColumnSort: (key: string) => any;
+    filter?: VirtualTableFilterValues<string>;
+    onRowClick?: (props: OnRowClickParams<Record<string, unknown>>) => void;
+    onColumnSort: (key: string) => void;
     onColumnResize: (params: OnVirtualTableColumnResizeParams) => void;
     onColumnResizeEnd: (params: OnVirtualTableColumnResizeParams) => void;
-    onFilterUpdate: (column: VirtualTableColumn, filterForProperty?: [VirtualTableWhereFilterOp, any]) => void;
+    onFilterUpdate: (column: VirtualTableColumn, filterForProperty?: [VirtualTableWhereFilterOp, unknown]) => void;
     sortByProperty?: string;
     customView?: React.ReactNode;
     hoverRow: boolean;
-    createFilterField?: (props: FilterFormFieldProps<any>) => React.ReactNode;
+    createFilterField?: (props: FilterFormFieldProps<unknown>) => React.ReactNode;
     rowClassName?: (rowData: T) => string | undefined;
     endAdornment?: React.ReactNode;
     AddColumnComponent?: React.ComponentType;
     onColumnsOrderChange?: (columns: VirtualTableColumn[]) => void;
     draggingColumnId?: string | null;
-    extraData?: Record<string, any>;
+    extraData?: unknown;
 };

package/dist/ui/src/hooks/useDebounceCallback.d.ts

@@ -1 +1 @@
-export declare function useDebounceCallback<T extends (...args: any[]) => any>(callback?: T, delay?: number): T;
+export declare function useDebounceCallback<T extends (...args: any[]) => unknown>(callback?: T, delay?: number): T;

package/dist/ui/src/util/debounce.d.ts

@@ -1,7 +1,7 @@
 /**
  * @ignore
  */
-export declare function debounce<T extends (...args: any[]) => any>(func: T, wait?: number): T & Cancelable;
+export declare function debounce<T extends (...args: any[]) => unknown>(func: T, wait?: number): T & Cancelable;
 /**
  * @ignore
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/plugin-data-enhancement",
   "type": "module",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "main": "./dist/index.umd.js",
   "module": "./dist/index.es.js",
   "types": "./dist/index.d.ts",
@@ -16,12 +16,12 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@rebasepro/admin": "0.2.3",
-    "@rebasepro/common": "0.2.3",
-    "@rebasepro/types": "0.2.3",
-    "@rebasepro/ui": "0.2.3",
-    "@rebasepro/core": "0.2.3",
-    "@rebasepro/utils": "0.2.3"
+    "@rebasepro/admin": "0.2.5",
+    "@rebasepro/common": "0.2.5",
+    "@rebasepro/types": "0.2.5",
+    "@rebasepro/core": "0.2.5",
+    "@rebasepro/utils": "0.2.5",
+    "@rebasepro/ui": "0.2.5"
   },
   "peerDependencies": {
     "react": ">=19.0.0",

package/src/api.ts

@@ -25,8 +25,8 @@ export async function enhanceDataAPIStream<M extends Record<string, unknown>>(pr
 
     instructions?: string,
     firebaseToken: string,
-    onUpdate: (suggestions: Record<string, any>) => void;
-    onUpdateDelta: (propertyKey: string, partialValue: any) => void;
+    onUpdate: (suggestions: Record<string, string | number>) => void;
+    onUpdateDelta: (propertyKey: string, partialValue: string) => void;
     onError: (error: Error) => void;
     onEnd: (result: EnhancedDataResult) => void;
     host?: string;
@@ -89,10 +89,10 @@ export async function enhanceDataAPIStream<M extends Record<string, unknown>>(pr
                                 props.onEnd(data.data);
                         }
                     });
-                } catch (e: any) {
+                } catch (e: unknown) {
                     console.error("str", str);
                     console.error("Error parsing stream", e);
-                    props.onError(e);
+                    props.onError(e instanceof Error ? e : new Error(String(e)));
                 }
             }
 

package/src/components/DataEnhancementControllerProvider.tsx

@@ -58,7 +58,7 @@ export function DataEnhancementControllerProvider({
     path,
     collection,
     formContext
-}: PropsWithChildren<DataEnhancementControllerProviderProps & PluginFormActionProps<any>>) {
+}: PropsWithChildren<DataEnhancementControllerProviderProps & PluginFormActionProps>) {
 
     const [enabled, setEnabled] = useState(false);
     const [suggestions, setSuggestions] = useState<Record<string, string | number>>({});
@@ -193,7 +193,7 @@ export function DataEnhancementControllerProvider({
         }));
     }, [properties, formContext]);
 
-    const displayNeededSubscriptionSnackbar = useCallback((projectId: any) => {
+    const displayNeededSubscriptionSnackbar = useCallback((projectId: unknown) => {
         snackbarController.open({
             type: "warning",
             message: "A valid subscription is needed in order to use this function.",
@@ -207,7 +207,7 @@ export function DataEnhancementControllerProvider({
         setSuggestions({});
     }, []);
 
-    const enhance = useCallback(async (props: EnhanceParams<any>): Promise<EnhancedDataResult | null> => {
+    const enhance = useCallback(async (props: EnhanceParams<Record<string, unknown>>): Promise<EnhancedDataResult | null> => {
 
         if (!authController.user) {
             snackbarController.open({
@@ -232,10 +232,13 @@ export function DataEnhancementControllerProvider({
         const currentValues = valuesRef.current ?? {};
 
         return new Promise((resolve, reject) => {
-            function onError(e: any) {
+            function onError(e: unknown) {
                 setLoadingSuggestions([]);
-                if (e.code === "payment-required") {
-                    const projectId = e.data.projectId;
+                const err = e instanceof Error ? e : typeof e === "object" && e !== null ? e : new Error(String(e));
+                const errorObj = err as Record<string, unknown>;
+                if (errorObj.code === "payment-required") {
+                    const data = errorObj.data as Record<string, unknown> | undefined;
+                    const projectId = data?.projectId;
                     displayNeededSubscriptionSnackbar(projectId);
                 } else {
                     console.error("Enhance error", e);
@@ -286,7 +289,7 @@ export function DataEnhancementControllerProvider({
                         enhancingInProgress.current = false;
                     }
                 }).catch(onError);
-            } catch (e: any) {
+            } catch (e: unknown) {
                 onError(e);
             }
         });

package/src/index.ts

@@ -5,6 +5,5 @@ export type {
     DataEnhancementPluginProps
 } from "./useDataEnhancementPlugin";
 
-export type { SubscriptionMessageProps } from "./types/subscriptions_message_props";
 
 export * from "./editor/useEditorAIController";

package/src/tests/strings_counter.test.ts

@@ -0,0 +1,101 @@
+import { countStringCharacters } from "../utils/strings_counter";
+import type { Properties } from "@rebasepro/types";
+
+describe("countStringCharacters", () => {
+    it("counts characters in a string property", () => {
+        const values = { title: "Hello World" };
+        const properties: Properties = {
+            title: { name: "title", type: "string" }
+        };
+        expect(countStringCharacters(values, properties)).toBe(11);
+    });
+
+    it("counts characters in a number property (stringified)", () => {
+        const values = { price: 12345 };
+        const properties: Properties = {
+            price: { name: "price", type: "number" }
+        };
+        expect(countStringCharacters(values, properties)).toBe(5);
+    });
+
+    it("skips disabled properties", () => {
+        const values = { title: "Hello", hidden: "Secret" };
+        const properties: Properties = {
+            title: { name: "title", type: "string" },
+            hidden: { name: "hidden", type: "string", ui: { disabled: true } }
+        };
+        expect(countStringCharacters(values, properties)).toBe(5);
+    });
+
+    it("counts array of strings", () => {
+        const values = { tags: ["hello", "world", "test"] };
+        const properties: Properties = {
+            tags: {
+                name: "tags",
+                type: "array",
+                of: { name: "tag", type: "string" }
+            }
+        };
+        // "hello" (5) + "world" (5) + "test" (4) = 14
+        expect(countStringCharacters(values, properties)).toBe(14);
+    });
+
+    it("recurses into map properties", () => {
+        const values = {
+            address: { city: "New York", country: "USA" }
+        };
+        const properties: Properties = {
+            address: {
+                name: "address",
+                type: "map",
+                properties: {
+                    city: { name: "city", type: "string" },
+                    country: { name: "country", type: "string" }
+                }
+            }
+        };
+        // "New York" (8) + "USA" (3) = 11
+        expect(countStringCharacters(values, properties)).toBe(11);
+    });
+
+    it("returns 0 for empty values", () => {
+        const properties: Properties = {
+            title: { name: "title", type: "string" }
+        };
+        expect(countStringCharacters({}, properties)).toBe(0);
+    });
+
+    it("handles mixed property types", () => {
+        const values = {
+            title: "Hello",
+            count: 42,
+            active: true,
+            tags: ["a", "bb"]
+        };
+        const properties: Properties = {
+            title: { name: "title", type: "string" },
+            count: { name: "count", type: "number" },
+            active: { name: "active", type: "boolean" },
+            tags: {
+                name: "tags",
+                type: "array",
+                of: { name: "tag", type: "string" }
+            }
+        };
+        // "Hello" (5) + "42" (2) + "a" (1) + "bb" (2) = 10
+        expect(countStringCharacters(values, properties)).toBe(10);
+    });
+
+    it("handles null values in array gracefully", () => {
+        const values = { tags: [null, "hello", null] };
+        const properties: Properties = {
+            tags: {
+                name: "tags",
+                type: "array",
+                of: { name: "tag", type: "string" }
+            }
+        };
+        // null?.length = 0, "hello" = 5, null?.length = 0
+        expect(countStringCharacters(values, properties)).toBe(5);
+    });
+});

package/src/tests/suggestions.test.ts

@@ -0,0 +1,53 @@
+import { getAppendableSuggestion } from "../utils/suggestions";
+
+describe("getAppendableSuggestion", () => {
+    it("returns the remaining part when suggestion starts with value", () => {
+        const result = getAppendableSuggestion("Hello World", "Hello");
+        expect(result).toBe(" World");
+    });
+
+    it("returns undefined when suggestion does not start with value", () => {
+        const result = getAppendableSuggestion("Goodbye World", "Hello");
+        expect(result).toBeUndefined();
+    });
+
+    it("performs case-insensitive matching", () => {
+        const result = getAppendableSuggestion("Hello World", "hello");
+        expect(result).toBe(" World");
+    });
+
+    it("returns undefined for number suggestion", () => {
+        const result = getAppendableSuggestion(42, "4");
+        expect(result).toBeUndefined();
+    });
+
+    it("returns undefined for undefined suggestion", () => {
+        const result = getAppendableSuggestion(undefined, "hello");
+        expect(result).toBeUndefined();
+    });
+
+    it("returns undefined for non-string value", () => {
+        const result = getAppendableSuggestion("Hello", 42);
+        expect(result).toBeUndefined();
+    });
+
+    it("returns full suggestion when value is empty string", () => {
+        const result = getAppendableSuggestion("Hello World", "");
+        expect(result).toBe("Hello World");
+    });
+
+    it("handles whitespace trimming", () => {
+        const result = getAppendableSuggestion("Hello World", "Hello");
+        expect(result).toBe(" World");
+    });
+
+    it("returns empty string when suggestion equals value", () => {
+        const result = getAppendableSuggestion("Hello", "Hello");
+        expect(result).toBe("");
+    });
+
+    it("returns undefined when value is longer than suggestion", () => {
+        const result = getAppendableSuggestion("Hi", "Hello World");
+        expect(result).toBeUndefined();
+    });
+});

package/src/tests/values.test.ts

@@ -0,0 +1,83 @@
+import { flatMapEntityValues } from "../utils/values";
+
+describe("flatMapEntityValues", () => {
+    it("returns flat object unchanged", () => {
+        const values = { name: "John", age: 30 };
+        const result = flatMapEntityValues(values);
+        expect(result).toEqual({ name: "John", age: 30 });
+    });
+
+    it("flattens nested object to dot-notation keys", () => {
+        const values = {
+            address: { city: "NYC", zip: "10001" }
+        };
+        const result = flatMapEntityValues(values);
+        expect(result).toEqual({
+            "address.city": "NYC",
+            "address.zip": "10001"
+        });
+    });
+
+    it("flattens deeply nested objects", () => {
+        const values = {
+            a: { b: { c: { d: "deep" } } }
+        };
+        const result = flatMapEntityValues(values);
+        expect(result).toEqual({ "a.b.c.d": "deep" });
+    });
+
+    it("returns empty object for empty input", () => {
+        expect(flatMapEntityValues({})).toEqual({});
+    });
+
+    it("returns empty object for null input", () => {
+        expect(flatMapEntityValues(null as unknown as object)).toEqual({});
+    });
+
+    it("returns empty object for undefined input", () => {
+        expect(flatMapEntityValues(undefined as unknown as object)).toEqual({});
+    });
+
+    it("handles mixed nested and flat values", () => {
+        const values = {
+            name: "John",
+            address: { city: "NYC" },
+            active: true
+        };
+        const result = flatMapEntityValues(values);
+        expect(result).toEqual({
+            name: "John",
+            "address.city": "NYC",
+            active: true
+        });
+    });
+
+    it("handles multiple nested objects", () => {
+        const values = {
+            home: { city: "NYC" },
+            work: { city: "SF" }
+        };
+        const result = flatMapEntityValues(values);
+        expect(result).toEqual({
+            "home.city": "NYC",
+            "work.city": "SF"
+        });
+    });
+
+    it("handles numeric values in nested objects", () => {
+        const values = {
+            stats: { visits: 100, clicks: 50 }
+        };
+        const result = flatMapEntityValues(values);
+        expect(result).toEqual({
+            "stats.visits": 100,
+            "stats.clicks": 50
+        });
+    });
+
+    it("uses custom path prefix", () => {
+        const values = { name: "John" };
+        const result = flatMapEntityValues(values, "user");
+        expect(result).toEqual({ "user.name": "John" });
+    });
+});

package/src/utils/properties.ts

@@ -35,7 +35,7 @@ function getSimpleProperty(property: Property): InputProperty {
     };
 }
 
-function getSimplifiedProperty(property: Property, path: string, value?: any): Record<string, InputProperty> {
+function getSimplifiedProperty(property: Property, path: string, value?: unknown): Record<string, InputProperty> {
     if (isPropertyBuilder(property)) return {};
     if (property.type === "array") {
 
@@ -115,7 +115,7 @@ function getSimplifiedProperty(property: Property, path: string, value?: any): R
         if (property.properties) {
             const mapProperties: Record<string, InputProperty> = Object.entries(property.properties)
                 .map(([key, childProperty]) => {
-                    const childValue = value?.[key];
+                    const childValue = value && typeof value === "object" ? (value as Record<string, unknown>)[key] : undefined;
                     return getSimplifiedProperty(childProperty, key, childValue);
                 })
                 .map(o => attachPathToKeys(o, path))
@@ -149,7 +149,7 @@ function getSimplifiedProperty(property: Property, path: string, value?: any): R
 }
 
 // attach a path to every key in an object
-function attachPathToKeys(obj: Record<string, any>, path = ""): Record<string, any> {
+function attachPathToKeys(obj: Record<string, InputProperty>, path = ""): Record<string, InputProperty> {
     return Object.entries(obj)
         .map(([key, value]) => {
             const fullKey = path ? `${path}.${key}` : key;

package/src/utils/suggestions.ts

@@ -1,4 +1,4 @@
-export function getAppendableSuggestion(suggestion: string | number | undefined, value: any): string | undefined {
+export function getAppendableSuggestion(suggestion: string | number | undefined, value: unknown): string | undefined {
     const suggestionIncludesValue = typeof suggestion === "string" && typeof value === "string" && suggestion.toLowerCase().trim().startsWith(value.toLowerCase().trim());
     return (typeof value === "string" && suggestionIncludesValue)
         ? suggestion.substring(suggestion.toLowerCase().trim().indexOf(value.toLowerCase().trim()) + value.trim().length)

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

@@ -1,19 +0,0 @@
-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/components/admin/RoleChip.d.ts

@@ -1,4 +0,0 @@
-import { Role } from "@rebasepro/types";
-export declare function RoleChip({ role }: {
-    role: Role;
-}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/admin/RolesFilterSelect.d.ts

@@ -1,2 +0,0 @@
-import { CollectionActionsProps } from "@rebasepro/types";
-export declare function RolesFilterSelect({ tableController }: CollectionActionsProps<any>): import("react/jsx-runtime").JSX.Element | null;

package/dist/admin/src/components/admin/RolesView.d.ts

@@ -1,4 +0,0 @@
-import { UserManagementDelegate } from "@rebasepro/types";
-export declare function RolesView({ userManagement }: {
-    userManagement: UserManagementDelegate;
-}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/admin/UserRolesSelectField.d.ts

@@ -1,2 +0,0 @@
-import { FieldProps } from "../../types/fields";
-export declare function UserRolesSelectField({ propertyKey, value, setValue, disabled }: FieldProps): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/admin/UsersView.d.ts

@@ -1,4 +0,0 @@
-import { UserManagementDelegate } from "@rebasepro/types";
-export declare function UsersView({ userManagement }: {
-    userManagement: UserManagementDelegate;
-}): import("react/jsx-runtime").JSX.Element;

package/dist/core/src/hooks/useValidateAuthenticator.d.ts

@@ -1,21 +0,0 @@
-import { AuthController, Authenticator, RebaseData, StorageSource, User } from "@rebasepro/types";
-/**
- * This hook is used internally for validating an authenticator.
- *
- * @param authController
- * @param authentication
- * @param storageSource
- * @param data
- */
-export declare function useValidateAuthenticator<USER extends User = any>({ disabled, authController, authenticator, storageSource, data }: {
-    disabled?: boolean;
-    authController: AuthController<USER>;
-    authenticator?: boolean | Authenticator<USER>;
-    data: RebaseData;
-    storageSource: StorageSource;
-}): {
-    canAccessMainView: boolean;
-    authLoading: boolean;
-    notAllowedError: any;
-    authVerified: boolean;
-};

package/dist/core/src/util/icon_synonyms.d.ts

@@ -1 +0,0 @@
-export declare const iconSynonyms: Record<string, string>;

package/dist/core/src/util/useTraceUpdate.d.ts

@@ -1,2 +0,0 @@
-export declare function printChanged(props: any, prev: any, path?: string | undefined, depth?: number | undefined, maxDepth?: number | undefined): void;
-export declare function useTraceUpdate(props: any, maxDepth?: number): void;

package/dist/plugin-data-enhancement/src/types/subscriptions_message_props.d.ts

@@ -1,3 +0,0 @@
-export type SubscriptionMessageProps = {
-    projectId: string;
-};

package/dist/types/src/users/roles.d.ts

@@ -1,22 +0,0 @@
-export type Role = {
-    /**
-     * ID of the role
-     */
-    id: string;
-    /**
-     * Name of the role
-     */
-    name: string;
-    /**
-     * If this flag is true, the user can perform any action
-     */
-    isAdmin?: boolean;
-    /**
-     * Permissions related to editing the collections
-     */
-    config?: {
-        createCollections?: boolean;
-        editCollections?: boolean | "own";
-        deleteCollections?: boolean | "own";
-    };
-};

package/src/types/subscriptions_message_props.tsx

@@ -1 +0,0 @@
-export type SubscriptionMessageProps = { projectId: string };