@rebasepro/studio 0.0.1-canary.09e5ec5

package/dist/types/src/types/user_management_delegate.d.ts

@@ -0,0 +1,121 @@
+import { Role, User } from "../users";
+/**
+ * Result of creating a new user via admin flow.
+ * Contains the created user plus information about how credentials were delivered.
+ */
+export interface UserCreationResult<USER extends User = User> {
+    /** The created user */
+    user: USER;
+    /** Whether an invitation email was sent to the user */
+    invitationSent: boolean;
+    /**
+     * Temporary password (only present when email service is not configured).
+     * This is returned one-time and should be shown to the admin to share manually.
+     */
+    temporaryPassword?: string;
+}
+/**
+ * Delegate to manage users, roles, and their permissions.
+ * This interface allows the CMS to be completely agnostic of the underlying
+ * authentication provider or backend.
+ *
+ * @group Models
+ */
+export interface UserManagementDelegate<USER extends User = User> {
+    /**
+     * Are the users and roles currently being fetched?
+     */
+    loading: boolean;
+    /**
+     * List of users managed by the CMS.
+     */
+    users: USER[];
+    /**
+     * Optional error if users failed to load.
+     */
+    usersError?: Error;
+    /**
+     * Function to get a user by its uid. This is used to show
+     * user information when assigning ownership of an entity.
+     * @param uid
+     */
+    getUser: (uid: string) => USER | null;
+    /**
+     * Search users with server-side pagination.
+     * When provided, the CMS will use this for the users table
+     * instead of loading all users into memory.
+     */
+    searchUsers?: (options: {
+        search?: string;
+        limit?: number;
+        offset?: number;
+        orderBy?: string;
+        orderDir?: "asc" | "desc";
+        roleId?: string;
+    }) => Promise<{
+        users: USER[];
+        total: number;
+    }>;
+    /**
+     * Save a user (create or update)
+     * @param user
+     */
+    saveUser?: (user: USER) => Promise<USER>;
+    /**
+     * Create a new user with invitation/password generation support.
+     * Returns additional info about how the credentials were delivered.
+     * Falls back to saveUser if not provided.
+     */
+    createUser?: (user: USER) => Promise<UserCreationResult<USER>>;
+    /**
+     * Reset the password for an existing user.
+     * Returns a temporary password if no email service is configured,
+     * or a flag indicating an email invitation was sent.
+     */
+    resetPassword?: (user: USER) => Promise<UserCreationResult<USER>>;
+    /**
+     * Delete a user
+     * @param user
+     */
+    deleteUser?: (user: USER) => Promise<void>;
+    /**
+     * List of roles defined in the CMS.
+     */
+    roles?: Role[];
+    /**
+     * Optional error if roles failed to load.
+     */
+    rolesError?: Error;
+    /**
+     * Save a role (create or update)
+     * @param role
+     */
+    saveRole?: (role: Role) => Promise<void>;
+    /**
+     * Delete a role
+     * @param role
+     */
+    deleteRole?: (role: Role) => Promise<void>;
+    /**
+     * Is the currently logged in user an admin?
+     */
+    isAdmin?: boolean;
+    /**
+     * If true, the UI will allow the user to create the default roles (admin, editor, viewer).
+     */
+    allowDefaultRolesCreation?: boolean;
+    /**
+     * Should collection config permissions be included?
+     */
+    includeCollectionConfigPermissions?: boolean;
+    /**
+     * Optionally define roles for a given user. This is useful when the roles
+     * are coming from a separate provider than the one issuing the tokens.
+     */
+    defineRolesFor?: (user: USER) => Promise<Role[] | undefined> | Role[] | undefined;
+    /**
+     * Optional function to bootstrap an admin user.
+     * Often used when the database is empty.
+     */
+    bootstrapAdmin?: () => Promise<void>;
+}

package/dist/types/src/types/websockets.d.ts

