@questpie/admin 1.1.1 → 2.0.0

package/dist/server/augmentation.d.mts

@@ -0,0 +1,1523 @@
+import { AnyBlockBuilder, AnyBlockDefinition, BlockBuilder } from "./block/block-builder.mjs";
+import "./block/index.mjs";
+import { I18nText } from "questpie/shared";
+import { BuilderCollectionsMap, BuilderEmailTemplatesMap, BuilderFieldsMap, BuilderGlobalsMap, BuilderJobsMap, FieldsOf, GlobalFieldsOf, QuestpieStateOf, RegisteredApp } from "questpie";
+import { BetterAuthOptions } from "better-auth";
+
+//#region src/server/augmentation.d.ts
+
+/**
+ * Admin locale configuration for UI language support.
+ * Separate from content locales - UI can have different languages than content.
+ *
+ * @example
+ * ```ts
+ * .adminLocale({
+ *   locales: ["en", "sk"],  // UI available in 2 languages
+ *   defaultLocale: "en",
+ * })
+ * ```
+ */
+interface AdminLocaleConfig {
+  /** Available UI locales for admin interface */
+  locales: string[];
+  /** Default UI locale */
+  defaultLocale: string;
+}
+/**
+ * Reference to a server-registered component.
+ * Used for icons, badges, and other UI elements defined on server.
+ *
+ * @example
+ * ```ts
+ * { type: "icon", props: { name: "ph:users" } }
+ * ```
+ */
+interface ComponentReference<TType extends string = string, TProps extends Record<string, unknown> = Record<string, unknown>> {
+  type: TType;
+  props: TProps;
+}
+/**
+ * Icon component reference with typed props.
+ */
+type IconReference = ComponentReference<"icon", {
+  name: string;
+}>;
+/**
+ * Badge component reference with typed props.
+ */
+type BadgeReference = ComponentReference<"badge", {
+  text: string;
+  color?: string;
+}>;
+/**
+ * View definition for list views (table, cards, etc.)
+ */
+interface ListViewDefinition<TName extends string = string> {
+  type: "listView";
+  name: TName;
+}
+/**
+ * View definition for edit views (form, wizard, etc.)
+ */
+interface EditViewDefinition<TName extends string = string> {
+  type: "editView";
+  name: TName;
+}
+/**
+ * Component definition for reusable UI components
+ */
+interface ComponentDefinition<TName extends string = string> {
+  type: "component";
+  name: TName;
+}
+type ComponentFactoryInput<TName extends string> = TName extends "icon" ? string | {
+  name: string;
+} : TName extends "badge" ? {
+  text: string;
+  color?: string;
+} : Record<string, unknown> | string;
+type ComponentFactoryOutput<TName extends string> = TName extends "icon" ? IconReference : TName extends "badge" ? BadgeReference : ComponentReference<TName, Record<string, unknown>>;
+/**
+ * Component factory API generated from registered components.
+ *
+ * Each key returns a serializable component reference.
+ *
+ * Note: `icon` keeps backward-compatible string shorthand:
+ * `c.icon("ph:users")` => `{ type: "icon", props: { name: "ph:users" } }`
+ */
+type ComponentFactory<TComponentNames extends string = string> = { [K in TComponentNames]: (props: ComponentFactoryInput<K>) => ComponentFactoryOutput<K> };
+/**
+ * Admin metadata for a collection.
+ * Defines how the collection appears in the admin sidebar and UI.
+ */
+interface AdminCollectionConfig {
+  /** Display label for the collection */
+  label?: I18nText;
+  /** Description shown in tooltips/help text */
+  description?: I18nText;
+  /** Icon reference (resolved by client's icon component) */
+  icon?: ComponentReference;
+  /** Hide from admin sidebar */
+  hidden?: boolean;
+  /** Group in sidebar */
+  group?: string;
+  /** Order within group */
+  order?: number;
+}
+/**
+ * Block category configuration.
+ * Defines how blocks are grouped in the block picker.
+ */
+interface BlockCategoryConfig {
+  /** Display label for the category */
+  label: I18nText;
+  /** Icon for the category */
+  icon?: ComponentReference;
+  /** Order in block picker (lower = first) */
+  order?: number;
+}
+/**
+ * Admin metadata for a block.
+ * Defines how the block appears in the block picker and editor.
+ *
+ * @example
+ * ```ts
+ * block("hero")
+ *   .admin(({ c }) => ({
+ *     label: { en: "Hero Section", sk: "Hero sekcia" },
+ *     icon: c.icon("ph:image"),
+ *     category: {
+ *       label: { en: "Sections", sk: "Sekcie" },
+ *       icon: c.icon("ph:layout"),
+ *     },
+ *   }))
+ * ```
+ */
+interface AdminBlockConfig {
+  /** Display label for the block */
+  label?: I18nText;
+  /** Description shown in tooltips/help text */
+  description?: I18nText;
+  /** Icon reference (resolved by client's icon component) */
+  icon?: ComponentReference;
+  /** Category for grouping in block picker */
+  category?: BlockCategoryConfig;
+  /** Order within category in block picker (lower = first) */
+  order?: number;
+  /** Hide from block picker (useful for deprecated blocks) */
+  hidden?: boolean;
+}
+/**
+ * List view configuration for a collection.
+ * Defines columns, sorting, filtering, and actions.
+ */
+interface ListViewConfig {
+  /** View type to use (e.g., "table", "cards") */
+  view?: string;
+  /** Columns to display */
+  columns?: string[];
+  /** Default sort configuration */
+  defaultSort?: {
+    field: string;
+    direction: "asc" | "desc";
+  };
+  /** Searchable fields */
+  searchable?: string[];
+  /** Filterable fields */
+  filterable?: string[];
+  /** Actions configuration */
+  actions?: {
+    header?: {
+      primary?: ActionReference[];
+      secondary?: ActionReference[];
+    };
+    row?: ActionReference[];
+    bulk?: ActionReference[];
+  };
+}
+/**
+ * Context passed to form reactive handlers.
+ */
+interface FormReactiveContext<TData = Record<string, unknown>> {
+  data: TData;
+  sibling: Record<string, unknown>;
+  ctx: {
+    db: any;
+    user?: any;
+    locale?: string;
+  };
+  prev?: {
+    data: TData;
+    sibling: Record<string, unknown>;
+  };
+}
+/**
+ * Reactive config for field-level form behavior.
+ */
+type FormReactiveConfig<TData = any, TReturn = any> = ((ctx: FormReactiveContext<TData>) => TReturn | Promise<TReturn>) | {
+  handler: (ctx: FormReactiveContext<TData>) => TReturn | Promise<TReturn>;
+  deps?: string[] | ((ctx: FormReactiveContext<TData>) => any[]);
+  debounce?: number;
+} | {
+  deps: string[];
+  debounce?: number;
+};
+/**
+ * Section layout for form views.
+ * Groups fields with optional visual wrapper and layout mode.
+ *
+ * @example
+ * ```ts
+ * {
+ *   type: "section",
+ *   label: { en: "Contact Information" },
+ *   layout: "grid",
+ *   columns: 2,
+ *   fields: [f.name, f.email, f.phone],
+ * }
+ * ```
+ */
+interface FormSectionLayout {
+  type: "section";
+  /** Section label */
+  label?: I18nText;
+  /** Section description */
+  description?: I18nText;
+  /** Visual wrapper mode */
+  wrapper?: "flat" | "collapsible";
+  /** Default collapsed state (for collapsible wrapper) */
+  defaultCollapsed?: boolean;
+  /** Field arrangement mode */
+  layout?: "stack" | "inline" | "grid";
+  /** Number of columns (for grid layout) */
+  columns?: number;
+  /** Custom gap (in quarter rems) */
+  gap?: number;
+  /** Fields in this section */
+  fields: FieldLayoutItem[];
+  /** Conditional visibility */
+  hidden?: boolean;
+  /** Custom CSS class */
+  className?: string;
+}
+/**
+ * Tab configuration for tabbed form views.
+ */
+interface FormTabConfig {
+  /** Unique tab identifier */
+  id: string;
+  /** Tab label */
+  label: I18nText;
+  /** Tab icon */
+  icon?: ComponentReference;
+  /** Fields in this tab */
+  fields: FieldLayoutItem[];
+  /** Conditional visibility */
+  hidden?: boolean;
+}
+/**
+ * Tabs layout for form views.
+ *
+ * @example
+ * ```ts
+ * {
+ *   type: "tabs",
+ *   tabs: [
+ *     { id: "basic", label: { en: "Basic" }, fields: [f.name, f.email] },
+ *     { id: "advanced", label: { en: "Advanced" }, fields: [f.settings] },
+ *   ],
+ * }
+ * ```
+ */
+interface FormTabsLayout {
+  type: "tabs";
+  tabs: FormTabConfig[];
+}
+/**
+ * Field entry with optional reactive form behavior.
+ */
+interface FormFieldLayoutItem<TData = any> {
+  field: string;
+  className?: string;
+  hidden?: boolean | FormReactiveConfig<TData, boolean>;
+  readOnly?: boolean | FormReactiveConfig<TData, boolean>;
+  disabled?: boolean | FormReactiveConfig<TData, boolean>;
+  compute?: FormReactiveConfig<TData, any>;
+}
+/**
+ * Field layout item - union of field reference or layout container.
+ *
+ * Can be:
+ * - Field name string: `f.name`
+ * - Field with className: `{ field: "name", className: "col-span-2" }`
+ * - Section layout: `{ type: "section", ... }`
+ * - Tabs layout: `{ type: "tabs", ... }`
+ */
+type FieldLayoutItem = string | FormFieldLayoutItem | FormSectionLayout | FormTabsLayout;
+/**
+ * Form sidebar configuration.
+ * Places fields in a fixed sidebar alongside the main content.
+ *
+ * @example
+ * ```ts
+ * sidebar: {
+ *   position: "right",
+ *   fields: [f.isActive, f.avatar],
+ * }
+ * ```
+ */
+interface FormSidebarConfig {
+  /** Sidebar position (default: "right") */
+  position?: "left" | "right";
+  /** Fields in the sidebar */
+  fields: FieldLayoutItem[];
+}
+/**
+ * Form view configuration for a collection.
+ * Defines field layout with sections, tabs, and optional sidebar.
+ *
+ * @example
+ * ```ts
+ * v.form({
+ *   sidebar: { position: "right", fields: [f.status] },
+ *   fields: [
+ *     { type: "section", label: { en: "Details" }, layout: "grid", columns: 2, fields: [f.name, f.email] },
+ *     { type: "section", label: { en: "Content" }, fields: [f.body] },
+ *   ],
+ * })
+ * ```
+ */
+interface FormViewConfig {
+  /** View type to use (e.g., "form", "wizard") */
+  view?: string;
+  /** Main content fields */
+  fields: FieldLayoutItem[];
+  /** Sidebar configuration */
+  sidebar?: FormSidebarConfig;
+}
+/**
+ * Preview configuration for a collection.
+ * Enables live preview of content.
+ */
+interface PreviewConfig {
+  /** Enable preview panel */
+  enabled?: boolean;
+  /** Preview URL builder (runs on server) */
+  url?: (ctx: {
+    record: Record<string, unknown>;
+    locale?: string;
+  }) => string;
+  /** Preview panel position */
+  position?: "left" | "right" | "bottom";
+  /** Default panel width (percentage) */
+  defaultWidth?: number;
+}
+/**
+ * Reference to an action
+ */
+type ActionReference = string | {
+  type: string;
+  config?: unknown;
+};
+/**
+ * Admin metadata for a global.
+ */
+interface AdminGlobalConfig {
+  /** Display label */
+  label?: I18nText;
+  /** Description */
+  description?: I18nText;
+  /** Icon reference */
+  icon?: ComponentReference;
+  /** Hide from admin */
+  hidden?: boolean;
+  /** Group in sidebar */
+  group?: string;
+  /** Order within group */
+  order?: number;
+}
+/**
+ * Context available to widget fetchFn and access functions on the server.
+ * When you register your app via `Register.app`, `ctx.app` is automatically typed.
+ */
+type WidgetFetchContext = {
+  app: RegisteredApp;
+  db: any;
+  session?: any;
+  locale?: string;
+};
+/**
+ * Per-widget access rule. Can be a boolean or async function.
+ * - `true` or `undefined`: always visible
+ * - `false`: always hidden
+ * - function: evaluated at request time
+ */
+type WidgetAccessRule = boolean | ((ctx: WidgetFetchContext) => boolean | Promise<boolean>);
+/**
+ * Server-side dashboard widget configuration.
+ * These are serializable and can be sent via introspection API.
+ */
+type ServerDashboardWidget = ServerStatsWidget | ServerChartWidget | ServerRecentItemsWidget | ServerQuickActionsWidget | ServerCustomWidget | ServerValueWidget | ServerTableWidget | ServerTimelineWidget | ServerProgressWidget;
+/**
+ * Stats widget - shows count from a collection
+ */
+interface ServerStatsWidget {
+  type: "stats";
+  /** Unique widget ID */
+  id?: string;
+  /** Widget label */
+  label?: I18nText;
+  /** Icon reference */
+  icon?: ComponentReference;
+  /** Collection to count */
+  collection: string;
+  /** Filter to apply */
+  filter?: Record<string, unknown>;
+  /** Grid span (1-4) */
+  span?: number;
+  /** Optional server-side data fetcher (overrides collection count) */
+  fetchFn?: (ctx: WidgetFetchContext) => Promise<{
+    count: number;
+  }>;
+  /** Per-widget access rule */
+  access?: WidgetAccessRule;
+}
+/**
+ * Chart widget - shows data over time
+ */
+interface ServerChartWidget {
+  type: "chart";
+  /** Unique widget ID */
+  id?: string;
+  /** Widget label */
+  label?: I18nText;
+  /** Chart type */
+  chartType: "line" | "bar" | "area" | "pie";
+  /** Collection to query */
+  collection: string;
+  /** Date field for time series */
+  dateField: string;
+  /** Time range */
+  timeRange?: "7d" | "30d" | "90d" | "1y";
+  /** Filter to apply */
+  filter?: Record<string, unknown>;
+  /** Grid span (1-4) */
+  span?: number;
+  /** Optional server-side data fetcher (overrides collection query) */
+  fetchFn?: (ctx: WidgetFetchContext) => Promise<Array<{
+    name: string;
+    value: number;
+  }>>;
+  /** Per-widget access rule */
+  access?: WidgetAccessRule;
+}
+/**
+ * Recent items widget - shows latest items from a collection
+ */
+interface ServerRecentItemsWidget {
+  type: "recentItems";
+  /** Unique widget ID */
+  id?: string;
+  /** Widget label */
+  label?: I18nText;
+  /** Collection to query */
+  collection: string;
+  /** Date field for ordering */
+  dateField: string;
+  /** Number of items to show */
+  limit?: number;
+  /** Filter to apply */
+  filter?: Record<string, unknown>;
+  /** Grid span (1-4) */
+  span?: number;
+  /** Optional server-side data fetcher */
+  fetchFn?: (ctx: WidgetFetchContext) => Promise<unknown>;
+  /** Per-widget access rule */
+  access?: WidgetAccessRule;
+}
+/**
+ * Quick actions widget - shows action buttons
+ */
+interface ServerQuickActionsWidget {
+  type: "quickActions";
+  /** Unique widget ID */
+  id?: string;
+  /** Widget label */
+  label?: I18nText;
+  /** Actions to display */
+  actions: ServerQuickAction[];
+  /** Grid span (1-4) */
+  span?: number;
+  /** Per-widget access rule */
+  access?: WidgetAccessRule;
+}
+/**
+ * Quick action definition
+ */
+interface ServerQuickAction {
+  /** Action label */
+  label: I18nText;
+  /** Action icon */
+  icon?: ComponentReference;
+  /** Action to perform */
+  action: {
+    type: "create";
+    collection: string;
+  } | {
+    type: "link";
+    href: string;
+    external?: boolean;
+  } | {
+    type: "page";
+    pageId: string;
+  };
+}
+/**
+ * Custom widget - rendered by client component
+ */
+interface ServerCustomWidget {
+  type: "custom";
+  /** Unique widget ID (required for custom) */
+  id: string;
+  /** Widget label */
+  label?: I18nText;
+  /** Custom widget type name (resolved by client registry) */
+  widgetType: string;
+  /** Widget props (passed to client component) */
+  props?: Record<string, unknown>;
+  /** Grid span (1-4) */
+  span?: number;
+  /** Optional server-side data fetcher */
+  fetchFn?: (ctx: WidgetFetchContext) => Promise<unknown>;
+  /** Per-widget access rule */
+  access?: WidgetAccessRule;
+}
+/**
+ * Value widget - displays a single metric with optional trend
+ */
+interface ServerValueWidget {
+  type: "value";
+  /** Unique widget ID */
+  id: string;
+  /** Widget label */
+  label?: I18nText;
+  /** Icon reference */
+  icon?: ComponentReference;
+  /** Grid span (1-4) */
+  span?: number;
+  /** Server-side data fetcher (required) */
+  fetchFn: (ctx: WidgetFetchContext) => Promise<{
+    value: number | string;
+    formatted?: string;
+    label?: I18nText | string;
+    subtitle?: I18nText | string;
+    footer?: I18nText | string;
+    icon?: ComponentReference;
+    trend?: {
+      value: string;
+      icon?: ComponentReference;
+    };
+    classNames?: Record<string, string>;
+  }>;
+  /** Per-widget access rule */
+  access?: WidgetAccessRule;
+}
+/**
+ * Table widget - displays a mini table from a collection
+ */
+interface ServerTableWidget {
+  type: "table";
+  /** Unique widget ID */
+  id: string;
+  /** Widget label */
+  label?: I18nText;
+  /** Collection to fetch from */
+  collection: string;
+  /** Columns to display */
+  columns: Array<string | {
+    key: string;
+    label?: I18nText;
+  }>;
+  /** Number of rows */
+  limit?: number;
+  /** Sort field */
+  sortBy?: string;
+  /** Sort direction */
+  sortOrder?: "asc" | "desc";
+  /** Filter */
+  filter?: Record<string, unknown>;
+  /** Grid span (1-4) */
+  span?: number;
+  /** Optional server-side data fetcher */
+  fetchFn?: (ctx: WidgetFetchContext) => Promise<unknown>;
+  /** Per-widget access rule */
+  access?: WidgetAccessRule;
+}
+/**
+ * Timeline widget - displays activity/event timeline
+ */
+interface ServerTimelineWidget {
+  type: "timeline";
+  /** Unique widget ID */
+  id: string;
+  /** Widget label */
+  label?: I18nText;
+  /** Max items to show */
+  maxItems?: number;
+  /** Show timestamps */
+  showTimestamps?: boolean;
+  /** Timestamp format */
+  timestampFormat?: "relative" | "absolute" | "datetime";
+  /** Empty state message */
+  emptyMessage?: I18nText;
+  /** Grid span (1-4) */
+  span?: number;
+  /** Server-side data fetcher (required) */
+  fetchFn: (ctx: WidgetFetchContext) => Promise<Array<{
+    id: string;
+    title: string;
+    description?: string;
+    timestamp: Date | string;
+    icon?: ComponentReference;
+    variant?: "default" | "success" | "warning" | "error" | "info";
+    href?: string;
+  }>>;
+  /** Per-widget access rule */
+  access?: WidgetAccessRule;
+}
+/**
+ * Progress widget - displays progress towards a goal
+ */
+interface ServerProgressWidget {
+  type: "progress";
+  /** Unique widget ID */
+  id: string;
+  /** Widget label */
+  label?: I18nText;
+  /** Progress bar color */
+  color?: string;
+  /** Show percentage */
+  showPercentage?: boolean;
+  /** Grid span (1-4) */
+  span?: number;
+  /** Server-side data fetcher (required) */
+  fetchFn: (ctx: WidgetFetchContext) => Promise<{
+    current: number;
+    target: number;
+    label?: string;
+    subtitle?: string;
+  }>;
+  /** Per-widget access rule */
+  access?: WidgetAccessRule;
+}
+/**
+ * Dashboard section - groups widgets
+ */
+interface ServerDashboardSection {
+  type: "section";
+  /** Section label */
+  label?: I18nText;
+  /** Section description */
+  description?: I18nText;
+  /** Section icon */
+  icon?: ComponentReference;
+  /** Layout mode */
+  layout?: "grid" | "stack";
+  /** Grid columns */
+  columns?: number;
+  /** Wrapper style */
+  wrapper?: "flat" | "card" | "collapsible";
+  /** Default collapsed (for collapsible) */
+  defaultCollapsed?: boolean;
+  /** Section items */
+  items: ServerDashboardItem[];
+}
+/**
+ * Dashboard tabs - tabbed sections
+ */
+interface ServerDashboardTabs {
+  type: "tabs";
+  /** Tabs configuration */
+  tabs: ServerDashboardTab[];
+  /** Default active tab ID */
+  defaultTab?: string;
+}
+/**
+ * Single tab configuration
+ */
+interface ServerDashboardTab {
+  /** Tab ID */
+  id: string;
+  /** Tab label */
+  label: I18nText;
+  /** Tab icon */
+  icon?: ComponentReference;
+  /** Tab items */
+  items: ServerDashboardItem[];
+}
+/**
+ * Dashboard layout item
+ */
+type ServerDashboardItem = ServerDashboardWidget | ServerDashboardSection | ServerDashboardTabs;
+/**
+ * Dashboard header action shown beside title/description.
+ */
+interface ServerDashboardAction {
+  /** Unique action ID */
+  id: string;
+  /** Action label */
+  label: I18nText;
+  /** Action icon */
+  icon?: ComponentReference;
+  /** Action URL */
+  href: string;
+  /** Visual variant */
+  variant?: "default" | "primary" | "secondary" | "outline" | "ghost";
+}
+/**
+ * Server-side dashboard configuration
+ */
+interface ServerDashboardConfig {
+  /** Dashboard title */
+  title?: I18nText;
+  /** Dashboard description */
+  description?: I18nText;
+  /** Header actions */
+  actions?: ServerDashboardAction[];
+  /** Grid columns (default: 4) */
+  columns?: number;
+  /** Gap between widgets */
+  gap?: number;
+  /** Dashboard items */
+  items?: ServerDashboardItem[];
+  /** Enable realtime invalidation for dashboard widgets by default */
+  realtime?: boolean;
+  /** Auto-refresh interval in milliseconds */
+  refreshInterval?: number;
+}
+/**
+ * Branding configuration for the admin panel.
+ */
+interface ServerBrandingConfig {
+  /** Admin panel name */
+  name?: I18nText;
+  /** Logo configuration */
+  logo?: unknown;
+}
+/**
+ * Server-side sidebar item types
+ */
+type ServerSidebarItem = ServerSidebarCollectionItem | ServerSidebarGlobalItem | ServerSidebarPageItem | ServerSidebarLinkItem | ServerSidebarDividerItem;
+/**
+ * Collection item in sidebar
+ */
+interface ServerSidebarCollectionItem {
+  type: "collection";
+  /** Collection name (validated against registered collections) */
+  collection: string;
+  /** Override display label */
+  label?: I18nText;
+  /** Override icon */
+  icon?: ComponentReference;
+}
+/**
+ * Global item in sidebar
+ */
+interface ServerSidebarGlobalItem {
+  type: "global";
+  /** Global name (validated against registered globals) */
+  global: string;
+  /** Override display label */
+  label?: I18nText;
+  /** Override icon */
+  icon?: ComponentReference;
+}
+/**
+ * Custom page item in sidebar
+ */
+interface ServerSidebarPageItem {
+  type: "page";
+  /** Page ID (resolved by client) */
+  pageId: string;
+  /** Display label */
+  label?: I18nText;
+  /** Icon */
+  icon?: ComponentReference;
+}
+/**
+ * External link item in sidebar
+ */
+interface ServerSidebarLinkItem {
+  type: "link";
+  /** Display label */
+  label: I18nText;
+  /** Link URL */
+  href: string;
+  /** Icon */
+  icon?: ComponentReference;
+  /** Open in new tab */
+  external?: boolean;
+}
+/**
+ * Divider item in sidebar
+ */
+interface ServerSidebarDividerItem {
+  type: "divider";
+}
+/**
+ * Sidebar section
+ */
+interface ServerSidebarSection {
+  /** Section ID (for targeting/extending) */
+  id: string;
+  /** Section title */
+  title?: I18nText;
+  /** Section icon */
+  icon?: ComponentReference;
+  /** Whether collapsed by default */
+  collapsed?: boolean;
+  /** Section items */
+  items?: ServerSidebarItem[];
+  /** Nested subsections */
+  sections?: ServerSidebarSection[];
+}
+/**
+ * Server-side sidebar configuration
+ */
+interface ServerSidebarConfig {
+  /** Sidebar sections */
+  sections: ServerSidebarSection[];
+}
+/**
+ * Action result types returned from action handlers.
+ */
+type ServerActionResult = ServerActionSuccess | ServerActionError | ServerActionRedirect | ServerActionDownload;
+/**
+ * Successful action result
+ */
+interface ServerActionSuccess {
+  type: "success";
+  /** Toast notification to show */
+  toast?: {
+    message: string;
+    title?: string;
+  };
+  /** Side effects to trigger */
+  effects?: ServerActionEffects;
+}
+/**
+ * Error action result
+ */
+interface ServerActionError {
+  type: "error";
+  /** Toast notification to show */
+  toast?: {
+    message: string;
+    title?: string;
+  };
+  /** Field-level errors */
+  errors?: Record<string, string>;
+}
+/**
+ * Redirect action result
+ */
+interface ServerActionRedirect {
+  type: "redirect";
+  /** URL to redirect to */
+  url: string;
+  /** Open in new tab */
+  external?: boolean;
+}
+/**
+ * Download action result
+ */
+interface ServerActionDownload {
+  type: "download";
+  /** File data */
+  file: {
+    name: string;
+    content: string | Uint8Array;
+    mimeType: string;
+  };
+}
+/**
+ * Action side effects
+ */
+interface ServerActionEffects {
+  /** Close the action modal */
+  closeModal?: boolean;
+  /** Invalidate queries (true = all, string[] = specific collections) */
+  invalidate?: boolean | string[];
+  /** Redirect after success */
+  redirect?: string;
+}
+/**
+ * Action handler context
+ */
+interface ServerActionContext<TData = Record<string, unknown>> {
+  /** Form data submitted */
+  data: TData;
+  /** Item ID (for single-item actions) */
+  itemId?: string;
+  /** Item IDs (for bulk actions) */
+  itemIds?: string[];
+  /** CMS app instance — typed via Register.app */
+  app: RegisteredApp;
+  /** Database client */
+  db: unknown;
+  /** Current user session */
+  session?: unknown;
+  /** Current locale */
+  locale?: string;
+}
+/**
+ * Action handler function type
+ */
+type ServerActionHandler<TData = Record<string, unknown>> = (ctx: ServerActionContext<TData>) => Promise<ServerActionResult> | ServerActionResult;
+/**
+ * Server-side action form field definition.
+ * Can be either a field definition from the registry or a simple config object.
+ */
+type ServerActionFormField = ServerActionFormFieldConfig | ServerActionFormFieldDefinition;
+/**
+ * Simple field config for action forms (when not using field registry)
+ */
+interface ServerActionFormFieldConfig {
+  /** Field type */
+  type: string;
+  /** Field label */
+  label?: I18nText;
+  /** Field description */
+  description?: I18nText;
+  /** Whether field is required */
+  required?: boolean;
+  /** Default value */
+  default?: unknown;
+  /** Field-specific options */
+  options?: unknown;
+}
+/**
+ * Field definition from field registry (has getMetadata method)
+ */
+interface ServerActionFormFieldDefinition {
+  /** Field definition state */
+  state: {
+    label?: I18nText;
+    description?: I18nText;
+    required?: boolean;
+  };
+  /** Get metadata for introspection */
+  getMetadata(): {
+    type: string;
+    label?: I18nText;
+    description?: I18nText;
+  };
+  /** Generate Zod schema for validation */
+  toZodSchema(): unknown;
+}
+/**
+ * Server-side action form configuration
+ */
+interface ServerActionForm {
+  /** Form dialog title */
+  title: I18nText;
+  /** Form dialog description */
+  description?: I18nText;
+  /** Form fields */
+  fields: Record<string, ServerActionFormField>;
+  /** Submit button label */
+  submitLabel?: I18nText;
+  /** Cancel button label */
+  cancelLabel?: I18nText;
+  /** Dialog width */
+  width?: "sm" | "md" | "lg" | "xl";
+}
+/**
+ * Server-side action definition
+ */
+interface ServerActionDefinition<TData = Record<string, unknown>> {
+  /** Unique action ID */
+  id: string;
+  /** Display label */
+  label: I18nText;
+  /** Action description */
+  description?: I18nText;
+  /** Icon reference */
+  icon?: ComponentReference;
+  /** Button variant */
+  variant?: "default" | "destructive" | "outline" | "secondary" | "ghost";
+  /** Where the action appears */
+  scope?: "single" | "bulk" | "header" | "row";
+  /** Form configuration (for actions with input) */
+  form?: ServerActionForm;
+  /** Confirmation dialog */
+  confirmation?: {
+    title: I18nText;
+    description?: I18nText;
+    confirmLabel?: I18nText;
+    cancelLabel?: I18nText;
+    destructive?: boolean;
+  };
+  /** Action handler (runs on server) */
+  handler: ServerActionHandler<TData>;
+}
+/**
+ * Built-in action types
+ */
+type BuiltinActionType = "create" | "save" | "delete" | "deleteMany" | "duplicate";
+/**
+ * Server-side actions configuration for a collection
+ */
+interface ServerActionsConfig {
+  /** Built-in actions to enable */
+  builtin?: BuiltinActionType[];
+  /** Custom actions */
+  custom?: ServerActionDefinition[];
+}
+/**
+ * Context for actions config function.
+ *
+ * Uses the same field registry as collections, so you can use `f.text()`, `f.select()` etc.
+ * for action form fields.
+ *
+ * @example
+ * ```ts
+ * .actions(({ a, c, f }) => ({
+ *   custom: [
+ *     a.action({
+ *       id: "send-email",
+ *       label: { en: "Send Email" },
+ *       form: {
+ *         title: { en: "Send Email" },
+ *         fields: {
+ *           subject: f.text({ label: { en: "Subject" }, required: true }),
+ *           message: f.textarea({ label: { en: "Message" } }),
+ *           priority: f.select({
+ *             label: { en: "Priority" },
+ *             options: [
+ *               { value: "low", label: { en: "Low" } },
+ *               { value: "high", label: { en: "High" } },
+ *             ],
+ *           }),
+ *         },
+ *       },
+ *       handler: async ({ data }) => {
+ *         // data.subject, data.message, data.priority are typed
+ *         return { type: "success" };
+ *       },
+ *     }),
+ *   ],
+ * }))
+ * ```
+ */
+interface ActionsConfigContext<TFields extends Record<string, unknown> = Record<string, unknown>, TComponentNames extends string = string> {
+  /** Action builders */
+  a: {
+    /** Enable create action */
+    create: () => BuiltinActionType;
+    /** Enable save action */
+    save: () => BuiltinActionType;
+    /** Enable delete action */
+    delete: () => BuiltinActionType;
+    /** Enable delete many action */
+    deleteMany: () => BuiltinActionType;
+    /** Enable duplicate action */
+    duplicate: () => BuiltinActionType;
+    /** Define a custom action */
+    action: <TData = Record<string, unknown>>(def: Omit<ServerActionDefinition<TData>, "scope"> & {
+      scope?: "single" | "row";
+    }) => ServerActionDefinition<TData>;
+    /** Define a bulk action */
+    bulkAction: <TData = Record<string, unknown>>(def: Omit<ServerActionDefinition<TData>, "scope">) => ServerActionDefinition<TData>;
+    /** Define a header action */
+    headerAction: <TData = Record<string, unknown>>(def: Omit<ServerActionDefinition<TData>, "scope">) => ServerActionDefinition<TData>;
+  };
+  /** Component helpers (from registered component registry) */
+  c: ComponentFactory<TComponentNames>;
+  /**
+   * Field proxy from field registry.
+   * Use the same field types as in collections: f.text(), f.select(), etc.
+   */
+  f: Record<string, (config?: Record<string, unknown>) => ServerActionFormField>;
+}
+/**
+ * Action factory for dashboard header actions.
+ */
+interface DashboardActionFactory {
+  /** Return action as-is */
+  action: (config: ServerDashboardAction) => ServerDashboardAction;
+  /** Link action */
+  link: (config: ServerDashboardAction) => ServerDashboardAction;
+  /** Create action linking to collection create view */
+  create: (config: Omit<ServerDashboardAction, "href"> & {
+    collection: string;
+  }) => ServerDashboardAction;
+  /** Global action linking to global edit view */
+  global: (config: Omit<ServerDashboardAction, "href"> & {
+    global: string;
+  }) => ServerDashboardAction;
+}
+/**
+ * Context for dashboard config function
+ */
+interface DashboardConfigContext<TComponentNames extends string = string> {
+  /** Dashboard action helpers */
+  a: DashboardActionFactory;
+  /** Dashboard builder helpers */
+  d: {
+    /** Create dashboard config */
+    dashboard: (config: ServerDashboardConfig) => ServerDashboardConfig;
+    /** Create a section */
+    section: (config: Omit<ServerDashboardSection, "type">) => ServerDashboardSection;
+    /** Create tabs */
+    tabs: (config: Omit<ServerDashboardTabs, "type">) => ServerDashboardTabs;
+    /** Create a stats widget */
+    stats: (config: Omit<ServerStatsWidget, "type">) => ServerStatsWidget;
+    /** Create a chart widget */
+    chart: (config: Omit<ServerChartWidget, "type">) => ServerChartWidget;
+    /** Create a recent items widget */
+    recentItems: (config: Omit<ServerRecentItemsWidget, "type">) => ServerRecentItemsWidget;
+    /** Create a quick actions widget */
+    quickActions: (config: Omit<ServerQuickActionsWidget, "type">) => ServerQuickActionsWidget;
+    /** Create a custom widget */
+    custom: (config: Omit<ServerCustomWidget, "type">) => ServerCustomWidget;
+    /** Create a value widget */
+    value: (config: Omit<ServerValueWidget, "type">) => ServerValueWidget;
+    /** Create a table widget */
+    table: (config: Omit<ServerTableWidget, "type">) => ServerTableWidget;
+    /** Create a timeline widget */
+    timeline: (config: Omit<ServerTimelineWidget, "type">) => ServerTimelineWidget;
+    /** Create a progress widget */
+    progress: (config: Omit<ServerProgressWidget, "type">) => ServerProgressWidget;
+  };
+  /** Component helpers (from registered component registry) */
+  c: ComponentFactory<TComponentNames>;
+}
+/**
+ * Context for sidebar config function
+ */
+interface SidebarConfigContext<TComponentNames extends string = string> {
+  /** Sidebar builder helpers */
+  s: {
+    /** Create sidebar config */
+    sidebar: (config: ServerSidebarConfig) => ServerSidebarConfig;
+    /** Create a section */
+    section: (config: Omit<ServerSidebarSection, "items"> & {
+      items?: ServerSidebarItem[];
+    }) => ServerSidebarSection;
+  };
+  /** Component helpers (from registered component registry) */
+  c: ComponentFactory<TComponentNames>;
+}
+/**
+ * Context for admin config functions with component proxy
+ */
+interface AdminConfigContext<TComponentNames extends string = string> {
+  c: ComponentFactory<TComponentNames>;
+}
+/**
+ * Extract state from a builder-like object.
+ */
+type BuilderStateOf<TBuilder> = TBuilder extends {
+  state: infer TState;
+} ? TState : never;
+/**
+ * Resolve source state for registry lookups.
+ *
+ * - Collection/Global builders: use `state["~questpieApp"].state`
+ * - QuestpieBuilder: use `state`
+ */
+type RegistrySourceStateOf<TBuilder> = QuestpieStateOf<BuilderStateOf<TBuilder> extends {
+  "~questpieApp"?: infer TQuestpieApp;
+} ? NonNullable<TQuestpieApp> : never> extends never ? BuilderStateOf<TBuilder> : QuestpieStateOf<BuilderStateOf<TBuilder> extends {
+  "~questpieApp"?: infer TQuestpieApp;
+} ? NonNullable<TQuestpieApp> : never>;
+/**
+ * Extract registered list view names from a builder.
+ */
+type RegisteredListViewNamesOfBuilder<TBuilder> = RegistrySourceStateOf<TBuilder> extends {
+  listViews?: infer TViews;
+} ? TViews extends Record<string, ListViewDefinition> ? keyof TViews & string : string : string;
+/**
+ * Extract registered edit view names from a builder.
+ */
+type RegisteredEditViewNamesOfBuilder<TBuilder> = RegistrySourceStateOf<TBuilder> extends {
+  editViews?: infer TViews;
+} ? TViews extends Record<string, EditViewDefinition> ? keyof TViews & string : string : string;
+/**
+ * Extract registered component names from a builder.
+ */
+type RegisteredComponentNamesOfBuilder<TBuilder> = RegistrySourceStateOf<TBuilder> extends {
+  components?: infer TComponents;
+} ? TComponents extends Record<string, ComponentDefinition> ? keyof TComponents & string : string : string;
+/**
+ * View factory API generated from registered list views.
+ */
+type ListViewFactory<TListViewNames extends string = string> = { [K in TListViewNames]: (config: Omit<ListViewConfig, "view">) => ListViewConfig & {
+  view: K;
+} };
+/**
+ * View factory API generated from registered edit views.
+ */
+type EditViewFactory<TEditViewNames extends string = string> = { [K in TEditViewNames]: (config: Omit<FormViewConfig, "view">) => FormViewConfig & {
+  view: K;
+} };
+/**
+ * Context for list view config functions
+ */
+interface ListViewConfigContext<TFields extends Record<string, any> = Record<string, any>, TListViewNames extends string = string> {
+  /** View factory */
+  v: ListViewFactory<TListViewNames>;
+  /** Field reference proxy - returns field names as strings */
+  f: { [K in keyof TFields]: K };
+  /** Action reference proxy */
+  a: {
+    create: string;
+    save: string;
+    delete: string;
+    deleteMany: string;
+    duplicate: string;
+    export: string;
+    custom: (name: string, config?: unknown) => {
+      type: string;
+      config?: unknown;
+    };
+  };
+}
+/**
+ * Context for form view config functions
+ */
+interface FormViewConfigContext<TFields extends Record<string, any> = Record<string, any>, TEditViewNames extends string = string> {
+  /** View factory */
+  v: EditViewFactory<TEditViewNames>;
+  /** Field reference proxy - returns field names as strings */
+  f: { [K in keyof TFields]: K };
+}
+/**
+ * Admin methods added to QuestpieBuilder via monkey patching.
+ * Use with type assertion when you need type safety:
+ *
+ * @example
+ * ```ts
+ * import type { WithAdminMethods } from "@questpie/admin/server";
+ *
+ * const builder = q({ name: "app" }).use(adminModule) as WithAdminMethods<typeof q>;
+ * builder.listView("table"); // now has type support
+ * ```
+ */
+interface QuestpieBuilderAdminMethods<TComponentNames extends string = string> {
+  /** Create a list view definition */
+  listView<TName extends string>(name: TName, config?: Record<string, unknown>): ListViewDefinition<TName>;
+  /** Create an edit view definition */
+  editView<TName extends string>(name: TName, config?: Record<string, unknown>): EditViewDefinition<TName>;
+  /** Create a component definition */
+  component<TName extends string>(name: TName, config?: Record<string, unknown>): ComponentDefinition<TName>;
+  /** Register list views */
+  listViews<TViews$1 extends Record<string, ListViewDefinition>>(views: TViews$1): this;
+  /** Register edit views */
+  editViews<TViews$1 extends Record<string, EditViewDefinition>>(views: TViews$1): this;
+  /** Register components */
+  components<TComponents$1 extends Record<string, ComponentDefinition>>(components: TComponents$1): this;
+  /** Register block definitions */
+  blocks<TBlocks extends Record<string, AnyBlockBuilder>>(blocks: TBlocks): this;
+  /**
+   * Configure the admin dashboard.
+   *
+   * @example
+   * ```ts
+   * .dashboard(({ d, c, a }) => d.dashboard({
+   *   title: { en: "Dashboard" },
+   *   actions: [
+   *     a.create({
+   *       id: "new-user",
+   *       collection: "users",
+   *       label: { en: "New User" },
+   *       icon: c.icon("ph:user-plus"),
+   *     }),
+   *   ],
+   *   items: [
+   *     d.section({
+   *       label: { en: "Overview" },
+   *       items: [
+   *         d.stats({ collection: "users", label: { en: "Total Users" } }),
+   *         d.chart({ collection: "posts", chartType: "line", dateField: "createdAt" }),
+   *       ],
+   *     }),
+   *   ],
+   * }))
+   * ```
+   */
+  dashboard(configFn: (ctx: DashboardConfigContext<TComponentNames>) => ServerDashboardConfig): this;
+  /**
+   * Configure the admin sidebar.
+   *
+   * @example
+   * ```ts
+   * .sidebar(({ s, c }) => s.sidebar({
+   *   sections: [
+   *     s.section({
+   *       id: "content",
+   *       title: { en: "Content" },
+   *       icon: c.icon("ph:files"),
+   *       items: [
+   *         { type: "collection", collection: "posts" },
+   *         { type: "collection", collection: "pages" },
+   *       ],
+   *     }),
+   *   ],
+   * }))
+   * ```
+   */
+  sidebar(configFn: (ctx: SidebarConfigContext<TComponentNames>) => ServerSidebarConfig): this;
+  /**
+   * Configure admin branding (name, logo).
+   *
+   * @example
+   * ```ts
+   * .branding({
+   *   name: { en: "My App", sk: "Moja Appka" },
+   * })
+   * ```
+   */
+  branding(config: ServerBrandingConfig): this;
+}
+/**
+ * Admin methods added to CollectionBuilder via monkey patching.
+ */
+interface CollectionBuilderAdminMethods<TFields extends Record<string, any> = Record<string, any>, TListViewNames extends string = string, TEditViewNames extends string = string, TComponentNames extends string = string> {
+  /**
+   * Set admin metadata for the collection.
+   */
+  admin(configOrFn: AdminCollectionConfig | ((ctx: AdminConfigContext<TComponentNames>) => AdminCollectionConfig)): this;
+  /**
+   * Configure list view for the collection.
+   */
+  list(configFn: (ctx: ListViewConfigContext<TFields, TListViewNames>) => ListViewConfig): this;
+  /**
+   * Configure form view for the collection.
+   */
+  form(configFn: (ctx: FormViewConfigContext<TFields, TEditViewNames>) => FormViewConfig): this;
+  /**
+   * Configure preview for the collection.
+   */
+  preview(config: PreviewConfig): this;
+  /**
+   * Configure actions for the collection.
+   * Enables built-in actions and custom actions with forms.
+   *
+   * @example
+   * ```ts
+   * .actions(({ a, c, fr }) => ({
+   *   builtin: [a.create(), a.delete(), a.deleteMany()],
+   *   custom: [
+   *     a.action({
+   *       id: "publish",
+   *       label: { en: "Publish" },
+   *       icon: c.icon("ph:check-circle"),
+   *       handler: async ({ itemId }) => {
+   *         return { type: "success", toast: { message: "Published!" } };
+   *       },
+   *     }),
+   *   ],
+   * }))
+   * ```
+   */
+  actions(configFn: (ctx: ActionsConfigContext<TFields, TComponentNames>) => ServerActionsConfig): this;
+}
+/**
+ * Admin methods added to GlobalBuilder via monkey patching.
+ */
+interface GlobalBuilderAdminMethods<TFields extends Record<string, any> = Record<string, any>, TEditViewNames extends string = string, TComponentNames extends string = string> {
+  /**
+   * Set admin metadata for the global.
+   */
+  admin(configOrFn: AdminGlobalConfig | ((ctx: AdminConfigContext<TComponentNames>) => AdminGlobalConfig)): this;
+  /**
+   * Configure form view for the global.
+   */
+  form(configFn: (ctx: FormViewConfigContext<TFields, TEditViewNames>) => FormViewConfig): this;
+}
+/**
+ * Type helper to add admin methods to a QuestpieBuilder type.
+ *
+ * @example
+ * ```ts
+ * const builder = q({ name: "app" }).use(adminModule) as WithAdminMethods<typeof q>;
+ * ```
+ */
+type WithAdminMethods<T> = T & QuestpieBuilderAdminMethods;
+/**
+ * Type helper to add admin methods to a CollectionBuilder type.
+ */
+type WithCollectionAdminMethods<T, TFields extends Record<string, any> = Record<string, any>, TListViewNames extends string = string, TEditViewNames extends string = string, TComponentNames extends string = string> = T & CollectionBuilderAdminMethods<TFields, TListViewNames, TEditViewNames, TComponentNames>;
+/**
+ * Type helper to add admin methods to a GlobalBuilder type.
+ */
+type WithGlobalAdminMethods<T, TFields extends Record<string, any> = Record<string, any>, TEditViewNames extends string = string, TComponentNames extends string = string> = T & GlobalBuilderAdminMethods<TFields, TEditViewNames, TComponentNames>;
+declare module "questpie" {
+  /**
+   * Admin methods for QuestpieBuilder.
+   * Added via runtime monkey patching in ./patch.ts.
+   */
+  interface QuestpieBuilderExtensions extends QuestpieBuilderAdminMethods {
+    /**
+     * Configure admin UI locales (separate from content locales).
+     *
+     * UI locales control the admin interface language.
+     * Content locales control which languages content can be edited in.
+     * These don't need to match.
+     *
+     * @example
+     * ```ts
+     * const cms = q({ name: "my-app" })
+     *   .use(adminModule)
+     *   // Content can be in 10 languages
+     *   .locale({
+     *     locales: [{ code: "en" }, { code: "sk" }, { code: "de" }, ...],
+     *     defaultLocale: "en",
+     *   })
+     *   // But admin UI only in 2 languages
+     *   .adminLocale({
+     *     locales: ["en", "sk"],
+     *     defaultLocale: "en",
+     *   })
+     *   .build({ ... });
+     * ```
+     */
+    adminLocale(config: AdminLocaleConfig): this;
+    /**
+     * Create a block builder bound to this Questpie builder.
+     * The block has access to all registered field types.
+     *
+     * @example
+     * ```ts
+     * const qb = q.use(adminModule);
+     *
+     * const heroBlock = qb.block("hero")
+     *   .label({ en: "Hero Section" })
+     *   .icon("ph:image")
+     *   .fields((f) => ({
+     *     title: f.text({ required: true }),  // typed from builder's field registry
+     *     subtitle: f.text(),
+     *   }));
+     *
+     * const cms = qb
+     *   .blocks({ hero: heroBlock })
+     *   .build({ ... });
+     * ```
+     */
+    block<TName extends string>(name: TName): BlockBuilder<{
+      name: TName;
+    }, QuestpieStateOf<this> extends {
+      fields: infer F extends Record<string, any>;
+    } ? F : Record<string, any>>;
+  }
+  /**
+   * Admin methods for CollectionBuilder.
+   * Uses FieldsOf<this> for lazy field type extraction - this prevents
+   * type explosion (TS7056) when combining many collections.
+   */
+  interface CollectionBuilderExtensions {
+    /**
+     * Set admin metadata for the collection.
+     */
+    admin(configOrFn: AdminCollectionConfig | ((ctx: AdminConfigContext<RegisteredComponentNamesOfBuilder<this>>) => AdminCollectionConfig)): this;
+    /**
+     * Configure list view for the collection.
+     * Field proxy `f` provides autocomplete for field names.
+     */
+    list(configFn: (ctx: ListViewConfigContext<FieldsOf<this>, RegisteredListViewNamesOfBuilder<this>>) => ListViewConfig): this;
+    /**
+     * Configure form view for the collection.
+     */
+    form(configFn: (ctx: FormViewConfigContext<FieldsOf<this>, RegisteredEditViewNamesOfBuilder<this>>) => FormViewConfig): this;
+    /**
+     * Configure preview for the collection.
+     */
+    preview(config: PreviewConfig): this;
+    /**
+     * Configure actions for the collection.
+     */
+    actions(configFn: (ctx: ActionsConfigContext<FieldsOf<this>, RegisteredComponentNamesOfBuilder<this>>) => ServerActionsConfig): this;
+  }
+  /**
+   * Admin methods for GlobalBuilder.
+   * Uses GlobalFieldsOf<this> for lazy field type extraction.
+   */
+  interface GlobalBuilderExtensions {
+    /**
+     * Set admin metadata for the global.
+     */
+    admin(configOrFn: AdminGlobalConfig | ((ctx: AdminConfigContext<RegisteredComponentNamesOfBuilder<this>>) => AdminGlobalConfig)): this;
+    /**
+     * Configure form view for the global.
+     */
+    form(configFn: (ctx: FormViewConfigContext<GlobalFieldsOf<this>, RegisteredEditViewNamesOfBuilder<this>>) => FormViewConfig): this;
+  }
+  interface QuestpieBuilderState<TName extends string = string, TCollections extends BuilderCollectionsMap = BuilderCollectionsMap, TGlobals extends BuilderGlobalsMap = BuilderGlobalsMap, TJobs extends BuilderJobsMap = BuilderJobsMap, TEmailTemplates extends BuilderEmailTemplatesMap = BuilderEmailTemplatesMap, TAuth extends BetterAuthOptions | Record<never, never> = Record<never, never>, TMessageKeys extends string = never, TBuilderFields extends BuilderFieldsMap = BuilderFieldsMap> {
+    listViews?: Record<string, ListViewDefinition>;
+    editViews?: Record<string, EditViewDefinition>;
+    components?: Record<string, ComponentDefinition>;
+    blocks?: Record<string, AnyBlockDefinition>;
+    dashboard?: ServerDashboardConfig;
+    sidebar?: ServerSidebarConfig;
+    branding?: ServerBrandingConfig;
+    /** Admin UI locale configuration (separate from content locales) */
+    adminLocale?: AdminLocaleConfig;
+  }
+  interface CollectionBuilderState {
+    admin?: AdminCollectionConfig;
+    adminList?: ListViewConfig;
+    adminForm?: FormViewConfig;
+    adminPreview?: PreviewConfig;
+    adminActions?: ServerActionsConfig;
+  }
+  interface GlobalBuilderState {
+    admin?: AdminGlobalConfig;
+    adminForm?: FormViewConfig;
+  }
+}
+//#endregion
+export { ActionReference, ActionsConfigContext, AdminBlockConfig, AdminCollectionConfig, AdminConfigContext, AdminGlobalConfig, AdminLocaleConfig, BlockCategoryConfig, BuiltinActionType, ComponentDefinition, ComponentFactory, ComponentReference, DashboardActionFactory, DashboardConfigContext, EditViewDefinition, EditViewFactory, FieldLayoutItem, FormFieldLayoutItem, FormReactiveConfig, FormReactiveContext, FormSectionLayout, FormSidebarConfig, FormTabConfig, FormTabsLayout, FormViewConfig, ListViewConfig, ListViewDefinition, ListViewFactory, PreviewConfig, ServerActionContext, ServerActionDefinition, ServerActionDownload, ServerActionEffects, ServerActionError, ServerActionForm, ServerActionFormField, ServerActionHandler, ServerActionRedirect, ServerActionResult, ServerActionSuccess, ServerActionsConfig, ServerBrandingConfig, ServerChartWidget, ServerCustomWidget, ServerDashboardAction, ServerDashboardConfig, ServerDashboardItem, ServerDashboardSection, ServerDashboardTab, ServerDashboardTabs, ServerDashboardWidget, ServerProgressWidget, ServerQuickAction, ServerQuickActionsWidget, ServerRecentItemsWidget, ServerSidebarCollectionItem, ServerSidebarConfig, ServerSidebarDividerItem, ServerSidebarGlobalItem, ServerSidebarItem, ServerSidebarLinkItem, ServerSidebarPageItem, ServerSidebarSection, ServerStatsWidget, ServerTableWidget, ServerTimelineWidget, ServerValueWidget, SidebarConfigContext, WidgetAccessRule, WidgetFetchContext, WithAdminMethods, WithCollectionAdminMethods, WithGlobalAdminMethods };
+//# sourceMappingURL=augmentation.d.mts.map