@rebasepro/admin 0.0.1-canary.09e5ec5

package/dist/components/PropertyIdCopyTooltip.d.ts

@@ -0,0 +1,8 @@
+export declare function PropertyIdCopyTooltip({ propertyKey, className, children }: {
+    propertyKey: string;
+    className?: string;
+    children: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function PropertyIdCopyTooltipContent({ propertyKey }: {
+    propertyKey: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/RebaseAuthGate.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+/**
+ * Auth gate component that handles the authentication flow.
+ *
+ * - Shows a loading spinner while `authController.initialLoading` is true.
+ * - Shows the login view when no user is authenticated.
+ * - Renders `children` when a user is authenticated.
+ *
+ * **Independently usable**: Use this alone when you want auth gating
+ * without the full CMS layout or navigation.
+ *
+ * @example
+ * ```tsx
+ * <RebaseAuthGate>
+ *   <MyCustomApp />
+ * </RebaseAuthGate>
+ * ```
+ */
+export declare function RebaseAuthGate({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/RebaseCMS.d.ts

@@ -0,0 +1,10 @@
+import type { RebaseCMSConfig } from "@rebasepro/types";
+/**
+ * Declarative component to configure the CMS in Rebase.
+ * Renders nothing — purely registers config into the RebaseRegistry.
+ *
+ * When `collectionEditor` is provided, the built-in visual schema editor
+ * is auto-wired as a native feature (slots, provider, Studio view) without
+ * needing any external plugin.
+ */
+export declare function RebaseCMS({ collections, homePage, entityViews, entityActions, plugins, collectionEditor }: RebaseCMSConfig): null;

package/dist/components/RebaseLayout.d.ts

@@ -0,0 +1,32 @@
+import React from "react";
+import type { AppView } from "@rebasepro/types";
+export interface RebaseLayoutProps {
+    /** Title shown in the drawer. */
+    title?: string;
+    /** Custom AppBar to override the default. */
+    appBar?: React.ReactNode;
+    /** Custom Drawer to override the default. */
+    drawer?: React.ReactNode;
+    /** Whether to auto-open the drawer on load. */
+    autoOpenDrawer?: boolean;
+    /** Dev views passed to AdminModeSyncer (resolved from RebaseNavigation). */
+    devViews?: AppView[];
+}
+/**
+ * Layout layer — provides the Scaffold, AppBar, Drawer, and SideDialogs.
+ *
+ * Wraps the route outlet with the standard Rebase admin layout.
+ * Override individual pieces (appBar, drawer) via props.
+ *
+ * **Independently usable**: Use this when you want the Rebase layout
+ * without its default route definitions.
+ *
+ * @example
+ * ```tsx
+ * <RebaseLayout title="My Admin">
+ *   <Route path="/" element={<MyHomePage />} />
+ *   <Route path="/custom" element={<CustomView />} />
+ * </RebaseLayout>
+ * ```
+ */
+export declare function RebaseLayout(props: RebaseLayoutProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/RebaseNavigation.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+export interface RebaseNavigationProps {
+    children: React.ReactNode;
+}
+/**
+ * Navigation layer — builds and provides all CMS navigation controllers:
+ * collection registry, URL controller, navigation state, side entity,
+ * and the self-assembling Studio bridge.
+ *
+ * Also handles the collection editor config controller when enabled.
+ *
+ * **Independently usable**: Use this when you need CMS navigation
+ * (entity tables, side panels) in a custom layout.
+ *
+ * @example
+ * ```tsx
+ * <RebaseNavigation>
+ *   <MyCustomLayout>
+ *     <EntityCollectionView ... />
+ *   </MyCustomLayout>
+ * </RebaseNavigation>
+ * ```
+ */
+export declare function RebaseNavigation({ children }: RebaseNavigationProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/RebaseRouteDefs.d.ts

@@ -0,0 +1,30 @@
+import React from "react";
+export interface RebaseRouteDefsProps {
+    /** User-provided custom routes to include. */
+    children?: React.ReactNode;
+    /**
+     * Wrap function — receives the route tree and lets you wrap it in a layout.
+     * If provided, the routes are rendered inside this wrapper.
+     * If not provided, routes are rendered directly inside <RebaseRoutes>.
+     */
+    layout?: React.ReactElement;
+}
+/**
+ * Route definitions for the CMS.
+ *
+ * Defines all standard routes: home, studio home, collection view,
+ * settings, users, roles, debug, custom views, and a catch-all 404.
+ *
+ * **Independently usable**: Use this when you want Rebase routes
+ * inside your own layout/navigation setup.
+ *
+ * @example
+ * ```tsx
+ * <RebaseNavigation>
+ *   <RebaseRouteDefs layout={<MyCustomLayout />}>
+ *     <Route path="/my-custom" element={<MyView />} />
+ *   </RebaseRouteDefs>
+ * </RebaseNavigation>
+ * ```
+ */
+export declare function RebaseRouteDefs({ children, layout }: RebaseRouteDefsProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/RebaseShell.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+export interface RebaseShellProps {
+    title?: string;
+    appBar?: React.ReactNode;
+    drawer?: React.ReactNode;
+    autoOpenDrawer?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * Convenience component that composes all four CMS layers:
+ *
+ * ```
+ * <RebaseAuthGate>
+ *   <RebaseNavigation>
+ *     <RebaseRouteDefs layout={<RebaseLayout>}>
+ *       {children}
+ *     </RebaseRouteDefs>
+ *   </RebaseNavigation>
+ * </RebaseAuthGate>
+ * ```
+ *
+ * Each layer is independently usable — see their individual docs.
+ * RebaseShell is sugar that composes them all with sensible defaults.
+ */
+export declare function RebaseShell(props: RebaseShellProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ReferenceTable/EntitySelectionTable.d.ts

@@ -0,0 +1,59 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+import { Entity, FilterValues } from "@rebasepro/types";
+/**
+ * @group Components
+ */
+export interface EntitySelectionProps<M extends Record<string, unknown>> {
+    /**
+     * Allow multiple selection of values
+     */
+    multiselect?: boolean;
+    /**
+     * Entity collection config
+     */
+    collection?: EntityCollection<M>;
+    /**
+     * Absolute path of the collection.
+     * May be not set if this hook is being used in a component and the path is
+     * dynamic. If not set, the dialog won't open.
+     */
+    path: string;
+    /**
+     * If you are opening the dialog for the first time, you can select some
+     * entity ids to be displayed first.
+     */
+    selectedEntityIds?: (string | number)[];
+    /**
+     * If `multiselect` is set to `false`, you will get the selected entity
+     * in this callback.
+     * @param entity
+     * @callback
+     */
+    onSingleEntitySelected?(entity: Entity<any> | null): void;
+    /**
+     * If `multiselect` is set to `true`, you will get the selected entities
+     * in this callback.
+     * @param entities
+     * @callback
+     */
+    onMultipleEntitiesSelected?(entities: Entity<any>[]): void;
+    /**
+     * Allow selection of entities that pass the given filter only.
+     */
+    forceFilter?: FilterValues<string>;
+    /**
+     * Use this description to indicate the user what to do in this dialog.
+     */
+    description?: React.ReactNode;
+    /**
+     * Maximum number of entities that can be selected.
+     */
+    maxSelection?: number;
+}
+/**
+ * This component allows to select entities from a given collection.
+ * You probably want to open this dialog as a side view using {@link useEntitySelectionTable}
+ * @group Components
+ */
+export declare function EntitySelectionTable<M extends Record<string, unknown>>({ onSingleEntitySelected, onMultipleEntitiesSelected, multiselect, collection, path: pathInput, selectedEntityIds: selectedEntityIdsProp, description, forceFilter, maxSelection }: EntitySelectionProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/components/ReferenceWidget.d.ts

@@ -0,0 +1,30 @@
+import { Entity, EntityReference, FilterValues } from "@rebasepro/types";
+import type { PreviewSize } from "../types/components/PropertyPreviewProps";
+export type ReferenceWidgetProps<M extends Record<string, unknown>> = {
+    name?: string;
+    multiselect?: boolean;
+    value: EntityReference | EntityReference[] | null;
+    onReferenceSelected?: (params: {
+        reference: EntityReference | null;
+        entity: Entity<M> | null;
+    }) => void;
+    onMultipleReferenceSelected?: (params: {
+        references: EntityReference[] | null;
+        entities: Entity<M>[] | null;
+    }) => void;
+    path: string;
+    disabled?: boolean;
+    previewProperties?: string[];
+    /**
+     * Allow selection of entities that pass the given filter only.
+     */
+    forceFilter?: FilterValues<string>;
+    size: PreviewSize;
+    className?: string;
+    includeId?: boolean;
+    includeEntityLink?: boolean;
+};
+/**
+ * This field allows selecting reference/s.
+ */
+export declare function ReferenceWidget<M extends Record<string, unknown>>({ name, multiselect, path, disabled, value, onReferenceSelected, onMultipleReferenceSelected, previewProperties, forceFilter, size, className, includeId, includeEntityLink }: ReferenceWidgetProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/components/RelationSelector.d.ts

@@ -0,0 +1,32 @@
+import * as React from "react";
+import { Entity, EntityRelation, FilterValues, Relation } from "@rebasepro/types";
+export interface RelationItem {
+    id: string | number;
+    label: string;
+    description?: string;
+    data?: Entity;
+    relation: EntityRelation;
+}
+export interface RelationSelectorProps {
+    className?: string;
+    name?: string;
+    id?: string;
+    value?: EntityRelation | EntityRelation[] | null;
+    /** Callback returning selected EntityRelation(s) */
+    onValueChange?: (updatedValue: EntityRelation | EntityRelation[] | undefined) => void;
+    placeholder?: React.ReactNode;
+    size?: "small" | "medium";
+    useChips?: boolean;
+    disabled?: boolean;
+    error?: boolean;
+    padding?: boolean;
+    invisible?: boolean;
+    relation: Relation;
+    forceFilter?: FilterValues<string>;
+    pageSize?: number;
+    emptyPlaceholder?: string;
+    searchPlaceholder?: string;
+    noResultsText?: string;
+    loadingText?: string;
+}
+export declare const RelationSelector: React.ForwardRefExoticComponent<RelationSelectorProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/SearchIconsView.d.ts

@@ -0,0 +1,5 @@
+export interface SearchIconsProps {
+    selectedIcon?: string;
+    onIconSelected?: (icon: string) => void;
+}
+export declare function SearchIconsView({ selectedIcon, onIconSelected }: SearchIconsProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/SelectableTable/SelectableTable.d.ts

@@ -0,0 +1,95 @@
+import React from "react";
+import { CollectionSize, Entity, EntityTableController, FilterValues } from "@rebasepro/types";
+import { CellRendererParams, VirtualTableColumn } from "@rebasepro/ui";
+import { OnCellValueChange, OnColumnResizeParams } from "@rebasepro/core";
+export type SelectableTableProps<M extends Record<string, unknown>> = {
+    /**
+     * Callback when a cell value changes.
+     */
+    onValueChange?: OnCellValueChange<any, M>;
+    columns: VirtualTableColumn[];
+    cellRenderer: React.ComponentType<CellRendererParams<Entity<M>>>;
+    /**
+     * Builder for creating the buttons in each row
+     * @param entity
+     * @param size
+     */
+    tableRowActionsBuilder?: (params: {
+        entity: Entity<M>;
+        size: CollectionSize;
+        width: number;
+        frozen?: boolean;
+    }) => React.ReactNode;
+    /**
+     * Callback when anywhere on the table is clicked
+     */
+    onEntityClick?(entity: Entity<M>): void;
+    /**
+     * Callback when a column is resized
+     */
+    onColumnResize?(params: OnColumnResizeParams): void;
+    /**
+     * Should apply a different style to a row when hovering
+     */
+    hoverRow?: boolean;
+    /**
+     * Controller holding the logic for the table
+     * {@link useDataTableController}
+     * {@link EntityTableController}
+     */
+    tableController: EntityTableController<M>;
+    filterable?: boolean;
+    sortable?: boolean;
+    inlineEditing?: boolean;
+    forceFilter?: FilterValues<keyof M extends string ? keyof M : never>;
+    highlightedRow?: (data: Entity<M>) => boolean;
+    size?: CollectionSize;
+    initialScroll?: number;
+    /**
+     * Callback when the table is scrolled
+     * @param props
+     */
+    onScroll?: (props: {
+        scrollDirection: "forward" | "backward";
+        scrollOffset: number;
+        scrollUpdateWasRequested: boolean;
+    }) => void;
+    emptyComponent?: React.ReactNode;
+    endAdornment?: React.ReactNode;
+    AddColumnComponent?: React.ComponentType;
+    /**
+     * Callback when columns are reordered via drag-and-drop
+     */
+    onColumnsOrderChange?: (columns: VirtualTableColumn[]) => void;
+    /**
+     * Extra data passed to VirtualTable cells. Changes to this object
+     * bust the cell memo comparator, triggering re-render of cells
+     * even when rowData hasn't changed.
+     */
+    extraData?: Record<string, any>;
+};
+/**
+ * This component is in charge of rendering a collection table with a high
+ * degree of customization.
+ *
+ * This component is used internally by {@link EntityCollectionView} and
+ * {@link useReferenceDialog}
+ *
+ * Please note that you only need to use this component if you are building
+ * a custom view. If you just need to create a default view you can do it
+ * exclusively with config options.
+ *
+ * If you want to bind a {@link EntityCollection} to a table with the default
+ * options you see in collections in the top level navigation, you can
+ * check {@link EntityCollectionView}.
+ *
+ * The data displayed in the table is managed by a {@link EntityTableController}.
+ * You can build the default, bound to a path in the driver, by using the hook
+ * {@link useDataTableController}
+ *
+ * @see EntityCollectionTableProps
+ * @see EntityCollectionView
+ * @see VirtualTable
+ * @group Components
+ */
+export declare const SelectableTable: <M extends Record<string, unknown>>({ onValueChange, cellRenderer, onEntityClick, onColumnResize, hoverRow, size, inlineEditing, tableController: { data, dataLoading, noMoreToLoad, dataLoadingError, filterValues, setFilterValues, sortBy, setSortBy, itemCount, setItemCount, pageSize, paginationEnabled, checkFilterCombination, setPopupCell }, filterable, onScroll, initialScroll, emptyComponent, columns, forceFilter, highlightedRow, endAdornment, AddColumnComponent, onColumnsOrderChange, extraData }: SelectableTableProps<M>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/SelectableTable/SelectableTableContext.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { EntityCollectionTableController } from "@rebasepro/core";
+export declare const SelectableTableContext: React.Context<EntityCollectionTableController<Record<string, unknown>>>;
+export declare const useSelectableTableController: () => EntityCollectionTableController<any>;

package/dist/components/SelectableTable/SelectionStore.d.ts

@@ -0,0 +1,26 @@
+import { SelectedCellProps } from "@rebasepro/types";
+/**
+ * A ref-based selection store that avoids React context re-renders.
+ *
+ * The problem with putting `selectedCell` in a React context value is that
+ * ANY cell selection change triggers a context value change, which forces
+ * ALL consumers (every PropertyTableCell in the table) to re-render.
+ * This causes the DOM to be replaced between mousedown and click events,
+ * breaking `alwaysInteractive` cells (like relation selectors) where the
+ * user needs to click a button on the very first interaction.
+ *
+ * This store uses `useSyncExternalStore` so only cells whose `selected`
+ * derivation actually changed will re-render.
+ */
+export declare function createSelectionStore(): {
+    getSnapshot: () => SelectedCellProps<any> | undefined;
+    subscribe: (listener: () => void) => () => void;
+    select: (cell: SelectedCellProps<any> | undefined) => void;
+};
+export type SelectionStore = ReturnType<typeof createSelectionStore>;
+/**
+ * Hook that subscribes a cell to the selection store and returns
+ * whether THIS cell is selected. Only re-renders when the cell's
+ * `selected` boolean actually changes (not on every store update).
+ */
+export declare function useCellSelected(store: SelectionStore, propertyKey: string, entityPath: string, entityId: string | number): boolean;

package/dist/components/SelectableTable/filters/BooleanFilterField.d.ts

@@ -0,0 +1,9 @@
+import { VirtualTableWhereFilterOp } from "@rebasepro/ui";
+interface BooleanFieldProps {
+    name: string;
+    value?: [op: VirtualTableWhereFilterOp, fieldValue: any];
+    setValue: (value?: [op: VirtualTableWhereFilterOp, newValue: any]) => void;
+    title?: string;
+}
+export declare function BooleanFilterField({ name, title, value, setValue }: BooleanFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/SelectableTable/filters/DateTimeFilterField.d.ts

@@ -0,0 +1,12 @@
+import { VirtualTableWhereFilterOp } from "@rebasepro/ui";
+interface DateTimeFilterFieldProps {
+    name: string;
+    mode?: "date" | "date_time";
+    value?: [op: VirtualTableWhereFilterOp, fieldValue: any];
+    setValue: (value?: [op: VirtualTableWhereFilterOp, newValue: any]) => void;
+    isArray?: boolean;
+    title?: string;
+    timezone?: string;
+}
+export declare function DateTimeFilterField({ name, isArray, mode, value, setValue, title, timezone }: DateTimeFilterFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/SelectableTable/filters/ReferenceFilterField.d.ts

@@ -0,0 +1,15 @@
+import { VirtualTableWhereFilterOp } from "@rebasepro/ui";
+interface ReferenceFilterFieldProps {
+    name: string;
+    value?: [op: VirtualTableWhereFilterOp, fieldValue: any];
+    setValue: (filterValue?: [VirtualTableWhereFilterOp, any]) => void;
+    isArray?: boolean;
+    path?: string;
+    title?: string;
+    includeId?: boolean;
+    previewProperties?: string[];
+    hidden: boolean;
+    setHidden: (hidden: boolean) => void;
+}
+export declare function ReferenceFilterField({ value, setValue, isArray, path, includeId, previewProperties, setHidden }: ReferenceFilterFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/SelectableTable/filters/RelationFilterField.d.ts

@@ -0,0 +1,12 @@
+import { VirtualTableWhereFilterOp } from "@rebasepro/ui";
+import { EntityRelation, Relation } from "@rebasepro/types";
+interface RelationFilterFieldProps {
+    name: string;
+    value?: [VirtualTableWhereFilterOp, EntityRelation | EntityRelation[] | null];
+    setValue: (value?: [VirtualTableWhereFilterOp, EntityRelation | EntityRelation[] | null]) => void;
+    relation: Relation;
+    hidden: boolean;
+    setHidden: (value: boolean) => void;
+}
+export declare function RelationFilterField({ value, setValue, relation, name: _name, hidden: _hidden, setHidden: _setHidden }: RelationFilterFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/SelectableTable/filters/StringNumberFilterField.d.ts

@@ -0,0 +1,13 @@
+import { VirtualTableWhereFilterOp } from "@rebasepro/ui";
+import { EnumValueConfig } from "@rebasepro/types";
+interface StringNumberFilterFieldProps {
+    name: string;
+    type: "string" | "number";
+    value?: [op: VirtualTableWhereFilterOp, fieldValue: any];
+    setValue: (value?: [op: VirtualTableWhereFilterOp, newValue: any]) => void;
+    isArray?: boolean;
+    enumValues?: EnumValueConfig[];
+    title?: string;
+}
+export declare function StringNumberFilterField({ name, value, setValue, type, isArray, enumValues, title }: StringNumberFilterFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/SideDialogs.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+export type SideDialogController = {
+    blocked: boolean;
+    setBlocked: (blocked: boolean) => void;
+    setBlockedNavigationMessage: (message?: React.ReactNode) => void;
+    width?: string;
+    close: (force?: boolean) => void;
+    pendingClose: boolean;
+    setPendingClose: (pendingClose: boolean) => void;
+};
+/**
+ * This hook is used to access the properties of a particular side dialog,
+ * in contrast with {@link useSideDialogsController} which handles the
+ * state of all the dialogs.
+ */
+export declare const useSideDialogContext: () => SideDialogController;
+/**
+ * This is the component in charge of rendering the side dialogs used
+ * for editing entities. Use the {@link useSideEntityController} to open
+ * and control the dialogs.
+ * This component needs a parent {@link Rebase}
+ * {@link useSideDialogsController}
+ * @group Components
+ */
+export declare function SideDialogs(): import("react/jsx-runtime").JSX.Element;

package/dist/components/SideEntityProvider.d.ts

@@ -0,0 +1,32 @@
+import React from "react";
+/**
+ * Provider that builds the SideEntityController and makes it available
+ * via the SideEntityControllerContext from @rebasepro/core.
+ *
+ * After the CMS extraction refactor, `useBuildSideEntityController` lives
+ * in the CMS package while the context it feeds into lives in core.
+ * This provider bridges the two: place it inside the `<Rebase>` tree and
+ * above any component that calls `useSideEntityController()`.
+ *
+ * Also auto-registers the side entity controller and breadcrumbs into the
+ * self-assembling Studio bridge (when a StudioBridgeRegistryProvider is
+ * mounted above in the tree).
+ *
+ * @example
+ * ```tsx
+ * <Rebase ...>
+ *   {({ loading }) => (
+ *     <SideEntityProvider>
+ *       <RebaseRoutes>
+ *         ...
+ *       </RebaseRoutes>
+ *     </SideEntityProvider>
+ *   )}
+ * </Rebase>
+ * ```
+ *
+ * @group Components
+ */
+export declare function SideEntityProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/UserSelector.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+export interface UserSelectorProps {
+    className?: string;
+    name?: string;
+    id?: string;
+    value?: string | null;
+    onValueChange?: (userId: string | null) => void;
+    placeholder?: React.ReactNode;
+    size?: "small" | "medium";
+    disabled?: boolean;
+    invisible?: boolean;
+    clearable?: boolean;
+    pageSize?: number;
+    searchPlaceholder?: string;
+    noResultsText?: string;
+    loadingText?: string;
+}
+export declare const UserSelector: React.ForwardRefExoticComponent<UserSelectorProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/admin/RoleChip.d.ts

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

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

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

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

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

package/dist/components/admin/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./UsersView";
+export * from "./RolesView";
+export * from "./RoleChip";

package/dist/components/app/AppBar.d.ts

@@ -0,0 +1,12 @@
+import { DefaultAppBarProps } from "../DefaultAppBar";
+/**
+ * This component renders the main app bar of Rebase.
+ */
+export declare function AppBar({ children, ...props }: {
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+} & DefaultAppBarProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace AppBar {
+    var componentType: string;
+}

package/dist/components/app/Drawer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * This component is in charge of rendering the drawer.
+ * If you add this component under your {@link Scaffold}, it will be rendered
+ * as a drawer, and the open and close functionality will be handled automatically.
+ * If you want to customise the drawer, you can create your own component and pass it as a child.
+ * For custom drawers, you can use the {@link useApp} to open and close the drawer.
+ *
+ */
+export declare function Drawer({ children, title, logo, logoDestination, className, style }: {
+    children?: React.ReactNode;
+    title?: React.ReactNode;
+    logo?: string;
+    logoDestination?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}): import("react/jsx-runtime").JSX.Element;
+export declare namespace Drawer {
+    var componentType: string;
+}

package/dist/components/app/Scaffold.d.ts

@@ -0,0 +1,34 @@
+import React from "react";
+export declare const DRAWER_WIDTH = 280;
+/**
+ * @group Core
+ */
+export interface ScaffoldProps {
+    /**
+     * Open the drawer on hover
+     */
+    autoOpenDrawer?: boolean;
+    /**
+     * Logo to be displayed in the top bar and drawer.
+     * Note that this has no effect if you are using a custom AppBar or Drawer.
+     */
+    logo?: string;
+    /**
+     * If true, the main content will be padded in large layouts. Defaults to true.
+     */
+    padding?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+}
+/**
+ * This view acts as a scaffold for Rebase.
+ *
+ * It is in charge of displaying the navigation drawer, top bar and main
+ * collection views.
+ * This component needs a parent {@link Rebase}
+ *
+ * @param props
+
+ * @group Core
+ */
+export declare const Scaffold: React.NamedExoticComponent<React.PropsWithChildren<ScaffoldProps>>;