@@ -0,0 +1,78 @@
+import { Entity } from "./entities";
+export interface WebSocketErrorPayload {
+    error?: string | {
+        message: string;
+        code?: string;
+    };
+    message?: string;
+    code?: string;
+}
+export interface WebSocketMessage {
+    type: string;
+    payload?: unknown;
+    subscriptionId?: string;
+    requestId?: string;
+    entities?: Entity<Record<string, unknown>>[];
+    entity?: Entity<Record<string, unknown>> | null;
+    error?: string;
+}
+export interface CollectionUpdateMessage extends WebSocketMessage {
+    type: "collection_update";
+    subscriptionId: string;
+    entities: Entity<Record<string, unknown>>[];
+}
+export interface EntityUpdateMessage extends WebSocketMessage {
+    type: "entity_update";
+    subscriptionId: string;
+    entity: Entity<Record<string, unknown>> | null;
+}
+/**
+ * Lightweight patch message sent to collection subscribers when a single
+ * entity is created, updated, or deleted. The client can merge this into
+ * its cached collection data for near-instant cross-tab updates without
+ * waiting for a full collection refetch.
+ */
+export interface CollectionEntityPatchMessage extends WebSocketMessage {
+    type: "collection_entity_patch";
+    subscriptionId: string;
+    entityId: string;
+    /** The updated entity, or null if deleted */
+    entity: Entity<Record<string, unknown>> | null;
+}
+/**
+ * Column metadata returned by table introspection.
+ */
+export interface TableColumnInfo {
+    column_name: string;
+    data_type: string;
+    udt_name: string;
+    is_nullable: string;
+    column_default: string | null;
+    character_maximum_length: number | null;
+    /** Enum values, populated for USER-DEFINED (enum) columns */
+    enum_values?: string[];
+}
+export interface TableForeignKeyInfo {
+    column_name: string;
+    foreign_table_name: string;
+    foreign_column_name: string;
+}
+export interface TableJunctionInfo {
+    junction_table_name: string;
+    source_column_name: string;
+    target_table_name: string;
+    target_column_name: string;
+}
+export interface TablePolicyInfo {
+    policy_name: string;
+    roles: string[];
+    cmd: string;
+    qual?: string;
+    with_check?: string;
+}
+export interface TableMetadata {
+    columns: TableColumnInfo[];
+    foreignKeys: TableForeignKeyInfo[];
+    junctions: TableJunctionInfo[];
+    policies: TablePolicyInfo[];
+}

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

@@ -0,0 +1,2 @@
+export * from "./user";
+export * from "./roles";

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

@@ -0,0 +1,22 @@
+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/dist/types/src/users/user.d.ts

@@ -0,0 +1,46 @@
+/**
+ * This interface represents a user.
+ * It has some of the same fields as a Firebase User.
+ * Note that in the default implementation, we simply take the Firebase user
+ * and use it as a Rebase user, so that means that even if they are not mapped
+ * in this interface, it contains all the methods of the former, such as `delete`,
+ * `getIdToken`, etc.
+ *
+ * @group Models
+ */
+export type User = {
+    /**
+     * The user's unique ID, scoped to the project.
+     */
+    readonly uid: string;
+    /**
+     * The display name of the user.
+     */
+    readonly displayName: string | null;
+    /**
+     * The email of the user.
+     */
+    readonly email: string | null;
+    /**
+     * The profile photo URL of the user.
+     */
+    readonly photoURL: string | null;
+    /**
+     * The provider used to authenticate the user.
+     */
+    readonly providerId: string;
+    /**
+     *
+     */
+    readonly isAnonymous: boolean;
+    /**
+     * Role IDs assigned to this user (e.g. ["admin", "editor"]).
+     * These are plain string IDs — use the UserManagementDelegate to look up full Role objects.
+     */
+    roles?: string[];
+    /**
+     * The date and time when the user was created.
+     */
+    createdAt?: Date | string | null;
+    getIdToken?: (forceRefresh?: boolean) => Promise<string>;
+};

package/dist/ui/src/components/Alert.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+export interface AlertProps {
+    children: React.ReactNode;
+    onDismiss?: () => void;
+    color?: "error" | "warning" | "info" | "success" | "base";
+    size?: "small" | "medium" | "large";
+    action?: React.ReactNode;
+    className?: string;
+    outerClassName?: string;
+    style?: React.CSSProperties;
+}
+export declare const Alert: React.FC<AlertProps>;

package/dist/ui/src/components/Autocomplete.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+export type AutocompleteProps = {
+    children: React.ReactNode;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    className?: string;
+};
+export declare const useAutoComplete: ({ ref }: {
+    ref: React.MutableRefObject<HTMLDivElement | null>;
+}) => {
+    inputFocused: boolean;
+    autoCompleteOpen: boolean;
+    setAutoCompleteOpen: React.Dispatch<React.SetStateAction<boolean>>;
+};
+export declare function Autocomplete({ children, open, setOpen, className }: AutocompleteProps): import("react/jsx-runtime").JSX.Element;
+export type AutocompleteItemProps = {
+    children: React.ReactNode;
+    onClick?: () => void;
+    className?: string;
+};
+export declare const AutocompleteItem: React.NamedExoticComponent<AutocompleteItemProps>;

package/dist/ui/src/components/Avatar.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+export interface AvatarProps {
+    src?: string;
+    alt?: string;
+    children?: React.ReactNode;
+    className?: string;
+    outerClassName?: string;
+    hover?: boolean;
+    style?: React.CSSProperties;
+}
+export declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/ui/src/components/Badge.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+export type BadgeColor = "primary" | "secondary" | "warning" | "error";
+export interface BadgeProps {
+    color?: BadgeColor;
+    children: React.ReactNode;
+    invisible?: boolean;
+}
+export declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLDivElement>>;

package/dist/ui/src/components/BooleanSwitch.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+export type BooleanSwitchProps = {
+    value: boolean | null;
+    className?: string;
+    disabled?: boolean;
+    size?: "smallest" | "small" | "medium" | "large";
+} & ({
+    allowIndeterminate: true;
+    onValueChange?: (newValue: boolean | null) => void;
+} | {
+    allowIndeterminate?: false;
+    onValueChange?: (newValue: boolean) => void;
+});
+export declare const BooleanSwitch: React.ForwardRefExoticComponent<BooleanSwitchProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/ui/src/components/BooleanSwitchWithLabel.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import { BooleanSwitchProps } from "./BooleanSwitch";
+export type BooleanSwitchWithLabelProps = BooleanSwitchProps & {
+    position?: "start" | "end";
+    invisible?: boolean;
+    label?: React.ReactNode;
+    error?: boolean;
+    autoFocus?: boolean;
+    fullWidth?: boolean;
+    className?: string;
+    inputClassName?: string;
+};
+/**
+ * Simple boolean switch.
+ *
+ */
+export declare const BooleanSwitchWithLabel: ({ value, position, size, invisible, onValueChange, error, label, autoFocus, disabled, className, fullWidth, inputClassName, ...props }: BooleanSwitchWithLabelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/Button.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+export type ButtonProps<C extends React.ElementType = "button"> = {
+    children?: React.ReactNode;
+    variant?: "filled" | "outlined" | "text";
+    disabled?: boolean;
+    color?: "primary" | "secondary" | "text" | "error" | "neutral";
+    size?: "small" | "medium" | "large" | "xl" | "2xl";
+    startIcon?: React.ReactNode;
+    fullWidth?: boolean;
+    className?: string;
+    component?: C;
+    onClick?: React.MouseEventHandler<any>;
+} & React.ComponentPropsWithoutRef<C>;
+export declare const Button: React.FC<ButtonProps<any>>;

package/dist/ui/src/components/Card.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+type CardProps = {
+    children: React.ReactNode;
+    style?: React.CSSProperties;
+    onClick?: (e?: React.MouseEvent) => void;
+    className?: string;
+};
+declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;
+export { Card };

package/dist/ui/src/components/CenteredView.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+export type CenteredViewProps = {
+    children: React.ReactNode;
+    maxWidth?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "4xl" | "5xl" | "6xl" | "7xl";
+    outerClassName?: string;
+    className?: string;
+    fullScreen?: boolean;
+};
+export declare const CenteredView: React.ForwardRefExoticComponent<CenteredViewProps & React.RefAttributes<HTMLDivElement>>;

package/dist/ui/src/components/Checkbox.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+export interface CheckboxProps {
+    checked: boolean;
+    id?: string;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    padding?: boolean;
+    size?: "smallest" | "small" | "medium" | "large";
+    color?: "primary" | "secondary";
+    "aria-label"?: string;
+}
+export declare const Checkbox: React.MemoExoticComponent<({ id, checked, indeterminate, padding, disabled, size, onCheckedChange, color, "aria-label": ariaLabel }: CheckboxProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/ui/src/components/Chip.d.ts

@@ -0,0 +1,26 @@
+import React from "react";
+import { CHIP_COLORS } from "../util";
+export type ChipColorScheme = {
+    color: string;
+    text: string;
+    /** Background color override for dark mode */
+    darkColor?: string;
+    /** Text color override for dark mode */
+    darkText?: string;
+};
+export type ChipColorKey = keyof typeof CHIP_COLORS;
+export interface ChipProps {
+    className?: string;
+    children: React.ReactNode;
+    size?: "smallest" | "small" | "medium" | "large";
+    colorScheme?: ChipColorScheme | ChipColorKey;
+    error?: boolean;
+    outlined?: boolean;
+    onClick?: () => void;
+    icon?: React.ReactNode;
+    style?: React.CSSProperties;
+}
+/**
+ * @group Preview components
+ */
+export declare function Chip({ children, colorScheme, error, outlined, onClick, icon, size, className, style }: ChipProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/CircularProgress.d.ts

@@ -0,0 +1,5 @@
+export type CircularProgressProps = {
+    size?: "smallest" | "small" | "medium" | "large";
+    className?: string;
+};
+export declare function CircularProgress({ size, className }: CircularProgressProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/CircularProgressCenter.d.ts

@@ -0,0 +1,11 @@
+import { CircularProgressProps } from "./CircularProgress";
+/**
+ *
+ * @param text
+ * @param props
+
+ * @ignore
+ */
+export declare function CircularProgressCenter({ text, ...props }: CircularProgressProps & {
+    text?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/Collapse.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+interface CollapseProps {
+    children?: React.ReactNode;
+    className?: string;
+    in?: boolean;
+    duration?: number;
+}
+export declare const Collapse: React.MemoExoticComponent<({ children, className, in: isOpen, duration }: CollapseProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/ui/src/components/ColorPicker.d.ts

@@ -0,0 +1,30 @@
+import { ChipColorKey } from "./Chip";
+export interface ColorPickerProps {
+    /**
+     * Currently selected color key
+     */
+    value?: ChipColorKey;
+    /**
+     * Callback when color selection changes. Passes undefined when "Auto" is selected.
+     */
+    onChange: (colorKey: ChipColorKey | undefined) => void;
+    /**
+     * Size of the color swatches
+     */
+    size?: "small" | "medium";
+    /**
+     * Whether to show the "Auto" option that clears the selection
+     */
+    allowClear?: boolean;
+    /**
+     * Whether the picker is disabled
+     */
+    disabled?: boolean;
+}
+/**
+ * A color picker component that displays a grid of predefined CHIP_COLORS.
+ * Used for selecting colors for enum values, tags, and other chip-based UI elements.
+ *
+ * @group Form components
+ */
+export declare function ColorPicker({ value, onChange, size, allowClear, disabled }: ColorPickerProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/Container.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+export type ContainerProps = {
+    children: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+    maxWidth?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "4xl" | "5xl" | "6xl" | "7xl";
+};
+export declare const Container: React.ForwardRefExoticComponent<ContainerProps & React.RefAttributes<HTMLDivElement>>;

package/dist/ui/src/components/DateTimeField.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+export type DateTimeFieldProps = {
+    value?: Date | null;
+    onChange?: (date: Date | null) => void;
+    mode?: "date" | "date_time";
+    disabled?: boolean;
+    clearable?: boolean;
+    error?: boolean;
+    size?: "smallest" | "small" | "medium" | "large";
+    label?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    inputClassName?: string;
+    invisible?: boolean;
+    locale?: string;
+    /**
+     * IANA timezone string (e.g., "America/New_York", "Europe/London").
+     * Used to display and input dates in the specified timezone.
+     * The value passed to onChange will always be in UTC.
+     * If not provided, uses the user's local timezone.
+     */
+    timezone?: string;
+};
+export declare const DateTimeField: React.FC<DateTimeFieldProps>;

package/dist/ui/src/components/DebouncedTextField.d.ts

@@ -0,0 +1,2 @@
+import { TextFieldProps } from "./index";
+export declare function DebouncedTextField<T extends string | number>(props: TextFieldProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/Dialog.d.ts

@@ -0,0 +1,39 @@
+import React from "react";
+export type DialogProps = {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+    className?: string;
+    containerClassName?: string;
+    fullWidth?: boolean;
+    fullHeight?: boolean;
+    fullScreen?: boolean;
+    scrollable?: boolean;
+    maxWidth?: keyof typeof widthClasses;
+    modal?: boolean;
+    onOpenAutoFocus?: (e: Event) => void;
+    onEscapeKeyDown?: (e: KeyboardEvent) => void;
+    onPointerDownOutside?: (e: Event) => void;
+    onInteractOutside?: (e: Event) => void;
+    /**
+     * If `true`, the dialog will not focus the first focusable element when opened.
+     */
+    disableInitialFocus?: boolean;
+    portalContainer?: HTMLElement | null;
+};
+declare const widthClasses: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    "2xl": string;
+    "3xl": string;
+    "4xl": string;
+    "5xl": string;
+    "6xl": string;
+    "7xl": string;
+    full: string;
+};
+export declare const Dialog: ({ open, onOpenChange, children, className, containerClassName, fullWidth, fullHeight, fullScreen, scrollable, maxWidth, modal, onOpenAutoFocus, onEscapeKeyDown, onPointerDownOutside, onInteractOutside, disableInitialFocus, portalContainer }: DialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/src/components/DialogActions.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+export declare function DialogActions({ children, position, translucent, className }: {
+    children: React.ReactNode;
+    position?: "sticky" | "absolute";
+    translucent?: boolean;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/DialogContent.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+export declare function DialogContent({ children, className, fullHeight, includeMargin }: {
+    children: React.ReactNode;
+    includeMargin?: boolean;
+    fullHeight?: boolean;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/DialogTitle.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { TypographyProps, TypographyVariant } from "./Typography";
+export type DialogContentProps = TypographyProps & {
+    children: React.ReactNode;
+    hidden?: boolean;
+    className?: string;
+    includeMargin?: boolean;
+    variant?: TypographyVariant;
+};
+export declare function DialogTitle({ children, hidden, className, variant, gutterBottom, includeMargin, ...props }: DialogContentProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/ErrorBoundary.d.ts

@@ -0,0 +1,11 @@
+import React, { ErrorInfo, PropsWithChildren } from "react";
+export declare class ErrorBoundary extends React.Component<PropsWithChildren<Record<string, unknown>>, {
+    error: Error | null;
+}> {
+    constructor(props: any);
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    componentDidCatch(error: Error, _errorInfo: ErrorInfo): void;
+    render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}

package/dist/ui/src/components/ExpandablePanel.d.ts

@@ -0,0 +1,12 @@
+import React, { PropsWithChildren } from "react";
+export declare function ExpandablePanel({ title, children, invisible, expanded, onExpandedChange, initiallyExpanded, titleClassName, asField, className, innerClassName }: PropsWithChildren<{
+    title: React.ReactNode;
+    invisible?: boolean;
+    initiallyExpanded?: boolean;
+    expanded?: boolean;
+    onExpandedChange?: (expanded: boolean) => void;
+    titleClassName?: string;
+    asField?: boolean;
+    className?: string;
+    innerClassName?: string;
+}>): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/FileUpload.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+export interface FileUploadError {
+    message: string;
+    code: string;
+}
+export type OnFileUploadRejected = (fileRejections: {
+    file: File;
+    errors: readonly FileUploadError[];
+}[], event: object) => void;
+export type OnFilesUploadAdded = (files: File[]) => void;
+export type FileUploadProps = {
+    accept: Record<string, string[]>;
+    onFilesAdded: OnFilesUploadAdded;
+    onFilesRejected?: OnFileUploadRejected;
+    maxSize?: number;
+    disabled?: boolean;
+    maxFiles?: number;
+    title?: React.ReactNode;
+    uploadDescription?: React.ReactNode;
+    preventDropOnDocument?: boolean;
+    size?: "small" | "medium" | "large";
+};
+export declare function FileUpload({ accept, onFilesAdded, onFilesRejected, maxSize, disabled, maxFiles, title, uploadDescription, children, preventDropOnDocument, size }: React.PropsWithChildren<FileUploadProps>): import("react/jsx-runtime").JSX.Element;