@gntik-ai/blocks 0.0.0-stage → 0.6.0

package/dist/index.d.ts

@@ -0,0 +1,3626 @@
+
+import { ComponentType, HTMLAttributes, ReactElement, ReactNode, Ref } from "react";
+import { LucideIcon } from "@gntik-ai/icons";
+import { AlertTone, BadgeTone, BreadcrumbItem, ButtonProps, CommandItem, DateInput, DateRange, DateRangePreset, MeterThresholds, MoreMenuAction, NavGroup, NavItem, NotificationItem, SparklineTone, StatusDefinition, StatusDotTone, TableDensity, UserMenuEntry, UserMenuUser, WizardLayoutProps, Workspace } from "@gntik-ai/ui";
+import { ChartColor, ChartStateProps, HeatmapProps, ValueFormatter } from "@gntik-ai/charts";
+import { FlowCanvasProps, FlowHandle, FlowNode, FlowNode as FlowNode$1, FlowNodeData, FlowNodeData as FlowNodeData$1, FlowNodeKind, FlowNodeKind as FlowNodeKind$1, FlowNodeRenderProps, FlowNodeRenderer, FlowNodeRenderer as FlowNodeRenderer$1, FlowTone, FlowTone as FlowTone$1 } from "@gntik-ai/flow";
+import { Monaco, MonacoLoader } from "@gntik-ai/editor";
+//#region src/meta.d.ts
+/** Metadata contract for a block: packages/blocks/src/<family>/<Name>/block.meta.ts. */
+interface BlockMeta {
+  /** Display name, e.g. "KPI row". */
+  name: string;
+  family: 'page-chrome' | 'shell' | 'data-display' | 'tables' | 'forms' | 'feedback' | 'billing' | 'team' | 'scheduling' | 'builders' | 'ai' | 'auth' | 'marketing';
+  status: 'stable' | 'beta' | 'experimental';
+  description: string;
+  /** @gntik-ai/ui (and other kit) components it composes, for docs and agents. */
+  uses: string[];
+  /** Optional per-instance copy contract, listed in docs and kit metadata. */
+  labels?: Array<{
+    key: string;
+    type: string;
+    state: string;
+  }>;
+}
+//#endregion
+//#region src/ai/AssistantCardGrid/fixtures.d.ts
+type AssistantStatus = 'active' | 'paused' | 'draft' | 'degraded' | 'failed';
+interface Assistant {
+  id: string;
+  name: string;
+  description: string;
+  /** Model identifier, e.g. "general-large". */
+  model: string;
+  /** Where it runs, e.g. "openai-compatible" or "self-hosted". */
+  runtime: string;
+  status: AssistantStatus;
+  /** Relative update time, e.g. "2h ago". */
+  updated?: string;
+  /** Optional link to the assistant's page. */
+  href?: string;
+}
+//#endregion
+//#region src/ai/AssistantCardGrid/AssistantCardGrid.d.ts
+export declare const ASSISTANT_STATUSES: Record<AssistantStatus, StatusDefinition>;
+export interface AssistantCardGridProps {
+  assistants?: Assistant[];
+  title?: string;
+  /** Called when a card is activated (cards with `href` also navigate). */
+  onSelect?: (assistant: Assistant) => void;
+  /** Shows a "New assistant" button. */
+  onCreate?: () => void;
+  /** Heading level of the section title (default h2); card names use the next level. */
+  titleAs?: 'h2' | 'h3';
+  className?: string;
+}
+/** Grid of assistants as clickable cards (1 → 2 → 3 columns). */
+export declare function AssistantCardGrid({ assistants, title, onSelect, onCreate, titleAs: TitleTag, className }: AssistantCardGridProps): import("react").JSX.Element;
+//#endregion
+//#region src/ai/AssistantCardGrid/block.meta.d.ts
+declare const meta$5: BlockMeta;
+//#endregion
+//#region src/ai/TraceWaterfall/fixtures.d.ts
+type SpanKind = 'chain' | 'llm' | 'tool' | 'retrieval' | 'http';
+interface TraceSpan {
+  id: string;
+  /** Parent span id; omit for the root span(s). */
+  parentId?: string;
+  name: string;
+  kind: SpanKind;
+  /** Start offset from the trace start, in ms. */
+  start: number;
+  /** Duration in ms. */
+  duration: number;
+  /** `running`: still in progress (its `duration` is the time elapsed so far). */
+  status: 'ok' | 'error' | 'running';
+  /** Extra key/value details shown in the side panel. */
+  attributes?: Record<string, string | number>;
+}
+export declare const traceSpans: TraceSpan[];
+/** A trace still in progress: the answer is being generated. */
+export declare const runningTraceSpans: TraceSpan[];
+//#endregion
+//#region src/ai/TraceWaterfall/span-details.d.ts
+/** StatusTag dictionary of span statuses (running is announced by its label, not colour alone). */
+export declare const SPAN_STATUSES: {
+  readonly ok: {
+    readonly label: "OK";
+    readonly tone: "success";
+  };
+  readonly error: {
+    readonly label: "Error";
+    readonly tone: "destructive";
+  };
+  readonly running: {
+    readonly label: "Running";
+    readonly tone: "info";
+  };
+};
+export declare function formatSpanDuration(ms: number): string;
+interface SpanDetailsProps {
+  span: TraceSpan;
+  /** Heading level of the span name. */
+  headingAs: 'h3' | 'h4' | 'h5';
+}
+/** Default content of the details pane: name, kind, status, timing and attributes. */
+export declare function SpanDetails({ span, headingAs: Heading }: SpanDetailsProps): import("react").JSX.Element;
+//#endregion
+//#region src/ai/TraceWaterfall/TraceWaterfall.d.ts
+export interface TraceWaterfallProps {
+  spans?: TraceSpan[];
+  title?: string;
+  /** Selected span (controlled). `null` selects nothing. */
+  selectedId?: string | null;
+  /** Span selected initially (defaults to the first root). */
+  defaultSelectedId?: string;
+  /** Called with the span selected by click, Enter or Space. */
+  onSelect?: (span: TraceSpan) => void;
+  /** Called with the id of the span selected (pair with `selectedId`). */
+  onSelectedIdChange?: (id: string) => void;
+  /** Span ids collapsed initially. */
+  defaultCollapsed?: string[];
+  /** Shows the details pane of the selected span (default true). */
+  showDetails?: boolean;
+  /** Custom content of the details pane (default: name, kind, status, timing and attributes). */
+  renderDetails?: (span: TraceSpan) => ReactNode;
+  /** Heading level of the title, to fit the page outline (default h3); inner headings use the next level. */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/**
+ * Trace waterfall: span tree + duration bars on a shared time axis + an optional details pane for
+ * the selected span. The span list is one tab stop: ↑/↓ move, Home/End jump, → expands or moves to
+ * the first child, ← collapses or moves to the parent, Enter/Space select.
+ */
+export declare function TraceWaterfall({ spans, title, selectedId: selectedProp, defaultSelectedId, onSelect, onSelectedIdChange, defaultCollapsed, showDetails, renderDetails, titleAs: TitleTag, className }: TraceWaterfallProps): import("react").JSX.Element;
+//#endregion
+//#region src/ai/TraceWaterfall/block.meta.d.ts
+declare const meta$72: BlockMeta;
+//#endregion
+//#region src/ai/TokenCostCard/fixtures.d.ts
+interface TokenUsagePeriod {
+  /** Stable id, e.g. "7d". */
+  id: string;
+  /** Toggle label, e.g. "7 days". */
+  label: string;
+  inputTokens: number;
+  outputTokens: number;
+  /** Spend in the period, in `currency`. */
+  cost: number;
+  /** Budget for the period, in `currency`. */
+  budget: number;
+}
+//#endregion
+//#region src/ai/TokenCostCard/TokenCostCard.d.ts
+export interface TokenCostCardProps {
+  /** One entry per selectable period (a single entry hides the switch). */
+  periods?: TokenUsagePeriod[];
+  defaultPeriod?: string;
+  /** ISO 4217 currency code for cost and budget. */
+  currency?: string;
+  title?: string;
+  /** Subtitle, e.g. the model or project the usage belongs to. */
+  description?: string;
+  /** Heading level of the title, to fit the page outline (default h3). */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** Token usage and spend for a period, with a budget meter. */
+export declare function TokenCostCard({ periods, defaultPeriod, currency, title, description, titleAs, className }: TokenCostCardProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/ai/TokenCostCard/block.meta.d.ts
+declare const meta$71: BlockMeta;
+//#endregion
+//#region src/ai/PromptEditor/PromptEditor.d.ts
+export interface PromptRunInput {
+  system: string;
+  user: string;
+  /** Values for every variable found in the prompts (missing ones are empty strings). */
+  variables: Record<string, string>;
+  temperature: number;
+  maxTokens: number;
+}
+export interface PromptEditorProps {
+  title?: string;
+  defaultSystem?: string;
+  defaultUser?: string;
+  /** Initial variable values (uncontrolled). */
+  defaultVariables?: Record<string, string>;
+  /** Variable values (controlled). Pair with `onVariablesChange`. */
+  variables?: Readonly<Record<string, string>>;
+  /** Called with every variable value (all keys kept) when one changes. */
+  onVariablesChange?: (variables: Record<string, string>) => void;
+  defaultTemperature?: number;
+  defaultMaxTokens?: number;
+  /** Upper bound of the max-tokens input. */
+  maxTokensLimit?: number;
+  /** Called on Run; return a promise to show the running state until it settles. */
+  onRun?: (input: PromptRunInput) => void | Promise<unknown>;
+  /** Heading level of the title, to fit the page outline (default h3); inner headings use the next level. */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** Unique `{{variable}}` names, in order of appearance. */
+export declare function extractPromptVariables(...texts: string[]): string[];
+/** Prompt playground: system + user prompts, detected variables, parameters and Run. */
+export declare function PromptEditor({ title, defaultSystem, defaultUser, defaultVariables, variables: variablesProp, onVariablesChange, defaultTemperature, defaultMaxTokens, maxTokensLimit, onRun, titleAs: TitleTag, className }: PromptEditorProps): import("react").JSX.Element;
+//#endregion
+//#region src/ai/PromptEditor/block.meta.d.ts
+declare const meta$53: BlockMeta;
+//#endregion
+//#region src/ai/EvaluationScorecard/fixtures.d.ts
+interface EvalMetric {
+  id: string;
+  label: string;
+  /** Minimum (or maximum, when lower is better) value that passes. */
+  threshold: number;
+  /** Defaults to true; false for costs and latencies. */
+  higherIsBetter?: boolean;
+  /** How values are shown: ratio as a percentage, or milliseconds. */
+  format?: 'percent' | 'ms' | 'number';
+  /** Change vs baseline that counts as a regression (same unit as the values). */
+  tolerance?: number;
+}
+interface EvalRow {
+  id: string;
+  dataset: string;
+  samples: number;
+  /** Samples that passed every check in this run. */
+  passed: number;
+  /** Samples that passed in the baseline run. */
+  baselinePassed: number;
+  scores: Record<string, number>;
+  baseline: Record<string, number>;
+}
+//#endregion
+//#region src/ai/EvaluationScorecard/EvaluationScorecard.d.ts
+export interface EvaluationScorecardProps {
+  metrics?: EvalMetric[];
+  rows?: EvalRow[];
+  title?: string;
+  /** Label of the run compared against, e.g. "baseline · v12". */
+  baselineLabel?: string;
+  /** Pass-rate drop (ratio) that counts as a regression. */
+  passRateTolerance?: number;
+  /** Heading level of the title, to fit the page outline (default h3). */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** Evaluation results by dataset and metric, compared with a baseline run. */
+export declare function EvaluationScorecard({ metrics, rows, title, baselineLabel, passRateTolerance, titleAs: TitleTag, className }: EvaluationScorecardProps): import("react").JSX.Element;
+//#endregion
+//#region src/ai/EvaluationScorecard/block.meta.d.ts
+declare const meta$23: BlockMeta;
+//#endregion
+//#region src/ai/ModelKeysList/fixtures.d.ts
+type ModelKeyStatus = 'connected' | 'failing' | 'untested' | 'revoked';
+interface ModelKey {
+  id: string;
+  /** Display name, e.g. "Production". */
+  name: string;
+  /** Provider or protocol, e.g. "Provider A", "openai-compatible", "self-hosted". */
+  provider: string;
+  /** Base URL for compatible or self-hosted endpoints. */
+  endpoint?: string;
+  /** Masked secret, e.g. "sk-…4f2a". Never pass the full key to the UI. */
+  maskedKey: string;
+  status: ModelKeyStatus;
+  /** Relative last-use time, e.g. "3 min ago". */
+  lastUsed?: string;
+}
+//#endregion
+//#region src/ai/ModelKeysList/ModelKeysList.d.ts
+export declare const MODEL_KEY_STATUSES: Record<ModelKeyStatus, StatusDefinition>;
+export interface ModelKeysListProps {
+  keys?: ModelKey[];
+  title?: string;
+  /** Tests a key; resolve true when the provider answered. Defaults to a simulated check. */
+  onTest?: (key: ModelKey) => Promise<boolean> | boolean;
+  /** Called after the revoke is confirmed. */
+  onRevoke?: (key: ModelKey) => void;
+  /** Shows an "Add key" button. */
+  onAdd?: () => void;
+  /** Heading level of the title, to fit the page outline (default h3). */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** Provider keys with masked secrets, connection tests and confirmed revocation. */
+export declare function ModelKeysList({ keys, title, onTest, onRevoke, onAdd, titleAs, className }: ModelKeysListProps): import("react").JSX.Element;
+//#endregion
+//#region src/ai/ModelKeysList/block.meta.d.ts
+declare const meta$41: BlockMeta;
+//#endregion
+//#region src/auth/shared.d.ts
+interface AuthHeaderProps {
+  eyebrow?: ReactNode;
+  title: ReactNode;
+  description?: ReactNode;
+  /** Defaults to h1. `null` omits the title heading. */
+  headingLevel?: 'h1' | 'h2' | 'h3' | null;
+  className?: string;
+}
+/** Eyebrow + title + supporting line used at the top of every auth form. */
+export declare function AuthHeader({ eyebrow, title, description, headingLevel: Heading, className }: AuthHeaderProps): import("react").JSX.Element;
+/** Horizontal rule with a centred caption ("Or continue with"). */
+export declare function AuthDivider({ children }: {
+  children: ReactNode;
+}): import("react").JSX.Element;
+/** Email by default; text mode supports a username or username-or-email identifier. */
+interface AuthIdentifierConfig {
+  type?: 'email' | 'text';
+  autoComplete?: string;
+  label?: ReactNode;
+  help?: ReactNode;
+  /** Optional stable id for the FieldDescription. Otherwise Base UI generates it. */
+  helpId?: string;
+  placeholder?: string;
+  minLength?: number;
+  maxLength?: number;
+}
+/** Kit-owned inline validation; consumers supply copy rather than running a second validator. */
+interface AuthValidationMessages {
+  identifierRequired?: string;
+  identifierInvalid?: string;
+  identifierTooShort?: string;
+  passwordRequired?: string;
+}
+/** Server errors use only these props plus the form's error alert; inline validation stays in the kit. */
+interface AuthFormAccessibilityProps {
+  fieldInvalid?: {
+    identifier?: boolean;
+    password?: boolean;
+  };
+  /** Id of the server alert (or an external feedback element), appended to flagged inputs. */
+  feedbackId?: string;
+  /** Describes the form itself; does not replace the per-field feedback association. */
+  'aria-describedby'?: string;
+  'aria-label'?: string;
+  'aria-labelledby'?: string;
+}
+/** Ordered text/email fields collected before the sign-up password. Ids must be unique. */
+interface AuthSignUpField {
+  id: string;
+  label: string;
+  placeholder?: string;
+  help?: ReactNode;
+  required?: boolean;
+  type?: 'text' | 'email';
+  autoComplete?: string;
+  /** Consumer copy for kit-owned validation. */
+  messages?: {
+    required?: string;
+    invalid?: string;
+  };
+}
+/** Consumer-owned copy and optional action when account creation is unavailable. */
+interface AuthUnavailableState {
+  title: ReactNode;
+  message: ReactNode;
+  action?: ReactNode;
+}
+/** Kit-owned sign-up validation with consumer-owned copy. */
+interface AuthSignUpValidationMessages {
+  passwordTooShort?: (minimum: number) => string;
+  termsRequired?: string;
+}
+//#endregion
+//#region src/auth/ForgotPasswordForm/ForgotPasswordForm.d.ts
+export interface ForgotPasswordFormRef {
+  focus(field: 'identifier'): void;
+}
+export interface ForgotPasswordFormProps extends AuthFormAccessibilityProps {
+  /** React 19 ref for focus after a server response; available in the request state. */
+  ref?: Ref<ForgotPasswordFormRef>;
+  identifier?: AuthIdentifierConfig;
+  /** The kit validates before submit. Supply copy here; do not add a second inline validator. */
+  messages?: AuthValidationMessages;
+  /** Requests the reset link. A returned promise shows the loading state; a rejection shows in the alert. */
+  onSubmit?: (email: string) => void | Promise<void>;
+  error?: string | null;
+  defaultEmail?: string;
+  /** Start on the "sent" step (e.g. after a redirect). */
+  defaultSent?: boolean;
+  signInHref?: string;
+  onBackToSignIn?: () => void;
+  eyebrow?: ReactNode;
+  title?: ReactNode;
+  description?: ReactNode;
+  sentTitle?: ReactNode;
+  sentDescription?: ReactNode;
+  /** Replaces the screen-reader sent announcement; `null` hides it. */
+  sentStatus?: ReactNode;
+  /** Replaces both resend/change-identifier actions; `null` hides them. */
+  resendActions?: ReactNode;
+  /** Applies to both request and sent states. `null` omits the internal heading. */
+  headingLevel?: AuthHeaderProps['headingLevel'];
+  className?: string;
+}
+/** Request a reset link by email, then a "check your inbox" state with resend and a way back. */
+export declare function ForgotPasswordForm({ identifier, messages, ref, fieldInvalid, feedbackId, 'aria-describedby': describedBy, 'aria-label': ariaLabel, 'aria-labelledby': labelledBy, onSubmit, error: errorProp, defaultEmail, defaultSent, signInHref, onBackToSignIn, eyebrow, title, description, sentTitle, sentDescription, sentStatus, resendActions, headingLevel, className }: ForgotPasswordFormProps): import("react").JSX.Element;
+//#endregion
+//#region src/auth/ForgotPasswordForm/block.meta.d.ts
+declare const meta$29: BlockMeta;
+//#endregion
+//#region src/auth/MfaChallenge/MfaChallenge.d.ts
+export type MfaMethod = 'code' | 'backup';
+export interface MfaChallengeProps {
+  /** Verifies the code. A returned promise shows the loading state; a rejection shows in the alert. */
+  onVerify?: (code: string, method: MfaMethod) => void | Promise<void>;
+  /** Sends a new code; the resend button then waits `resendCooldown` seconds. */
+  onResend?: () => void | Promise<void>;
+  /** Seconds between resends. */
+  resendCooldown?: number;
+  /** Seconds left before the first resend (a code was just sent). Defaults to `resendCooldown`. */
+  initialCooldown?: number;
+  /** Code length. */
+  length?: 6 | 8;
+  /** Where the code was sent, e.g. "a•••@example.com". Omit for authenticator apps. */
+  destination?: string;
+  error?: string | null;
+  loading?: boolean;
+  /** Called when the user gives up ("Back to sign in"). */
+  onCancel?: () => void;
+  eyebrow?: ReactNode;
+  title?: ReactNode;
+  className?: string;
+}
+/**
+ * Second-factor step: a one-time code (auto-submits when complete), a switch to a backup code,
+ * and a resend button with a countdown.
+ */
+export declare function MfaChallenge({ onVerify, onResend, resendCooldown, initialCooldown, length, destination, error: errorProp, loading: loadingProp, onCancel, eyebrow, title, className }: MfaChallengeProps): import("react").JSX.Element;
+//#endregion
+//#region src/auth/MfaChallenge/block.meta.d.ts
+declare const meta$40: BlockMeta;
+//#endregion
+//#region src/auth/ResetPasswordForm/ResetPasswordForm.d.ts
+export interface ResetPasswordFormProps {
+  /** Saves the new password. A returned promise shows the loading state; a rejection shows in the alert. */
+  onSubmit?: (password: string) => void | Promise<void>;
+  error?: string | null;
+  minPasswordLength?: number;
+  /** Called from the success state ("Continue to sign in"). */
+  onContinue?: () => void;
+  eyebrow?: ReactNode;
+  className?: string;
+}
+/** New password + confirmation with length and mismatch validation, then a success state. */
+export declare function ResetPasswordForm({ onSubmit, error: errorProp, minPasswordLength, onContinue, eyebrow, className }: ResetPasswordFormProps): import("react").JSX.Element;
+//#endregion
+//#region src/auth/ResetPasswordForm/block.meta.d.ts
+declare const meta$55: BlockMeta;
+//#endregion
+//#region src/auth/SignInForm/SignInForm.d.ts
+export interface SignInValues {
+  email: string;
+  /** Trimmed identifier in text mode. `email` remains available for existing consumers. */
+  identifier?: string;
+  password: string;
+  remember: boolean;
+}
+export interface SignInFormRef {
+  focus(field: 'identifier' | 'password'): void;
+}
+export interface SignInFormProps extends AuthFormAccessibilityProps {
+  /** React 19 ref for focus after a server response. */
+  ref?: Ref<SignInFormRef>;
+  identifier?: AuthIdentifierConfig;
+  /** The kit validates before submit. Supply copy here; do not add a second inline validator. */
+  messages?: AuthValidationMessages;
+  passwordHelp?: ReactNode;
+  passwordHelpId?: string;
+  /** Signs in. A returned promise shows the loading state; a rejection's message shows in the alert. */
+  onSubmit?: (values: SignInValues) => void | Promise<void>;
+  /** Error from the server (e.g. "Incorrect email or password"). */
+  error?: string | null;
+  /** Forces the loading state (when the parent tracks the request). */
+  loading?: boolean;
+  defaultEmail?: string;
+  forgotPasswordHref?: string;
+  onForgotPassword?: () => void;
+  signUpHref?: string;
+  onSignUp?: () => void;
+  /** Replaces the sign-up prompt; `null` hides it. Defaults to the existing account link. */
+  signUpPrompt?: ReactNode;
+  /** SSO area under the divider; defaults to SsoButtons, `null` hides it. */
+  sso?: ReactNode;
+  eyebrow?: ReactNode;
+  title?: ReactNode;
+  description?: ReactNode;
+  /** Omit the internal heading with null; the form keeps its accessible name. */
+  headingLevel?: AuthHeaderProps['headingLevel'];
+  className?: string;
+}
+/** Email + password sign-in with remember me, forgot-password link, SSO slot, error alert and loading. */
+export declare function SignInForm({ identifier, messages, passwordHelp, passwordHelpId, ref, fieldInvalid, feedbackId, 'aria-describedby': describedBy, 'aria-label': ariaLabel, 'aria-labelledby': labelledBy, onSubmit, error: errorProp, loading: loadingProp, defaultEmail, forgotPasswordHref, onForgotPassword, signUpHref, onSignUp, signUpPrompt, sso, eyebrow, title, description, headingLevel, className }: SignInFormProps): import("react").JSX.Element;
+//#endregion
+//#region src/auth/SignInForm/block.meta.d.ts
+declare const meta$60: BlockMeta;
+//#endregion
+//#region src/auth/SignUpForm/SignUpForm.d.ts
+export interface SignUpValues {
+  name: string;
+  email: string;
+  password: string;
+  /** Present only in configured mode. Text/email values are trimmed and keyed by field id. */
+  fields?: Record<string, string>;
+}
+export interface SignUpFormProps {
+  /** Ordered text/email inputs before Password. Omit to keep the default fields and payload. */
+  fields?: readonly AuthSignUpField[];
+  messages?: AuthSignUpValidationMessages;
+  /** Replaces all account creation controls with a consumer-supplied callout. */
+  unavailable?: AuthUnavailableState;
+  /** Resolving policy, separate from loading (an account submission). No form is rendered. */
+  policyLoading?: boolean;
+  /** Creates the account. A returned promise shows the loading state; a rejection shows in the alert. */
+  onSubmit?: (values: SignUpValues) => void | Promise<void>;
+  error?: string | null;
+  loading?: boolean;
+  /** Optional password guidance; receives the current minimum length when a function is supplied. */
+  passwordHelp?: ReactNode | ((minimum: number) => ReactNode);
+  /** Minimum password length. Defaults to 8. */
+  minPasswordLength?: number;
+  /** Omit to require consent; false removes the checkbox and consent validation. */
+  terms?: false;
+  termsHref?: string;
+  privacyHref?: string;
+  signInHref?: string;
+  onSignIn?: () => void;
+  /** SSO area under the divider; defaults to SsoButtons, `null` hides it. */
+  sso?: ReactNode;
+  eyebrow?: ReactNode;
+  title?: ReactNode;
+  description?: ReactNode;
+  className?: string;
+}
+/** Account creation: name, work email, password with a strength meter and a required terms checkbox. */
+export declare function SignUpForm({ fields, messages, unavailable, policyLoading, onSubmit, error: errorProp, loading: loadingProp, minPasswordLength, passwordHelp, terms: termsProp, termsHref, privacyHref, signInHref, onSignIn, sso, eyebrow, title, description, className }: SignUpFormProps): import("react").JSX.Element;
+//#endregion
+//#region src/auth/SignUpForm/block.meta.d.ts
+declare const meta$61: BlockMeta;
+//#endregion
+//#region src/auth/SsoButtons/fixtures.d.ts
+interface SsoProvider {
+  id: string;
+  /** Full button text, e.g. "Continue with SSO". */
+  label: string;
+  /** A neutral lucide icon (no brand logos or colours). */
+  icon?: LucideIcon;
+}
+export declare const ssoProviders: SsoProvider[];
+//#endregion
+//#region src/auth/SsoButtons/SsoButtons.d.ts
+export interface SsoButtonsProps {
+  providers?: SsoProvider[];
+  /** Called with the provider id. */
+  onSelect?: (providerId: string) => void;
+  /** Provider currently redirecting (shows a spinner and disables the others). */
+  loadingId?: string | null;
+  disabled?: boolean;
+  /** `stack` (full-width rows, default) or `grid` (two columns from `sm`). */
+  layout?: 'stack' | 'grid';
+  /** Accessible name of the group. */
+  label?: string;
+  className?: string;
+}
+/** Neutral single-sign-on buttons: text labels and lucide icons, no brand colours or logos. */
+export declare function SsoButtons({ providers, onSelect, loadingId, disabled, layout, label, className }: SsoButtonsProps): import("react").JSX.Element;
+//#endregion
+//#region src/auth/SsoButtons/block.meta.d.ts
+declare const meta$64: BlockMeta;
+//#endregion
+//#region src/billing/format.d.ts
+/** Shared formatting for the billing blocks (en-US, Intl). */
+/** A calendar date: a `Date` or an ISO `YYYY-MM-DD` string (read as a local date, no UTC shift). */
+type DateInput$1 = Date | string;
+//#endregion
+//#region src/billing/PlanCard/PlanSummary.d.ts
+/** Consumer data only: each summary region is optional. Prices are cycle totals. */
+interface SummaryPlan {
+  name?: string;
+  statusLabel?: string;
+  statusTone?: BadgeTone;
+  priceMonthly?: number;
+  priceAnnual?: number;
+  currency?: string;
+  cycle?: BillingCycle;
+  renewsOn?: DateInput$1;
+  features?: string[];
+}
+interface PlanSummaryProps {
+  variant: 'summary';
+  plan?: SummaryPlan;
+  emptyLabel?: string;
+  /** Consumer-supplied kit Buttons or native links. No built-in actions. */
+  actions?: ReactNode;
+  defaultCycle?: BillingCycle;
+  onCycleChange?: (cycle: BillingCycle) => void;
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+//#endregion
+//#region src/billing/PlanCard/PlanCard.d.ts
+export type PlanStatus = 'active' | 'trialing' | 'past_due' | 'canceled';
+export type BillingCycle = 'monthly' | 'annual';
+export interface BillingPlan {
+  name: string;
+  status?: PlanStatus;
+  /** Price per month on the monthly cycle. */
+  priceMonthly: number;
+  /** Price per month when billed annually. Enables the monthly/annual toggle. */
+  priceAnnual?: number;
+  /** ISO 4217 code. Default USD. */
+  currency?: string;
+  /** Next renewal date. */
+  renewsOn: DateInput$1;
+  /** Short line after the renewal date, e.g. "50 seats · 2 regions". */
+  summary?: string;
+  features?: string[];
+}
+export interface BillingPlanCardProps {
+  variant?: 'billing';
+  plan?: BillingPlan;
+  /** Initial cycle shown (uncontrolled). */
+  defaultCycle?: BillingCycle;
+  onCycleChange?: (cycle: BillingCycle) => void;
+  onUpgrade?: () => void;
+  onManage?: () => void;
+  upgradeLabel?: string;
+  manageLabel?: string;
+  /** Heading level of the title, to fit the page outline (default h3). */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+export type PlanCardProps = BillingPlanCardProps | PlanSummaryProps;
+/** Default billing header, or an opt-in summary without sample data. */
+export declare function PlanCard(props: PlanCardProps): import("react").JSX.Element;
+//#endregion
+//#region src/billing/PlanCard/block.meta.d.ts
+declare const meta$49: BlockMeta;
+//#endregion
+//#region src/billing/PlanCard/fixtures.d.ts
+/** Sample current plan (neutral workspace data). */
+export declare const samplePlan: BillingPlan;
+//#endregion
+//#region src/billing/PlanDefinitionCard/PlanDefinitionCard.d.ts
+export type PlanDefinitionStatus = 'draft' | 'active' | 'deprecated' | 'archived';
+export interface PlanDefinition {
+  name: string;
+  slug: string;
+  description?: string;
+  status: PlanDefinitionStatus;
+  capabilities?: Record<string, boolean>;
+  quotas?: Record<string, string | number>;
+  tenantCount: number;
+  updatedAt: DateInput$1;
+}
+export interface PlanDefinitionCardProps {
+  plan?: PlanDefinition;
+  density?: 'compact' | 'full';
+  /** Consumer-supplied kit Buttons or native links; no billing actions. */
+  actions?: ReactNode;
+  statusLabels?: Partial<Record<PlanDefinitionStatus, string>>;
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** Administrative plan information, with no commercial fields or actions. */
+export declare function PlanDefinitionCard({ plan, density, actions, statusLabels, titleAs: TitleTag, className }: PlanDefinitionCardProps): import("react").JSX.Element;
+//#endregion
+//#region src/billing/PlanDefinitionCard/block.meta.d.ts
+declare const meta$50: BlockMeta;
+//#endregion
+//#region src/billing/PlanDefinitionCard/fixtures.d.ts
+export declare const samplePlanDefinition: PlanDefinition;
+//#endregion
+//#region src/billing/QuotaMeters/QuotaMeters.d.ts
+export interface Quota {
+  id: string;
+  label: string;
+  used: number;
+  limit: number;
+  /** End-of-cycle projection. When any quota has one, a Current/Projected toggle appears. */
+  projected?: number;
+  /** Unit after the numbers, e.g. "requests" or "GB". */
+  unit?: string;
+  /** Helper line under the bar. Over the limit, a default overage note is shown. */
+  note?: ReactNode;
+}
+export type QuotaScope = 'current' | 'projected';
+export interface QuotaMetersProps {
+  quotas?: Quota[];
+  /** Heading above the meters. */
+  title?: string;
+  /** Percent-of-limit thresholds for amber and red (default 80 / 100). */
+  thresholds?: MeterThresholds;
+  /** Formats used/limit numbers. Default: grouped, compact above a million. */
+  formatValue?: (value: number) => string;
+  defaultScope?: QuotaScope;
+  onScopeChange?: (scope: QuotaScope) => void;
+  /** Heading level of the title, to fit the page outline (default h3). */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** Plan quotas as meters: green with headroom, amber near the cap, red over it. */
+export declare function QuotaMeters({ quotas, title, thresholds, formatValue, defaultScope, onScopeChange, titleAs: TitleTag, className }: QuotaMetersProps): import("react").JSX.Element;
+//#endregion
+//#region src/billing/QuotaMeters/block.meta.d.ts
+declare const meta$54: BlockMeta;
+//#endregion
+//#region src/billing/QuotaMeters/fixtures.d.ts
+/** Sample plan quotas: usage so far this cycle and the end-of-cycle projection. */
+export declare const sampleQuotas: Quota[];
+//#endregion
+//#region src/billing/SpendVsBudget/SpendVsBudget.d.ts
+export interface SpendPoint {
+  /** X-axis label, e.g. "May 12". */
+  label: string;
+  /** Cumulative actual spend; null after today. */
+  spend: number | null;
+  /** Cumulative forecast; null before today. Start it on the last actual point to join the lines. */
+  forecast?: number | null;
+}
+export interface SpendVsBudgetProps {
+  data?: SpendPoint[];
+  /** Budget cap for the period (drawn as a flat line). */
+  budget?: number;
+  currency?: string;
+  title?: string;
+  /** Period caption, e.g. "May cycle". */
+  period?: string;
+  /** Chart plot height in px. */
+  height?: number;
+  /** Heading level of the title, to fit the page outline (default h3). */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** Cumulative spend against a budget cap, with the end-of-period forecast. */
+export declare function SpendVsBudget({ data, budget, currency, title, period, height, titleAs: TitleTag, className }: SpendVsBudgetProps): import("react").JSX.Element;
+//#endregion
+//#region src/billing/SpendVsBudget/block.meta.d.ts
+declare const meta$63: BlockMeta;
+//#endregion
+//#region src/billing/SpendVsBudget/fixtures.d.ts
+/**
+ * Sample cumulative spend for a 30-day cycle: actuals through day 18, forecast after.
+ * The forecast starts on the last actual point so the two lines join.
+ */
+export declare const sampleSpend: SpendPoint[];
+export declare const sampleBudget = 2000;
+//#endregion
+//#region src/billing/InvoiceTable/InvoiceTable.d.ts
+export type InvoiceStatus = 'paid' | 'open' | 'overdue' | 'void' | 'draft';
+export interface Invoice {
+  id: string;
+  /** Human invoice number, e.g. "INV-2026-0004". */
+  number: string;
+  /** Issue date. */
+  date: DateInput$1;
+  amount: number;
+  /** ISO 4217 code. Default: the table's currency. */
+  currency?: string;
+  status: InvoiceStatus;
+  /** PDF URL. Without it the download control calls `onDownload` only. */
+  url?: string;
+}
+export interface InvoiceTableProps {
+  invoices?: Invoice[];
+  /** Table caption (screen-reader only unless `showCaption`). */
+  caption?: string;
+  showCaption?: boolean;
+  currency?: string;
+  /** Called when a download control is activated. */
+  onDownload?: (invoice: Invoice) => void;
+  /** Row density; omitted, it follows the surrounding DensityProvider. */
+  density?: 'compact' | 'comfortable';
+  className?: string;
+}
+/** Invoice history: number, date, amount, status and a per-row PDF download. */
+export declare function InvoiceTable({ invoices, caption, showCaption, currency, onDownload, density, className }: InvoiceTableProps): import("react").JSX.Element;
+//#endregion
+//#region src/billing/InvoiceTable/block.meta.d.ts
+declare const meta$36: BlockMeta;
+//#endregion
+//#region src/billing/InvoiceTable/fixtures.d.ts
+/** Sample invoice history. */
+export declare const sampleInvoices: Invoice[];
+//#endregion
+//#region src/billing/PaymentMethodCard/PaymentMethodCard.d.ts
+export type PaymentMethodStatus = 'valid' | 'expiring' | 'expired';
+export interface PaymentMethod {
+  /** Card network as text, e.g. "Visa", "Mastercard", "Amex". */
+  brand: string;
+  last4: string;
+  expMonth: number;
+  expYear: number;
+  holder?: string;
+  isDefault?: boolean;
+  /** Computed by the app (the block never reads the clock). */
+  status?: PaymentMethodStatus;
+}
+export interface PaymentMethodCardProps {
+  method?: PaymentMethod;
+  title?: string;
+  description?: string;
+  onUpdate?: () => void;
+  onRemove?: () => void;
+  updateLabel?: string;
+  /** Heading level of the title, to fit the page outline (default h3). */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** The payment method on file: brand, masked number, expiry and an update action. No card artwork. */
+export declare function PaymentMethodCard({ method, title, description, onUpdate, onRemove, updateLabel, titleAs, className }: PaymentMethodCardProps): import("react").JSX.Element;
+//#endregion
+//#region src/billing/PaymentMethodCard/block.meta.d.ts
+declare const meta$47: BlockMeta;
+//#endregion
+//#region src/billing/PaymentMethodCard/fixtures.d.ts
+/** Sample default payment method. */
+export declare const samplePaymentMethod: PaymentMethod;
+//#endregion
+//#region src/billing/CostBreakdown/CostBreakdown.d.ts
+export interface CostItem {
+  label: string;
+  amount: number;
+}
+export interface CostBreakdownProps {
+  items?: CostItem[];
+  currency?: string;
+  title?: string;
+  /** Caption under the total in the donut hole. */
+  centerLabel?: string;
+  /** Donut diameter in px. */
+  size?: number;
+  /** Heading level of the title, to fit the page outline (default h3). */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** Where the spend goes: a donut by category plus the categories ranked by amount. */
+export declare function CostBreakdown({ items, currency, title, centerLabel, size, titleAs: TitleTag, className }: CostBreakdownProps): import("react").JSX.Element;
+//#endregion
+//#region src/billing/CostBreakdown/block.meta.d.ts
+declare const meta$12: BlockMeta;
+//#endregion
+//#region src/billing/CostBreakdown/fixtures.d.ts
+/** Sample cycle cost by category. */
+export declare const sampleCosts: CostItem[];
+//#endregion
+//#region src/builders/FlowBuilder/fixtures.d.ts
+/** React Flow edge, as FlowCanvas takes it. */
+type FlowEdge = NonNullable<FlowCanvasProps['edges']>[number];
+interface PaletteItem {
+  kind: FlowNodeKind$1;
+  /** Default title of a node created from this item. */
+  title: string;
+  description: string;
+}
+interface ConsoleEntry {
+  id: string;
+  /** Display time, e.g. "10:42:07". */
+  time: string;
+  level: 'info' | 'success' | 'warn' | 'error';
+  message: string;
+}
+//#endregion
+//#region src/builders/FlowBuilder/extensions.d.ts
+/** Connection plus node type identifiers, for consumer edge mapping and validation. */
+interface FlowConnection {
+  source: string;
+  target: string;
+  sourceHandle: string | null;
+  targetHandle: string | null;
+  sourceType: string;
+  targetType: string;
+}
+interface FlowValidationIssue {
+  code: string;
+  nodeId?: string;
+  message: string;
+}
+interface FlowConnectionRejection extends FlowValidationIssue {
+  nodeId: string;
+}
+interface FlowBuilderExtensions {
+  mode?: 'edit' | 'run';
+  nodeStatus?: Readonly<Record<string, FlowTone$1 | undefined>>;
+  onNodeSelect?: (id: string) => void;
+  validationIssues?: readonly FlowValidationIssue[];
+  nodeTypes?: readonly FlowNodeRenderer$1[];
+  /** Return edge kind and payload; endpoints always come from the connection. */
+  onConnectEdge?: (connection: FlowConnection) => Pick<FlowEdge, 'type' | 'data'>;
+  /** Return true to accept, false for a generic rejection, or an issue for a specific reason. Pure: called during dragging. */
+  isValidConnection?: (connection: FlowConnection) => boolean | FlowValidationIssue;
+  onConnectionRejected?: (issue: FlowConnectionRejection) => void;
+  /** Called only after an accepted connection has been added. */
+  onConnect?: (connection: FlowConnection) => void;
+}
+//#endregion
+//#region src/builders/FlowBuilder/FlowBuilder.d.ts
+export interface FlowBuilderProps<Kind extends string = FlowNodeKind$1> extends FlowBuilderExtensions {
+  title?: string;
+  nodes?: FlowNode$1<Kind | FlowNodeKind$1>[];
+  edges?: FlowEdge[];
+  palette?: PaletteItem[];
+  /**
+   * Console output (controlled). Run and Clear then report the next list through
+   * `onConsoleChange` instead of updating it internally.
+   */
+  consoleEntries?: ConsoleEntry[];
+  /** Initial console output (uncontrolled). Defaults to the sample entries. */
+  defaultConsoleEntries?: ConsoleEntry[];
+  /** Called with the next console list after a run appends to it or it is cleared. */
+  onConsoleChange?: (entries: ConsoleEntry[]) => void;
+  /** Called when the console's Clear button is pressed. */
+  onConsoleClear?: () => void;
+  /** Heading level of the builder title (default h2); panel titles use the next level. */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  /** Total height of the builder on wide screens (px). */
+  height?: number;
+  /**
+   * Called with the current graph when Run is pressed. Return console entries (or a promise
+   * of them) to log the real run; return nothing to log a simulated run. While a returned
+   * promise is pending the Run button shows a loading state; a rejection is logged as an error.
+   */
+  onRun?: (graph: {
+    nodes: FlowNode$1<Kind | FlowNodeKind$1>[];
+    edges: FlowEdge[];
+  }) => FlowRunResult | Promise<FlowRunResult>;
+  className?: string;
+}
+/** What `onRun` may return: entries to append, or nothing for the simulated run. */
+export type FlowRunResult = ConsoleEntry[] | void | undefined;
+/**
+ * Visual flow builder: node palette, brand React Flow canvas (drag, connect, zoom/pan),
+ * inspector for the selected node and a run console, in resizable panels. On small screens
+ * the panels stack.
+ */
+export declare function FlowBuilder<Kind extends string = FlowNodeKind$1>({ title, nodes: initialNodes, edges: initialEdges, palette, consoleEntries, defaultConsoleEntries, onConsoleChange, onConsoleClear, titleAs: TitleTag, height, onRun, nodeTypes, onConnectEdge, onConnect: onConnected, isValidConnection, onConnectionRejected, validationIssues, mode, nodeStatus, onNodeSelect, className }: FlowBuilderProps<Kind>): import("react").JSX.Element;
+//#endregion
+//#region src/builders/FlowBuilder/parts.d.ts
+/** Heading level of a panel title (one below the builder's title). */
+type PanelHeading = 'h3' | 'h4' | 'h5';
+interface NodePaletteProps {
+  items: PaletteItem[];
+  onAdd: (item: PaletteItem) => void;
+  /** Heading level of the panel title (default h3). */
+  titleAs?: PanelHeading;
+}
+/** Left rail: node kinds to add to the canvas. */
+export declare function NodePalette({ items, onAdd, titleAs: TitleTag }: NodePaletteProps): import("react").JSX.Element;
+interface NodeInspectorProps<Kind extends string = FlowNodeKind$1> {
+  node: FlowNode$1<Kind> | undefined;
+  onChange: (id: string, patch: Partial<FlowNodeData$1>) => void;
+  onDelete: (id: string) => void;
+  /** Heading level of the panel title (default h3). */
+  titleAs?: PanelHeading;
+}
+/** Right rail: the selected node's editable fields. */
+export declare function NodeInspector<Kind extends string = FlowNodeKind$1>({ node, onChange, onDelete, titleAs: TitleTag }: NodeInspectorProps<Kind>): import("react").JSX.Element;
+interface RunConsoleProps {
+  entries: ConsoleEntry[];
+  onClear: () => void;
+  /** Heading level of the panel title (default h3). */
+  titleAs?: PanelHeading;
+}
+/** Bottom panel: run output (role="log"). */
+export declare function RunConsole({ entries, onClear, titleAs: TitleTag }: RunConsoleProps): import("react").JSX.Element;
+//#endregion
+//#region src/builders/FlowBuilder/block.meta.d.ts
+declare const meta$28: BlockMeta;
+//#endregion
+//#region src/builders/CodePanel/fixtures.d.ts
+interface CodeFile {
+  /** File path, shown as the tab label. */
+  path: string;
+  /** Monaco language id. */
+  language: string;
+  content: string;
+  /** Previous version; enables the diff view for this file. */
+  original?: string;
+}
+type ProblemSeverity = 'error' | 'warning' | 'info';
+interface CodeProblem {
+  id: string;
+  severity: ProblemSeverity;
+  message: string;
+  /** Path of the file the problem belongs to. */
+  file: string;
+  line: number;
+  column?: number;
+  /** Tool that reported it, e.g. "tsc" or "schema". */
+  source?: string;
+}
+//#endregion
+//#region src/builders/CodePanel/markers.d.ts
+/** Consumer line marker. Use a distinct owner for each external diagnostics service. */
+interface CodePanelMarker extends CodeProblem {
+  owner: string;
+  endLine?: number;
+  endColumn?: number;
+}
+type MonacoReady = (monaco: Monaco) => void | (() => void);
+//#endregion
+//#region src/builders/CodePanel/CodePanel.d.ts
+type View = 'code' | 'diff';
+export interface CodePanelProps {
+  files?: CodeFile[];
+  readOnly?: boolean;
+  markers?: readonly CodePanelMarker[];
+  /** Fires when the merged error count crosses zero (warnings do not invalidate). */
+  onValidityChange?: (valid: boolean) => void;
+  /** Configure consumer language services; optionally return their cleanup function. */
+  onMonacoReady?: MonacoReady;
+  problems?: CodeProblem[];
+  /** Path of the file opened first (uncontrolled; defaults to the first file). */
+  defaultFile?: string;
+  /** Path of the open file (controlled). Pair with `onActiveFileChange`. */
+  activeFile?: string;
+  /** Called with the path of the file to open (tab click, arrow keys, or a problem in another file). */
+  onActiveFileChange?: (path: string) => void;
+  /** Heading level of the "Problems" heading, to fit the page outline (default 3). */
+  headingLevel?: 2 | 3 | 4 | 5 | 6;
+  defaultView?: View;
+  /** Editor height (px or CSS length). */
+  height?: number | string;
+  /** Called with the file path and its new text on every edit. */
+  onChange?: (path: string, value: string) => void;
+  /** Called when a problem is picked in the list (the editor also jumps to it). */
+  onProblemSelect?: (problem: CodeProblem) => void;
+  /** Monaco loader passed to the editors (self-hosting, tests). Monaco loads lazily by default. */
+  loader?: MonacoLoader;
+  className?: string;
+}
+/**
+ * Multi-file code panel: file tabs, Monaco editor (or diff against the previous version) and
+ * a problems list that jumps to the reported line. Monaco is loaded lazily by @gntik-ai/editor.
+ */
+export declare function CodePanel({ files, problems: suppliedProblems, readOnly, markers, onValidityChange, onMonacoReady, defaultFile, activeFile: activeProp, onActiveFileChange, headingLevel, defaultView, height, onChange, onProblemSelect, loader, className }: CodePanelProps): import("react").JSX.Element;
+//#endregion
+//#region src/builders/CodePanel/block.meta.d.ts
+declare const meta$8: BlockMeta;
+//#endregion
+//#region src/builders/LogViewer/fixtures.d.ts
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LogLine {
+  id: string;
+  /** Display timestamp, e.g. "12:04:31.118". */
+  timestamp: string;
+  level: LogLevel;
+  message: string;
+  /** Emitting component, e.g. "worker-2". */
+  source?: string;
+}
+//#endregion
+//#region src/builders/LogViewer/LogViewer.d.ts
+export declare const LOG_LEVELS: LogLevel[];
+export interface LogViewerProps {
+  /** Log lines, oldest first. */
+  lines?: LogLine[];
+  /** Accessible name of the log region and visible title. */
+  title?: string;
+  /** Height of the scrolling viewport in px. */
+  height?: number;
+  /** Fixed row height in px (the windowing math relies on it). */
+  rowHeight?: number;
+  /** Rows rendered above and below the visible window. */
+  overscan?: number;
+  /** Levels shown initially. */
+  defaultLevels?: LogLevel[];
+  /** Start pinned to the newest line. */
+  defaultFollow?: boolean;
+  /** Called after a line is copied. */
+  onCopyLine?: (line: LogLine) => void;
+  /** Enables an inspect button and mouse selection on each visible row. */
+  onSelectLine?: (line: LogLine) => void;
+  /** Selected inspect button, exposed through aria-pressed. */
+  selectedLineId?: string;
+  /** Announce appended lines while following (default true). False keeps aria-live off. */
+  announceLines?: boolean;
+  /** Heading level of the title, to fit the page outline (default h3). */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/**
+ * Log stream viewer. Only the visible rows are rendered (fixed row height + scroll offset),
+ * so it stays fast with thousands of lines. Level filter, search with highlighted matches,
+ * follow-tail and per-line copy.
+ */
+export declare function LogViewer({ lines, title, height, rowHeight, overscan, defaultLevels, defaultFollow, onCopyLine, onSelectLine, selectedLineId, announceLines, titleAs: TitleTag, className }: LogViewerProps): import("react").JSX.Element;
+//#endregion
+//#region src/builders/LogViewer/block.meta.d.ts
+declare const meta$38: BlockMeta;
+//#endregion
+//#region src/data-display/shared/TrendDelta.d.ts
+/** Arrow shape of a change. */
+export type DeltaDirection = 'up' | 'down' | 'flat';
+/** Whether the change is good, bad or neither — independent of its direction (lower latency is good). */
+export type DeltaSentiment = 'positive' | 'negative' | 'neutral';
+export interface KpiDelta {
+  /** Display text, e.g. "+12.4%". */
+  value: string;
+  direction: DeltaDirection;
+  sentiment: DeltaSentiment;
+  /** Comparison context, e.g. "vs. previous 24h". */
+  note?: string;
+}
+export interface TrendDeltaProps extends KpiDelta {
+  className?: string;
+}
+/**
+ * Mono delta with a triangle: the arrow follows `direction`, the colour follows `sentiment`.
+ * Screen readers get the direction and sentiment in words.
+ */
+export declare function TrendDelta({ value, direction, sentiment, className }: TrendDeltaProps): import("react").JSX.Element;
+//#endregion
+//#region src/data-display/KpiRow/KpiRow.d.ts
+export interface KpiItem {
+  id: string;
+  label: string;
+  /** Pre-formatted value ("38,921", "842 ms"). */
+  value: string;
+  delta?: KpiDelta;
+  /** Optional series for a sparkline under the value, oldest first. */
+  trend?: readonly number[];
+  trendTone?: SparklineTone;
+}
+export interface KpiRowProps {
+  /** 3–5 tiles read best; more wrap onto a new row. */
+  items?: readonly KpiItem[];
+  /** `cards` (one card per KPI, default) or `strip` (a single divided card, for page headers). */
+  variant?: 'cards' | 'strip';
+  /** Draw sparklines for items that have a `trend`. */
+  showTrends?: boolean;
+  /** Accessible name of the list. */
+  label?: string;
+  className?: string;
+}
+/**
+ * KPI row: label, big number, delta (direction and sentiment are independent) and an optional
+ * Sparkline. A description list, so each label is announced with its value.
+ */
+export declare function KpiRow({ items, variant, showTrends, label, className }: KpiRowProps): import("react").JSX.Element;
+//#endregion
+//#region src/data-display/KpiRow/block.meta.d.ts
+declare const meta$37: BlockMeta;
+//#endregion
+//#region src/data-display/KpiRow/fixtures.d.ts
+/** Four project KPIs: note latency and spend — same arrow logic, different sentiment. */
+export declare const KPI_ITEMS: KpiItem[];
+//#endregion
+//#region src/data-display/StatCard/StatCard.d.ts
+export interface StatCardRange {
+  /** Range key, e.g. "7d". */
+  value: string;
+  /** Toggle label. */
+  label: string;
+  /** Pre-formatted headline value for this range. */
+  stat: string;
+  delta?: KpiDelta;
+  /** Series drawn under the value, oldest first. */
+  series: readonly number[];
+}
+export interface StatCardProps {
+  label?: string;
+  /** Leading icon tile (a lucide icon). */
+  icon?: LucideIcon;
+  /** One entry per range; with a single entry the range toggle is hidden. */
+  ranges?: readonly StatCardRange[];
+  /** Initially selected range (uncontrolled). */
+  defaultRange?: string;
+  /** Selected range (controlled). */
+  range?: string;
+  onRangeChange?: (range: string) => void;
+  /** `area` line (default) or daily `bar` shape. */
+  chart?: 'area' | 'bar';
+  tone?: SparklineTone;
+  /** Footer link-style action ("View requests →"). */
+  action?: {
+    label: string;
+    onClick?: () => void;
+    href?: string;
+  };
+  /** Heading level of the title, to fit the page outline (default h3). */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** A single rich stat: icon tile, label, value, delta, a range toggle and a trend chart, with a footer action. */
+export declare function StatCard({ label, icon: IconCmp, ranges, defaultRange, range: rangeProp, onRangeChange, chart, tone, action, titleAs: TitleTag, className }: StatCardProps): import("react").JSX.Element;
+//#endregion
+//#region src/data-display/StatCard/block.meta.d.ts
+declare const meta$65: BlockMeta;
+//#endregion
+//#region src/data-display/StatCard/fixtures.d.ts
+/** Requests per range: the value and delta recalculate when the range changes. */
+export declare const STAT_RANGES: StatCardRange[];
+//#endregion
+//#region src/data-display/ChartCard/fixtures.d.ts
+interface CostPoint {
+  day: string;
+  Compute: number;
+  Storage: number;
+  Network: number;
+}
+/** Infrastructure cost by resource, per range. */
+export declare const COST_BY_RANGE: Record<string, CostPoint[]>;
+export declare const COST_RANGES: ChartCardRange[];
+interface TrafficRow {
+  day: string;
+  '00h': number;
+  '03h': number;
+  '06h': number;
+  '09h': number;
+  '12h': number;
+  '15h': number;
+  '18h': number;
+  '21h': number;
+}
+/** Three-hour buckets of TRAFFIC_BY_RANGE, in display order. */
+export declare const TRAFFIC_BUCKETS: readonly ["00h", "03h", "06h", "09h", "12h", "15h", "18h", "21h"];
+/** Requests (thousands) per weekday and three-hour bucket: a heatmap for a ChartCard. */
+export declare const TRAFFIC_BY_RANGE: Record<string, TrafficRow[]>;
+export declare const TRAFFIC_RANGES: ChartCardRange[];
+//#endregion
+//#region src/data-display/ChartCard/ChartCard.d.ts
+export interface ChartCardRange {
+  /** Range key ("7d"); also the key into `dataByRange`. */
+  value: string;
+  label: string;
+  /** Optional headline for this range. */
+  summary?: {
+    value: string;
+    delta?: KpiDelta;
+  };
+}
+/** Heatmap-only options of a ChartCard with `kind="heatmap"`. */
+export type ChartCardHeatmapOptions = Pick<HeatmapProps<object>, 'scale' | 'domain' | 'steps' | 'showValues' | 'rowHeader'>;
+export interface ChartCardProps<T extends object> extends ChartStateProps {
+  title?: string;
+  description?: string;
+  /** Ordered options; defaults to 7d/30d/90d. Unknown range keys fall back to the first option. */
+  ranges?: readonly ChartCardRange[];
+  /** Chart rows per range key. */
+  dataByRange?: Readonly<Record<string, readonly T[]>>;
+  /** X-axis field (heatmap: the row label field). */
+  index?: Extract<keyof T, string>;
+  /** Series fields, one legend entry each (heatmap: the columns, in order). */
+  categories?: ReadonlyArray<Extract<keyof T, string>>;
+  /**
+   * Chart type. `heatmap` renders an @gntik-ai/charts Heatmap: rows from `index`, columns from
+   * `categories`, its hue from `colors[0]`, its colour scale as the legend (`showLegend`) and its
+   * cells sized to fill `height`.
+   */
+  kind?: 'area' | 'line' | 'bar' | 'heatmap';
+  /** Heatmap options (scale, domain, steps, showValues, rowHeader). */
+  heatmap?: ChartCardHeatmapOptions;
+  stacked?: boolean;
+  colors?: readonly ChartColor[];
+  valueFormatter?: ValueFormatter;
+  showLegend?: boolean;
+  /** Hide the range control when a page toolbar owns the controlled `range`. */
+  showRangeToggle?: boolean;
+  /** Plot height in px (heatmap: the grid, column labels included). */
+  height?: number;
+  /** Initial uncontrolled selection; defaults to the first option. */
+  defaultRange?: string;
+  /** Controlled selection. Changes are requested through `onRangeChange` until this prop updates. */
+  range?: string;
+  onRangeChange?: (range: string) => void;
+  /** Extra header control (e.g. a MoreMenu), after the range toggle. */
+  action?: ReactNode;
+  /** Footer content under the chart. */
+  footer?: ReactNode;
+  /** Heading level of the title, to fit the page outline (default h3). */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/**
+ * Chart in a Card: title, optional headline value + delta, a configurable range ToggleGroup, and an
+ * @gntik-ai/charts area, line, bar or heatmap chart with its legend (heatmap: its colour scale).
+ * Defaults to 7d/30d/90d; hide the toggle when a toolbar owns the controlled range.
+ * The chart states (`state`, `emptyMessage`, `errorMessage`, `onRetry`) and `dataTable` pass through.
+ */
+export declare function ChartCard<T extends object = CostPoint>({ title, description, ranges, dataByRange, index, categories, kind, heatmap, stacked, colors, valueFormatter, showLegend, showRangeToggle, height, defaultRange, range: rangeProp, onRangeChange, action, footer, titleAs, className, state, emptyMessage, errorMessage, onRetry, dataTable }: ChartCardProps<T>): import("react").JSX.Element;
+//#endregion
+//#region src/data-display/ChartCard/block.meta.d.ts
+declare const meta$7: BlockMeta;
+//#endregion
+//#region src/data-display/DescriptionListCard/DescriptionListCard.d.ts
+export interface DescriptionItem {
+  id: string;
+  label: string;
+  /** Text value; also what the copy button copies unless `copyValue` is set. */
+  value?: string;
+  /** Rich value (overrides `value` for display). */
+  render?: ReactNode;
+  /** Shows the value as a StatusTag with this state key. */
+  status?: string;
+  /** Monospace value (IDs, regions, URLs). */
+  mono?: boolean;
+  /** Adds a copy button. */
+  copyable?: boolean;
+  copyValue?: string;
+}
+export interface DescriptionListCardProps {
+  title?: string;
+  description?: string;
+  items?: readonly DescriptionItem[];
+  /** Shows an Edit button in the header. */
+  onEdit?: () => void;
+  editLabel?: string;
+  /** Called after a value is copied. */
+  onCopy?: (item: DescriptionItem) => void;
+  /** Heading level of the title, to fit the page outline (default h3). */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** Key–value detail card: label column, values (mono, status or rich), copy buttons and an Edit action. */
+export declare function DescriptionListCard({ title, description, items, onEdit, editLabel, onCopy, titleAs, className }: DescriptionListCardProps): import("react").JSX.Element;
+//#endregion
+//#region src/data-display/DescriptionListCard/block.meta.d.ts
+declare const meta$18: BlockMeta;
+//#endregion
+//#region src/data-display/DescriptionListCard/fixtures.d.ts
+/** Configuration of a deployment. */
+export declare const DEPLOYMENT_DETAILS: DescriptionItem[];
+//#endregion
+//#region src/data-display/ResourceCardGrid/ResourceCardGrid.d.ts
+export interface ResourceCard {
+  id: string;
+  name: string;
+  description?: string;
+  /** Icon tile (a lucide icon). Ignored when `avatar` is set. */
+  icon?: LucideIcon;
+  /** Avatar instead of the icon tile (people, teams, organisations). */
+  avatar?: {
+    name: string;
+    src?: string;
+  };
+  /** StatusTag state key (running, paused, failed…). */
+  status?: string;
+  /** Two or three small figures at the bottom of the card. */
+  meta?: ReadonlyArray<{
+    label: string;
+    value: string;
+  }>;
+}
+export type ResourceAction = 'open' | 'rename' | 'duplicate' | 'delete';
+export interface ResourceCardGridProps {
+  items?: readonly ResourceCard[];
+  /** Accessible name of the list. */
+  label?: string;
+  /** Called with the default actions (Open, Rename, Duplicate, Delete). */
+  onAction?: (action: ResourceAction, item: ResourceCard) => void;
+  /** Replaces the default menu entirely. Return an empty array to hide the menu. */
+  getActions?: (item: ResourceCard) => Array<MoreMenuAction | 'separator'>;
+  /** Columns at the widest breakpoint. */
+  columns?: 2 | 3 | 4;
+  /** Heading level of each card's name, to fit the page outline (default h3). */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** Responsive grid of resource cards: icon or avatar, name, status, meta figures and a row-actions MoreMenu. */
+export declare function ResourceCardGrid({ items, label, onAction, getActions, columns, titleAs: TitleTag, className }: ResourceCardGridProps): import("react").JSX.Element;
+//#endregion
+//#region src/data-display/ResourceCardGrid/block.meta.d.ts
+declare const meta$56: BlockMeta;
+//#endregion
+//#region src/data-display/ResourceCardGrid/fixtures.d.ts
+/** Project resources. */
+export declare const RESOURCE_CARDS: ResourceCard[];
+//#endregion
+//#region src/data-display/StatusTimeline/StatusTimeline.d.ts
+export interface StatusEvent {
+  id: string;
+  /** Short state name next to the dot ("Running"). */
+  status: string;
+  tone: StatusDotTone;
+  title: string;
+  description?: string;
+  at: DateInput;
+  /** Who or what caused the change. */
+  actor?: string;
+  /** Pulses the dot (the current, in-progress state). */
+  live?: boolean;
+}
+export interface StatusTimelineProps {
+  /** Events, newest first. */
+  events?: readonly StatusEvent[];
+  /** Accessible name of the list. */
+  label?: string;
+  /** Title shown when events is an explicit empty array. */
+  emptyLabel?: string;
+  /** Collapse toggle text. */
+  showFewerLabel?: string;
+  /** Expand toggle text, given the number of hidden events. */
+  showEarlierLabel?: (hidden: number) => string;
+  /** Prefix before the actor's name. */
+  actorLabel?: string;
+  /** Events shown before "Show earlier"; all when omitted. */
+  maxVisible?: number;
+  /** `relative` ("3 hours ago") or `absolute` timestamps. */
+  timeFormat?: 'relative' | 'absolute';
+  className?: string;
+}
+/** Vertical timeline of state changes, or a named empty state for an explicit empty events array. */
+export declare function StatusTimeline({ events, label: labelProp, emptyLabel: emptyLabelProp, showFewerLabel: showFewerLabelProp, showEarlierLabel: showEarlierLabelProp, actorLabel: actorLabelProp, maxVisible, timeFormat, className }: StatusTimelineProps): import("react").JSX.Element;
+//#endregion
+//#region src/data-display/StatusTimeline/block.meta.d.ts
+declare const meta$66: BlockMeta;
+//#endregion
+//#region src/data-display/StatusTimeline/fixtures.d.ts
+/** State changes of a deployment, newest first. */
+export declare const DEPLOYMENT_EVENTS: StatusEvent[];
+//#endregion
+//#region src/data-display/ActivityFeed/ActivityFeed.d.ts
+export interface ActivityItem {
+  id: string;
+  actor: {
+    name: string;
+    src?: string;
+  };
+  /** Verb phrase ("deployed", "invited"). */
+  action: string;
+  /** Object of the action, emphasised ("orders-api v2.14.0"). */
+  target?: string;
+  at: DateInput;
+}
+export interface ActivityFeedProps {
+  /** Items, newest first. */
+  items?: readonly ActivityItem[];
+  /** Accessible name of the feed. */
+  label?: string;
+  /** Reference "now" for the Today / Yesterday headings (defaults to the mount time). */
+  now?: DateInput;
+  locale?: string;
+  /** Shows a "Load more" button. */
+  onLoadMore?: () => void;
+  loadingMore?: boolean;
+  /** Heading level of the day-group titles, to fit the page outline (default h3). */
+  groupHeadingAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+interface DayGroup {
+  key: string;
+  label: string;
+  items: ActivityItem[];
+}
+/** Groups items by calendar day (local time), labelled Today, Yesterday or the date. */
+export declare function groupActivityByDay(items: readonly ActivityItem[], now: Date, locale?: string): DayGroup[];
+/** Activity feed: actor avatar, action, target and Timestamp, grouped by day. */
+export declare function ActivityFeed({ items, label, now, locale, onLoadMore, loadingMore, groupHeadingAs: GroupTag, className }: ActivityFeedProps): import("react").JSX.Element;
+//#endregion
+//#region src/data-display/ActivityFeed/block.meta.d.ts
+declare const meta$1: BlockMeta;
+//#endregion
+//#region src/data-display/ActivityFeed/fixtures.d.ts
+/** Project activity, newest first. */
+export declare const PROJECT_ACTIVITY: ActivityItem[];
+//#endregion
+//#region src/data-display/CommentThread/CommentThread.d.ts
+export interface CommentAuthor {
+  name: string;
+  src?: string;
+}
+export interface ThreadComment {
+  id: string;
+  author: CommentAuthor;
+  /** Plain text (no markdown); line breaks are kept. */
+  body: string;
+  at: DateInput;
+}
+export interface CommentThreadProps {
+  comments?: readonly ThreadComment[];
+  /** Author of new comments (the signed-in user). */
+  currentUser?: CommentAuthor;
+  /** Called with the trimmed text when a comment is posted. */
+  onSubmit?: (body: string) => void;
+  /** Append posted comments locally (default). Turn off when the parent updates `comments`. */
+  appendOnSubmit?: boolean;
+  /** Accessible name of the thread. */
+  label?: string;
+  placeholder?: string;
+  submitLabel?: string;
+  className?: string;
+}
+/** Comment thread: avatar, author, plain-text body and Timestamp, with a reply composer (⌘/Ctrl+Enter posts). */
+export declare function CommentThread({ comments, currentUser, onSubmit, appendOnSubmit, label: labelProp, placeholder: placeholderProp, submitLabel: submitLabelProp, className }: CommentThreadProps): import("react").JSX.Element;
+//#endregion
+//#region src/data-display/CommentThread/block.meta.d.ts
+declare const meta$9: BlockMeta;
+//#endregion
+//#region src/data-display/CommentThread/fixtures.d.ts
+export declare const COMMENT_AUTHOR: CommentAuthor;
+/** Review discussion on a pull request, oldest first. */
+export declare const REVIEW_COMMENTS: ThreadComment[];
+//#endregion
+//#region src/feedback/types.d.ts
+/** An action rendered as a kit Button, or as a Link when `href` is set. */
+interface FeedbackAction {
+  id?: string;
+  label: string;
+  href?: string;
+  icon?: LucideIcon;
+  variant?: ButtonProps['variant'];
+  disabled?: boolean;
+  onClick?: () => void;
+}
+//#endregion
+//#region src/feedback/SystemBanner/SystemBanner.d.ts
+export type SystemBannerKind = 'maintenance' | 'incident' | 'info';
+export interface SystemBannerProps {
+  kind?: SystemBannerKind;
+  /** Bold lead-in. */
+  title?: ReactNode;
+  message?: ReactNode;
+  /** Optional call to action (status page, details). */
+  action?: FeedbackAction | null;
+  /** Shows a dismiss button. Incidents are usually not dismissible. */
+  dismissible?: boolean;
+  /** Controlled visibility; omit to let the banner hide itself on dismiss. */
+  open?: boolean;
+  onDismiss?: () => void;
+  className?: string;
+}
+/**
+ * Full-width banner above the app chrome for system-wide notices. Incidents are announced
+ * assertively (role="alert"); maintenance and info politely (role="status").
+ */
+export declare function SystemBanner({ kind, title, message, action, dismissible, open, onDismiss, className }: SystemBannerProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/feedback/SystemBanner/block.meta.d.ts
+declare const meta$69: BlockMeta;
+//#endregion
+//#region src/feedback/InlineCallout/InlineCallout.d.ts
+export interface InlineCalloutProps {
+  tone?: AlertTone;
+  title?: ReactNode;
+  description?: ReactNode;
+  /** Buttons (or links when `href` is set) under the text; the first is the main one. */
+  actions?: FeedbackAction[];
+  /** Replaces the tone icon; `null` hides it. */
+  icon?: LucideIcon | null;
+  /** Shows a dismiss button; the callout hides itself unless `open` is controlled. */
+  dismissible?: boolean;
+  open?: boolean;
+  onDismiss?: () => void;
+  className?: string;
+}
+/** In-content callout built on Alert: tone, title, body and a row of actions. */
+export declare function InlineCallout({ tone, title, description, actions, icon, dismissible, open, onDismiss, className }: InlineCalloutProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/feedback/InlineCallout/block.meta.d.ts
+declare const meta$33: BlockMeta;
+//#endregion
+//#region src/feedback/EmptyStates/EmptyStates.d.ts
+interface SharedEmptyProps {
+  /** Heading level that fits the page outline. */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  /** Dashed border around the state (use inside a card or table). */
+  bordered?: boolean;
+  className?: string;
+}
+export interface FirstRunEmptyProps extends SharedEmptyProps {
+  icon?: LucideIcon;
+  title?: ReactNode;
+  description?: ReactNode;
+  actionLabel?: string;
+  onAction?: () => void;
+  /** Secondary link (docs, guide). `null` hides it. */
+  secondary?: {
+    label: string;
+    href: string;
+  } | null;
+  /** Short checklist of what the first run involves. */
+  steps?: string[];
+}
+/** First-run state: nothing created yet; explains the value and offers the first action. */
+export declare function FirstRunEmpty({ icon, title, description, actionLabel, onAction, secondary, steps, titleAs, bordered, className }: FirstRunEmptyProps): import("react").JSX.Element;
+export interface NoResultsEmptyProps extends SharedEmptyProps {
+  /** The search text that matched nothing. */
+  query?: string;
+  /** Number of active filters (shows "Clear filters" when > 0). */
+  filterCount?: number;
+  /** Plural noun for what is being searched. */
+  entity?: string;
+  onClearFilters?: () => void;
+  onClearSearch?: () => void;
+}
+/** No-results state for a filtered list or table: echoes the query and offers ways out. */
+export declare function NoResultsEmpty({ query, filterCount, entity, onClearFilters, onClearSearch, titleAs, bordered, className }: NoResultsEmptyProps): import("react").JSX.Element;
+export interface NoAccessEmptyProps extends SharedEmptyProps {
+  /** What the viewer cannot see. */
+  resource?: string;
+  /** Who can grant access. */
+  owner?: string;
+  /** Called on "Request access"; may return a promise (the button shows a spinner). */
+  onRequestAccess?: () => void | Promise<void>;
+  /** Start in the "requested" state (e.g. a pending request exists). */
+  defaultRequested?: boolean;
+}
+/** Permission state: the viewer lacks access; explains who can grant it and lets them ask. */
+export declare function NoAccessEmpty({ resource, owner, onRequestAccess, defaultRequested, titleAs, bordered, className }: NoAccessEmptyProps): import("react").JSX.Element;
+//#endregion
+//#region src/feedback/EmptyStates/fixtures.d.ts
+/** Neutral sample copy for the empty states. */
+export declare const firstRunSteps: string[];
+export declare const noResultsSample: {
+  readonly query: "billing-api";
+  readonly filterCount: 2;
+  readonly entity: "projects";
+};
+export declare const noAccessSample: {
+  readonly resource: "Billing";
+  readonly owner: "an organization admin";
+};
+//#endregion
+//#region src/feedback/EmptyStates/block.meta.d.ts
+declare const meta$20: BlockMeta;
+//#endregion
+//#region src/feedback/Skeletons/Skeletons.d.ts
+export interface TableSkeletonProps {
+  rows?: number;
+  columns?: number;
+  /** Screen-reader announcement. */
+  label?: string;
+  className?: string;
+}
+/** Table placeholder: header strip plus rows with an avatar cell, text cells and a status pill. */
+export declare function TableSkeleton({ rows, columns, label: labelProp, className }: TableSkeletonProps): import("react").JSX.Element;
+export interface ListSkeletonProps {
+  rows?: number;
+  label?: string;
+  className?: string;
+}
+/** List placeholder: avatar, two text lines, a pill and a row action. */
+export declare function ListSkeleton({ rows, label: labelProp, className }: ListSkeletonProps): import("react").JSX.Element;
+export interface PageSkeletonProps {
+  /** Number of stat cards. */
+  stats?: number;
+  /** Rows of the table under the stats. */
+  rows?: number;
+  label?: string;
+  className?: string;
+}
+/** Whole-page placeholder: header (title, meta, actions), a stat row and a table. */
+export declare function PageSkeleton({ stats, rows, label: labelProp, className }: PageSkeletonProps): import("react").JSX.Element;
+//#endregion
+//#region src/feedback/Skeletons/block.meta.d.ts
+declare const meta$62: BlockMeta;
+//#endregion
+//#region src/feedback/ConfirmDestructive/ConfirmDestructive.d.ts
+export interface ConfirmDestructiveProps {
+  /** Exact name the user must type to unlock the action. */
+  resourceName?: string;
+  /** What kind of resource it is (used in the default copy). */
+  resourceType?: string;
+  title?: ReactNode;
+  description?: ReactNode;
+  /** What will be lost, as a short list. */
+  consequences?: string[];
+  /** Label of the confirming button (and of the default trigger). */
+  confirmLabel?: string;
+  /** Default trigger button text; `null` renders no trigger (control `open` instead). */
+  triggerLabel?: string | null;
+  open?: boolean;
+  defaultOpen?: boolean;
+  onOpenChange?: (open: boolean) => void;
+  /** Runs on confirm. Returning a promise keeps the dialog open with a spinner until it settles; a rejection shows its message. */
+  onConfirm?: () => void | Promise<void>;
+}
+/**
+ * Typed-confirmation for irreversible actions: an AlertDialog whose destructive button stays
+ * disabled until the resource name is typed exactly.
+ */
+export declare function ConfirmDestructive({ resourceName, resourceType, title, description, consequences, confirmLabel, triggerLabel, open, defaultOpen, onOpenChange, onConfirm }: ConfirmDestructiveProps): import("react").JSX.Element;
+//#endregion
+//#region src/feedback/ConfirmDestructive/block.meta.d.ts
+declare const meta$11: BlockMeta;
+//#endregion
+//#region src/feedback/ErrorPanel/ErrorPanel.d.ts
+export interface ErrorPanelProps {
+  icon?: LucideIcon;
+  title?: ReactNode;
+  /** Human summary of what failed and what to do. */
+  message?: ReactNode;
+  /** Status or error code shown as a mono chip (e.g. 503, ECONNRESET). */
+  code?: string | number | null;
+  /** Correlation id for support; gets a copy button. */
+  requestId?: string;
+  /** Raw details (response body, stack) behind a disclosure. */
+  details?: string;
+  /** Retry handler. A returned promise shows the loading state until it settles. */
+  onRetry?: () => void | Promise<void>;
+  /** Force the loading state from outside. */
+  retrying?: boolean;
+  retryLabel?: string;
+  /** Extra action next to Retry (e.g. contact support). */
+  secondaryAction?: FeedbackAction | null;
+  titleAs?: 'h2' | 'h3';
+  className?: string;
+}
+/** Error summary for a failed load or action: what happened, request id, retry and technical details. */
+export declare function ErrorPanel({ icon: Icon, title, message, code, requestId, details, onRetry, retrying, retryLabel: retryLabelProp, secondaryAction, titleAs: Heading, className }: ErrorPanelProps): import("react").JSX.Element;
+//#endregion
+//#region src/feedback/ErrorPanel/block.meta.d.ts
+declare const meta$22: BlockMeta;
+//#endregion
+//#region src/forms/DangerZone/fixtures.d.ts
+interface DangerZoneAction {
+  id: string;
+  title: string;
+  description: string;
+  /** Label of the row button and of the confirming button. */
+  actionLabel: string;
+  /** Text the user must type to confirm (e.g. the resource name). Omit for a plain confirmation. */
+  confirmText?: string;
+  /** Use the destructive button style in the row (default true); `false` renders a secondary button. */
+  destructive?: boolean;
+}
+export declare const dangerZoneActions: DangerZoneAction[];
+//#endregion
+//#region src/forms/DangerZone/DangerZone.d.ts
+export interface DangerZoneProps {
+  title?: ReactNode;
+  description?: ReactNode;
+  actions?: DangerZoneAction[];
+  /** Called after the user confirms an action. A returned promise shows a loading state. */
+  onConfirm?: (actionId: string) => void | Promise<void>;
+  headingLevel?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/**
+ * Bordered destructive section. Each action opens a confirmation dialog; actions with
+ * `confirmText` require typing it (e.g. the project name) before the confirm button enables.
+ */
+export declare function DangerZone({ title, description, actions, onConfirm, headingLevel: Heading, className }: DangerZoneProps): import("react").JSX.Element;
+//#endregion
+//#region src/forms/DangerZone/block.meta.d.ts
+declare const meta$15: BlockMeta;
+//#endregion
+//#region src/forms/CreateApiKeyDialog/fixtures.d.ts
+interface ApiKeyScope {
+  value: string;
+  label: string;
+  description?: string;
+}
+interface ApiKeyExpiry {
+  value: string;
+  label: string;
+}
+export declare const apiKeyScopes: ApiKeyScope[];
+export declare const apiKeyExpiries: ApiKeyExpiry[];
+/** Demo secret generator (the real secret comes from your API). */
+export declare function generateDemoSecret(prefix?: string): string;
+//#endregion
+//#region src/forms/CreateApiKeyDialog/CreateApiKeyDialog.d.ts
+export interface CreateApiKeyInput {
+  name: string;
+  scopes: string[];
+  expiry: string;
+}
+export interface CreateApiKeyDialogProps {
+  scopes?: ApiKeyScope[];
+  expiries?: ApiKeyExpiry[];
+  defaultExpiry?: string;
+  /** Creates the key and returns its secret (shown once). Defaults to a demo generator. */
+  onCreate?: (input: CreateApiKeyInput) => string | Promise<string>;
+  open?: boolean;
+  defaultOpen?: boolean;
+  onOpenChange?: (open: boolean) => void;
+  /** Trigger element (rendered through Dialog.Trigger). Pass `null` when controlling `open` yourself. */
+  trigger?: ReactElement | null;
+}
+/**
+ * Two-step API key dialog: name, scopes and expiry, then the secret shown once in a CodeBlock
+ * with copy. Closing the dialog discards the secret; it can't be shown again.
+ */
+export declare function CreateApiKeyDialog({ scopes, expiries, defaultExpiry, onCreate, open: openProp, defaultOpen, onOpenChange, trigger }: CreateApiKeyDialogProps): import("react").JSX.Element;
+//#endregion
+//#region src/forms/CreateApiKeyDialog/block.meta.d.ts
+declare const meta$13: BlockMeta;
+//#endregion
+//#region src/forms/CredentialDisclosureDialog/CredentialDisclosureDialog.d.ts
+export interface CredentialDisclosure {
+  variant: 'stored' | 'fresh';
+  credentialId: string;
+  /** Caller-formatted expiry; the block applies no expiry policy. */
+  expiresAt: ReactNode;
+  secret: string;
+}
+export interface CredentialDisclosureDialogProps {
+  /** Set only after a successful response. Leave null while pending or on failure. */
+  disclosure: CredentialDisclosure | null;
+  /** Clear disclosure to null on dismissal, dropping the secret in the consumer. */
+  onClose: () => void;
+  /** Resolve the current row action at close time, including after list reloads. */
+  resolveReturnFocus?: () => HTMLElement | null;
+  /** Resolve a fallback such as a page heading with tabIndex={-1}. */
+  fallbackFocus?: () => HTMLElement | null;
+  title?: string;
+  description?: string;
+  credentialIdLabel?: string;
+  expiryLabel?: string;
+  secretLabel?: string;
+  showLabel?: string;
+  hideLabel?: string;
+  copyLabel?: string;
+  copiedLabel?: string;
+  successAnnouncement?: string;
+  failureAnnouncement?: string;
+  warningTitle?: string;
+  warningText?: string;
+  closeLabel?: string;
+}
+/**
+ * Discloses an existing credential only after a successful response. Consumers keep disclosure
+ * null while pending or on failure, and clear it on close. No pending/error state or internal
+ * secret retention. A fresh secret requires a new successful response to be shown again.
+ */
+export declare function CredentialDisclosureDialog(props: CredentialDisclosureDialogProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/forms/CredentialDisclosureDialog/block.meta.d.ts
+declare const meta$14: BlockMeta;
+//#endregion
+//#region src/forms/DateRangeFilter/DateRangeFilter.d.ts
+export interface DateRangeFilterProps {
+  value?: DateRange;
+  /** Initial range; defaults to the "Last 7 days" preset. Pass `{ start: null, end: null }` for none. */
+  defaultValue?: DateRange;
+  /** Called with a complete range, or an empty one when cleared. */
+  onValueChange?: (range: DateRange) => void;
+  presets?: DateRangePreset[];
+  /** "Today" for the presets (defaults to the current date). */
+  today?: Date;
+  /** Accessible name of the field. */
+  label?: string;
+  placeholder?: string;
+  /** Show a clear button while a range is set. */
+  clearable?: boolean;
+  disabled?: boolean;
+  className?: string;
+}
+/** Compact DateRangePicker for toolbars: small trigger, short dates, presets and a clear button. */
+export declare function DateRangeFilter({ value, defaultValue, onValueChange, presets, today, label: labelProp, placeholder: placeholderProp, clearable, disabled, className }: DateRangeFilterProps): import("react").JSX.Element;
+//#endregion
+//#region src/forms/DateRangeFilter/block.meta.d.ts
+declare const meta$17: BlockMeta;
+//#endregion
+//#region src/forms/FileUploadPanel/fixtures.d.ts
+type UploadStatus = 'uploading' | 'done' | 'error';
+interface UploadItem {
+  id: string;
+  name: string;
+  /** Size in bytes. */
+  size: number;
+  /** 0–100. */
+  progress: number;
+  status: UploadStatus;
+  /** Why the file was rejected or failed. */
+  error?: string;
+}
+export declare const uploadItems: UploadItem[];
+/** Demo uploader: reports progress in steps and resolves after ~1.5 s. */
+export declare function simulateUpload(_file: File, onProgress: (pct: number) => void): Promise<void>;
+//#endregion
+//#region src/forms/FileUploadPanel/FileUploadPanel.d.ts
+export interface FileUploadPanelProps {
+  /** Accepted types, as for `<input accept>` (".csv,.json", "image/*"). */
+  accept?: string;
+  /** Maximum size per file in bytes. */
+  maxSize?: number;
+  multiple?: boolean;
+  /** Initial list (e.g. files already uploaded). */
+  defaultFiles?: UploadItem[];
+  /** Uploads one file and reports progress (0–100). Defaults to a demo simulation. */
+  onUpload?: (file: File, onProgress: (pct: number) => void) => Promise<void>;
+  onRemove?: (item: UploadItem) => void;
+  /** Visible label of the panel. */
+  label?: string;
+  /** Hint under the drop text; defaults to the accepted types and size limit. */
+  hint?: string;
+  disabled?: boolean;
+  className?: string;
+}
+/**
+ * Drop zone with a Browse button, accept and size validation, and a file list with progress,
+ * retry and remove. Rejected files stay in the list with the reason.
+ */
+export declare function FileUploadPanel({ accept, maxSize, multiple, defaultFiles, onUpload, onRemove, label: labelProp, hint, disabled, className }: FileUploadPanelProps): import("react").JSX.Element;
+//#endregion
+//#region src/forms/FileUploadPanel/block.meta.d.ts
+declare const meta$26: BlockMeta;
+//#endregion
+//#region src/forms/FormSection/FormSection.d.ts
+export interface FormSectionProps extends Omit<HTMLAttributes<HTMLElement>, 'title' | 'className'> {
+  /** Section title shown in the left column; also names the section landmark. */
+  title?: ReactNode;
+  /** Help text under the title. */
+  description?: ReactNode;
+  /** The fields (right column). Defaults to a sample "General" field set. */
+  children?: ReactNode;
+  /** Footer row under the fields (e.g. Save / Cancel). */
+  actions?: ReactNode;
+  /** Heading level that fits the page outline. */
+  headingLevel?: 'h2' | 'h3' | 'h4';
+  /** Draws a rule above the section (for stacked sections). */
+  divided?: boolean;
+  className?: string;
+}
+/**
+ * Two-column form section: title and help on the left, fields on the right. Stacks into a
+ * single column on small screens.
+ */
+export declare function FormSection({ title, description, children, actions, headingLevel: Heading, divided, className, ...props }: FormSectionProps): import("react").JSX.Element;
+//#endregion
+//#region src/forms/FormSection/block.meta.d.ts
+declare const meta$30: BlockMeta;
+//#endregion
+//#region src/forms/InviteMembersDialog/fixtures.d.ts
+interface RoleOption {
+  value: string;
+  label: string;
+  description?: string;
+}
+export declare const memberRoles: RoleOption[];
+//#endregion
+//#region src/forms/InviteMembersDialog/InviteMembersDialog.d.ts
+export interface InvitePayload {
+  emails: string[];
+  role: string;
+  message: string;
+}
+export interface InviteMembersDialogProps {
+  roles?: RoleOption[];
+  defaultRole?: string;
+  /** Sends the invitations. A returned promise shows a loading state; a rejection shows its message. */
+  onInvite?: (payload: InvitePayload) => void | Promise<void>;
+  /** Maximum number of addresses per batch. */
+  maxInvites?: number;
+  open?: boolean;
+  defaultOpen?: boolean;
+  onOpenChange?: (open: boolean) => void;
+  /** Trigger element (rendered through Dialog.Trigger). Pass `null` when controlling `open` yourself. */
+  trigger?: ReactElement | null;
+  title?: string;
+  description?: string;
+}
+/** Invite dialog: email chips with validation, a role and an optional message; submit with loading. */
+export declare function InviteMembersDialog({ roles, defaultRole, onInvite, maxInvites, open: openProp, defaultOpen, onOpenChange, trigger, title, description }: InviteMembersDialogProps): import("react").JSX.Element;
+//#endregion
+//#region src/forms/InviteMembersDialog/block.meta.d.ts
+declare const meta$35: BlockMeta;
+//#endregion
+//#region src/forms/SettingsRow/SettingsRow.d.ts
+export interface SettingsRowControlIds {
+  /** Id of the label element: pass it as `aria-labelledby` to the control. */
+  labelId: string;
+  /** Id of the description element (when there is one): pass it as `aria-describedby`. */
+  descriptionId: string | undefined;
+}
+export interface SettingsRowProps {
+  label?: ReactNode;
+  description?: ReactNode;
+  /**
+   * Custom control. A function receives the label/description ids to wire the control's
+   * accessible name. Without it, a Switch driven by `checked` / `defaultChecked` is rendered.
+   */
+  control?: ReactNode | ((ids: SettingsRowControlIds) => ReactNode);
+  checked?: boolean;
+  defaultChecked?: boolean;
+  onCheckedChange?: (checked: boolean) => void;
+  disabled?: boolean;
+  /** Extra content under the description (status, link). */
+  children?: ReactNode;
+  className?: string;
+}
+/** One setting: label and description on the left, its control (a Switch by default) on the right. */
+export declare function SettingsRow({ label, description, control, checked, defaultChecked, onCheckedChange, disabled, children, className }: SettingsRowProps): import("react").JSX.Element;
+//#endregion
+//#region src/forms/SettingsRow/block.meta.d.ts
+declare const meta$59: BlockMeta;
+//#endregion
+//#region src/forms/ValidationSummary/fixtures.d.ts
+interface ValidationIssue {
+  /** Id of the control to focus (the link target). */
+  fieldId: string;
+  /** Field name shown before the message. */
+  label?: string;
+  message: string;
+}
+declare const validationIssues$1: ValidationIssue[];
+//#endregion
+//#region src/forms/ValidationSummary/ValidationSummary.d.ts
+export interface ValidationSummaryProps {
+  errors?: ValidationIssue[];
+  /** Increment on every submit attempt: the summary takes focus when there are errors. */
+  submitCount?: number;
+  /** Title; defaults to "There are N problems with this form". */
+  title?: ReactNode;
+  className?: string;
+}
+/**
+ * Error summary for long forms: lists every problem with a link that moves focus to the field.
+ * After a failed submit it takes focus, so screen readers announce it.
+ */
+export declare function ValidationSummary({ errors, submitCount, title, className }: ValidationSummaryProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/forms/DialogWizard/DialogWizard.d.ts
+export interface DialogWizardProps extends Omit<WizardLayoutProps, 'mode' | 'steps' | 'current'> {
+  steps?: WizardLayoutProps['steps'];
+  current?: number;
+  /** Step-local validation surface, normally a ValidationSummary with consumer copy. */
+  stepError?: ReactNode;
+  /** Replaces the last step body, normally a DescriptionListCard with consumer copy. */
+  reviewStep?: ReactNode;
+}
+/** Modal variant of create-wizard for a flow over its parent page. State stays consumer-owned. */
+export declare function DialogWizard({ steps, current, size, stepError, reviewStep, children, title, ...props }: DialogWizardProps): import("react").JSX.Element;
+//#endregion
+//#region src/forms/DialogWizard/block.meta.d.ts
+declare const meta$19: BlockMeta;
+//#endregion
+//#region src/forms/DialogWizard/fixtures.d.ts
+/** Example data only; consumers own every label and all step state. */
+export declare const dialogWizardSteps: {
+  label: string;
+}[];
+export declare const dialogWizardCopy: {
+  title: string;
+  description: string;
+  exitLabel: string;
+  cancelLabel: string;
+  backLabel: string;
+  nextLabel: string;
+  finishLabel: string;
+  pendingLabel: string;
+  stepsLabel: string;
+  stepsSummaryLabel: string;
+  exitTitle: string;
+  exitDescription: string;
+  exitConfirmLabel: string;
+  exitCancelLabel: string;
+  stepAnnouncement: ({ position, total, label }: {
+    position: number;
+    total: number;
+    label: unknown;
+  }) => string;
+};
+//#endregion
+//#region src/forms/ValidationSummary/block.meta.d.ts
+declare const meta$74: BlockMeta;
+//#endregion
+//#region src/forms/DangerZone/ConfirmDestructiveDialog.d.ts
+interface ConfirmDestructiveDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  title: ReactNode;
+  description: ReactNode;
+  /** Text that must be typed exactly to enable the confirming button. */
+  confirmText?: string;
+  confirmLabel: string;
+  /** Runs on confirm; a returned promise shows a loading state and keeps the dialog open until it settles. */
+  onConfirm?: () => void | Promise<void>;
+}
+/** Destructive confirmation (alertdialog) that can require typing the resource name first. */
+export declare function ConfirmDestructiveDialog({ open, onOpenChange, title, description, confirmText, confirmLabel, onConfirm }: ConfirmDestructiveDialogProps): import("react").JSX.Element;
+//#endregion
+//#region src/marketing/actions.d.ts
+type IconComponent = ComponentType<{
+  size?: number;
+  'aria-hidden'?: boolean;
+}>;
+/** A call to action: a link when `href` is set, otherwise a button. */
+interface MarketingAction {
+  label: string;
+  href?: string;
+  onClick?: () => void;
+  /** Trailing icon (lucide component). */
+  icon?: IconComponent;
+}
+//#endregion
+//#region src/marketing/Hero/Hero.d.ts
+export interface HeroProps {
+  /** `centered` (copy over the media) or `split` (copy left, media right from `lg`). */
+  variant?: 'centered' | 'split';
+  /** Small label above the title. */
+  eyebrow?: ReactNode;
+  title?: ReactNode;
+  description?: ReactNode;
+  primaryAction?: MarketingAction | null;
+  secondaryAction?: MarketingAction | null;
+  /** Screenshot slot. Defaults to a neutral app-window placeholder; null hides it. */
+  media?: ReactNode;
+  /** Heading level of the title. */
+  headingLevel?: 'h1' | 'h2';
+  className?: string;
+}
+/** Neutral app-window placeholder for the screenshot slot (decorative). */
+export declare function HeroScreenshotPlaceholder({ className }: {
+  className?: string;
+}): import("react").JSX.Element;
+/** Landing hero: eyebrow, title, description, two calls to action and a screenshot slot. */
+export declare function Hero({ variant, eyebrow, title, description, primaryAction, secondaryAction, media, headingLevel: Heading, className }: HeroProps): import("react").JSX.Element;
+//#endregion
+//#region src/marketing/Hero/block.meta.d.ts
+declare const meta$32: BlockMeta;
+//#endregion
+//#region src/marketing/FeatureGrid/FeatureGrid.d.ts
+export interface Feature {
+  icon: LucideIcon;
+  title: string;
+  description: ReactNode;
+}
+export interface FeatureGridProps {
+  features?: Feature[];
+  eyebrow?: ReactNode;
+  title?: ReactNode;
+  description?: ReactNode;
+  /** Columns from `lg` (one column on phones, two on tablets). */
+  columns?: 2 | 3 | 4;
+  /** Heading level of the section title; feature titles use the next level. */
+  headingLevel?: 'h2' | 'h3';
+  className?: string;
+}
+/** Features section: a heading block over a grid of icon + title + description. */
+export declare function FeatureGrid({ features, eyebrow, title, description, columns, headingLevel: Heading, className }: FeatureGridProps): import("react").JSX.Element;
+//#endregion
+//#region src/marketing/FeatureGrid/block.meta.d.ts
+declare const meta$25: BlockMeta;
+//#endregion
+//#region src/marketing/FeatureGrid/fixtures.d.ts
+/** Sample product-agnostic features. */
+export declare const sampleFeatures: Feature[];
+//#endregion
+//#region src/marketing/PricingTable/PricingTable.d.ts
+export type PricingCycle = 'monthly' | 'annual';
+export interface PricingTier {
+  id: string;
+  name: string;
+  description?: string;
+  /** Price per month on monthly billing; null shows "Custom". */
+  priceMonthly: number | null;
+  /** Price per month on annual billing; null shows "Custom". */
+  priceAnnual: number | null;
+  /** Call-to-action label. */
+  cta: string;
+  features: string[];
+  /** Emphasised with a primary border (no colour fill). */
+  highlighted?: boolean;
+  /** Label on the tier, e.g. "Most popular". */
+  badge?: string;
+}
+export interface PricingTableProps {
+  tiers?: PricingTier[];
+  eyebrow?: ReactNode;
+  title?: ReactNode;
+  description?: ReactNode;
+  currency?: string;
+  defaultCycle?: PricingCycle;
+  onCycleChange?: (cycle: PricingCycle) => void;
+  /** Called with the tier and the cycle shown when a CTA is activated. */
+  onSelectTier?: (tier: PricingTier, cycle: PricingCycle) => void;
+  /** Note next to the annual option, e.g. "Save 20%". */
+  annualNote?: string;
+  /** Level of the section title; tier names use the next level (or this one when there is no title). */
+  headingLevel?: 'h2' | 'h3';
+  /** Shows the monthly/annual toggle (default true). */
+  showCycleToggle?: boolean;
+  /** Columns at the widest breakpoint (default: one per tier, up to 4). */
+  columns?: 1 | 2 | 3 | 4;
+  /** Names the tier list / radio group when `title` is null (the block then renders no landmark), e.g. inside a wizard step. */
+  'aria-label'?: string;
+  /** Id of an external heading that names the section when `title` is null. */
+  'aria-labelledby'?: string;
+  /**
+   * Id of the tier the account is on: its card gets a "Current plan" badge and
+   * `aria-current`, and its CTA becomes a disabled "Current plan" button.
+   */
+  currentTierId?: string;
+  /** Label of the current tier's badge and disabled CTA. */
+  currentPlanLabel?: string;
+  /**
+   * Turns the tiers into a single-choice radio group (role radiogroup/radio, arrow keys,
+   * selected card with a primary border and a check). CTAs are not rendered in this mode.
+   */
+  selectable?: boolean;
+  /** Selected tier id (controlled, `selectable` only). */
+  value?: string;
+  /** Initially selected tier id (uncontrolled, `selectable` only). */
+  defaultValue?: string;
+  /** Called with the newly selected tier id (`selectable` only). */
+  onValueChange?: (value: string) => void;
+  className?: string;
+}
+/** Pricing section: tiers with a monthly/annual toggle, a highlighted tier and a feature checklist. */
+export declare function PricingTable({ tiers, eyebrow, title, description, currency, defaultCycle, onCycleChange, onSelectTier, annualNote, headingLevel: Heading, showCycleToggle, columns, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, currentTierId, currentPlanLabel, selectable, value, defaultValue, onValueChange, className }: PricingTableProps): import("react").JSX.Element;
+//#endregion
+//#region src/marketing/PricingTable/block.meta.d.ts
+declare const meta$51: BlockMeta;
+//#endregion
+//#region src/marketing/PricingTable/fixtures.d.ts
+/** Sample three-tier pricing. Prices are per month; annual is per month billed yearly. */
+export declare const samplePricingTiers: PricingTier[];
+//#endregion
+//#region src/marketing/Faq/Faq.d.ts
+export interface FaqItem {
+  id: string;
+  question: string;
+  answer: ReactNode;
+}
+export interface FaqProps {
+  items?: FaqItem[];
+  title?: ReactNode;
+  description?: ReactNode;
+  /** `stacked` (heading over the list) or `split` (heading left from `lg`). */
+  layout?: 'stacked' | 'split';
+  /** Ids of the items open on mount. */
+  defaultOpen?: string[];
+  /** Allow several items open at once. */
+  multiple?: boolean;
+  headingLevel?: 'h2' | 'h3';
+  className?: string;
+}
+/** Frequently asked questions in an accordion, with a heading block. */
+export declare function Faq({ items, title, description, layout, defaultOpen, multiple, headingLevel: Heading, className }: FaqProps): import("react").JSX.Element;
+//#endregion
+//#region src/marketing/Faq/block.meta.d.ts
+declare const meta$24: BlockMeta;
+//#endregion
+//#region src/marketing/Faq/fixtures.d.ts
+/** Sample product-agnostic questions. */
+export declare const sampleFaqs: FaqItem[];
+//#endregion
+//#region src/marketing/ComparisonTable/ComparisonTable.d.ts
+/** A plan or option: one column of the comparison. */
+export interface ComparisonPlan {
+  id: string;
+  name: string;
+  /** Headline price or figure under the name ("$49", "Custom"). */
+  price?: ReactNode;
+  /** Small text after the price ("per month"). */
+  priceNote?: ReactNode;
+  /** Call to action under the price. */
+  cta?: MarketingAction;
+}
+/** A plain value, or a value with a short note under it ("Add-on"). */
+export type ComparisonValue = boolean | string | number | null | undefined | {
+  value: boolean | string | number | null;
+  note?: string;
+};
+export interface ComparisonFeature {
+  id: string;
+  label: string;
+  /** Muted text under the label. */
+  description?: string;
+  /** Value per plan id. Missing / null values render like `false` (a dash, "Not included"). */
+  values: Readonly<Record<string, ComparisonValue>>;
+}
+export interface ComparisonSection {
+  id: string;
+  title: string;
+  features: ComparisonFeature[];
+}
+export interface ComparisonTableProps {
+  plans?: ComparisonPlan[];
+  sections?: ComparisonSection[];
+  /** Plan column marked as recommended: badge text, a primary top rule and a tinted column. */
+  highlightedPlanId?: string;
+  /** Text of the recommended badge (default "Recommended"). */
+  highlightLabel?: string;
+  eyebrow?: ReactNode;
+  title?: ReactNode;
+  description?: ReactNode;
+  /** Level of the section title (default h2). */
+  headingLevel?: 'h2' | 'h3';
+  /** Table name (screen-reader caption). Default: the title when it is a string, else "Plan comparison". */
+  caption?: string;
+  /** Header of the feature column (screen-reader only unless `showFeatureHeader`). */
+  featureHeader?: string;
+  showFeatureHeader?: boolean;
+  /** Screen-reader text of `true` (default "Included"). */
+  includedLabel?: string;
+  /** Screen-reader text of `false` / missing values (default "Not included"). */
+  notIncludedLabel?: string;
+  /** Formats numeric values (default: en-US grouping). */
+  formatNumber?: (value: number, feature: ComparisonFeature) => string;
+  className?: string;
+}
+/**
+ * Feature comparison of plans or options: columns are plans, rows are features grouped by section.
+ * Booleans render as a check or a dash with screen-reader text; text and numbers render as is. The
+ * table scrolls sideways on narrow screens with the feature column pinned.
+ */
+export declare function ComparisonTable({ plans, sections, highlightedPlanId, highlightLabel, eyebrow, title, description, headingLevel: Heading, caption, featureHeader, showFeatureHeader, includedLabel, notIncludedLabel, formatNumber, className }: ComparisonTableProps): import("react").JSX.Element;
+//#endregion
+//#region src/marketing/ComparisonTable/block.meta.d.ts
+declare const meta$10: BlockMeta;
+//#endregion
+//#region src/marketing/ComparisonTable/fixtures.d.ts
+/** Three sample plans (generic, product-agnostic). */
+export declare const sampleComparisonPlans: ComparisonPlan[];
+/** Features grouped by section; values are keyed by plan id. */
+export declare const sampleComparisonSections: ComparisonSection[];
+//#endregion
+//#region src/page-chrome/types.d.ts
+/** A header/toolbar action rendered as a kit Button (or a MoreMenu item when folded). */
+interface PageChromeAction {
+  /** Stable key; defaults to `label`. */
+  id?: string;
+  label: string;
+  icon?: LucideIcon;
+  /** Button style; when omitted the block picks one (primary for the main action, secondary otherwise). */
+  variant?: ButtonProps['variant'];
+  disabled?: boolean;
+  onClick?: () => void;
+}
+//#endregion
+//#region src/page-chrome/PageHeader/PageHeader.d.ts
+export interface PageHeaderMetaItem {
+  /** Term (screen-reader only when an icon is shown). */
+  label: string;
+  value: ReactNode;
+  icon?: LucideIcon;
+  /** Render the value in Geist Mono (ids, regions, versions). */
+  mono?: boolean;
+}
+export interface PageHeaderTab {
+  value: string;
+  label: string;
+  count?: number;
+}
+export interface PageHeaderProps {
+  /** Root element. Use 'div' where the layout already has a banner (e.g. StackedLayout's pageHeader slot). */
+  as?: 'header' | 'div';
+  /** Location trail above the title; `null` hides it. */
+  breadcrumbs?: BreadcrumbItem[] | null;
+  title?: ReactNode;
+  /** h1 focus target: adds tabIndex=-1 for titleRef.current.focus(), outside the Tab order. */
+  titleRef?: Ref<HTMLHeadingElement>;
+  description?: ReactNode;
+  /** StatusTag key next to the title (e.g. `active`, `paused`, `failed`). */
+  status?: string;
+  statuses?: Record<string, StatusDefinition>;
+  /** Meta row under the description. */
+  meta?: PageHeaderMetaItem[];
+  /**
+   * Header actions in visual order. The primary one (first with `variant: 'primary'`, else the
+   * last) stays visible on small screens; the rest fold into a MoreMenu.
+   */
+  actions?: PageChromeAction[];
+  /** Resource-level navigation tabs under the header; `null` hides them. */
+  tabs?: PageHeaderTab[] | null;
+  tab?: string;
+  defaultTab?: string;
+  onTabChange?: (value: string) => void;
+  className?: string;
+}
+/** Screen header: breadcrumb, title + status, description, meta row, actions and optional tabs. */
+export declare function PageHeader({ as: Root, breadcrumbs, title, titleRef, description, status, statuses, meta, actions, tabs, tab, defaultTab, onTabChange, className }: PageHeaderProps): import("react").JSX.Element;
+//#endregion
+//#region src/page-chrome/PageHeader/fixtures.d.ts
+export declare const pageHeaderBreadcrumbs: BreadcrumbItem[];
+export declare const pageHeaderActions: PageChromeAction[];
+export declare const pageHeaderTabs: PageHeaderTab[];
+//#endregion
+//#region src/page-chrome/PageHeader/block.meta.d.ts
+declare const meta$44: BlockMeta;
+//#endregion
+//#region src/page-chrome/SectionHeader/SectionHeader.d.ts
+export interface SectionHeaderProps {
+  title?: ReactNode;
+  description?: ReactNode;
+  /** Count pill after the title (members, items…). */
+  count?: number;
+  /** Small actions on the right; the last one without a variant is secondary. */
+  actions?: PageChromeAction[];
+  /** Heading level that fits the page outline. */
+  as?: 'h2' | 'h3';
+  /** Hairline under the header. */
+  bordered?: boolean;
+  /** Id for the heading, so a section can use `aria-labelledby`. */
+  headingId?: string;
+  className?: string;
+}
+/** Heading for a section inside a page: title (+ count), description and small actions. */
+export declare function SectionHeader({ title, description, count, actions, as: Heading, bordered, headingId, className }: SectionHeaderProps): import("react").JSX.Element;
+//#endregion
+//#region src/page-chrome/SectionHeader/block.meta.d.ts
+declare const meta$57: BlockMeta;
+//#endregion
+//#region src/page-chrome/PageToolbar/PageToolbar.d.ts
+export interface PageToolbarView {
+  value: string;
+  /** Accessible name of the icon toggle. */
+  label: string;
+  icon: LucideIcon;
+}
+export interface PageToolbarProps {
+  /** Controlled search text. */
+  search?: string;
+  defaultSearch?: string;
+  onSearchChange?: (value: string) => void;
+  searchLabel?: string;
+  searchPlaceholder?: string;
+  /**
+   * Filter controls. Use ToolbarButton (optionally with `render` for a Menu/Popover trigger) so they
+   * join the toolbar's arrow-key navigation. Omitted: a single "Filters" button; `null` hides it.
+   */
+  filters?: ReactNode;
+  /** View modes for the segmented toggle; `null` or an empty list hides it. */
+  views?: PageToolbarView[] | null;
+  view?: string;
+  defaultView?: string;
+  onViewChange?: (value: string) => void;
+  /** Main action at the end of the bar; `null` hides it. */
+  primaryAction?: PageChromeAction | null;
+  'aria-label'?: string;
+  className?: string;
+}
+/** List/table toolbar: search, filters, view toggle and the primary action, with one Tab stop. */
+export declare function PageToolbar({ search, defaultSearch, onSearchChange, searchLabel: searchLabelProp, searchPlaceholder, filters, views, view, defaultView, onViewChange, primaryAction, 'aria-label': ariaLabelProp, className }: PageToolbarProps): import("react").JSX.Element;
+//#endregion
+//#region src/page-chrome/PageToolbar/fixtures.d.ts
+export declare const pageToolbarViews: PageToolbarView[];
+//#endregion
+//#region src/page-chrome/PageToolbar/block.meta.d.ts
+declare const meta$45: BlockMeta;
+//#endregion
+//#region src/page-chrome/StickyActionBar/StickyActionBar.d.ts
+export interface StickyActionBarProps {
+  /** Whether the form has unsaved changes; Save and Discard are disabled while clean. */
+  dirty?: boolean;
+  /** Shows a spinner on Save and blocks both buttons. */
+  saving?: boolean;
+  onSave?: () => void;
+  onCancel?: () => void;
+  /** Text while dirty. */
+  dirtyMessage?: ReactNode;
+  /** Text while clean. */
+  cleanMessage?: ReactNode;
+  saveLabel?: string;
+  cancelLabel?: string;
+  /** Render nothing while clean (the bar slides in only when there is something to save). */
+  hideWhenClean?: boolean;
+  /** Accessible name of the region. */
+  'aria-label'?: string;
+  className?: string;
+}
+/** Bottom bar for long forms: unsaved-changes status plus Discard / Save, sticky to the viewport. */
+export declare function StickyActionBar({ dirty, saving, onSave, onCancel, dirtyMessage: dirtyMessageProp, cleanMessage: cleanMessageProp, saveLabel: saveLabelProp, cancelLabel: cancelLabelProp, hideWhenClean, 'aria-label': ariaLabelProp, className }: StickyActionBarProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/page-chrome/StickyActionBar/block.meta.d.ts
+declare const meta$67: BlockMeta;
+//#endregion
+//#region src/page-chrome/BulkActionBar/BulkActionBar.d.ts
+export interface BulkActionBarProps {
+  /** Number of selected rows; the bar renders nothing at 0. */
+  selectedCount?: number;
+  /** Total rows, shown as "3 of 24 selected". */
+  totalCount?: number;
+  /** Noun for the count, singular and plural. */
+  noun?: [singular: string, plural: string];
+  actions?: PageChromeAction[];
+  onClear?: () => void;
+  clearLabel?: string;
+  className?: string;
+}
+/** Contextual toolbar shown while rows are selected: count, bulk actions and clear selection. */
+export declare function BulkActionBar({ selectedCount, totalCount, noun: nounProp, actions, onClear, clearLabel: clearLabelProp, className }: BulkActionBarProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/page-chrome/BulkActionBar/block.meta.d.ts
+declare const meta$6: BlockMeta;
+//#endregion
+//#region src/scheduling/shared/events.d.ts
+/** A scheduled item on a calendar. */
+interface ScheduleEvent {
+  id: string;
+  title: string;
+  start: Date;
+  end: Date;
+  /** Key into the `kinds` map (job, deploy, review, backup, maintenance…). */
+  kind?: string;
+  /** Region, room or target, shown after the time. */
+  location?: string;
+}
+type EventTone = 'primary' | 'violet' | 'cyan' | 'amber' | 'neutral';
+interface EventKind {
+  label: string;
+  icon: LucideIcon;
+  tone: EventTone;
+}
+/** Default kinds: brand green for jobs, categorical accents for the rest (never severity). */
+export declare const defaultEventKinds: Record<string, EventKind>;
+//#endregion
+//#region src/scheduling/MonthCalendar/MonthCalendar.d.ts
+export interface MonthCalendarProps {
+  events?: ScheduleEvent[];
+  /** The app's "today" (the block never reads the clock). */
+  today?: Date;
+  /** Month shown first (uncontrolled). Defaults to the month of `today`. */
+  defaultMonth?: Date;
+  onMonthChange?: (month: Date) => void;
+  /** Initially selected day (uncontrolled). */
+  defaultSelected?: Date;
+  /** Called when a day is activated (click, Enter or Space). */
+  onSelectDate?: (date: Date, events: ScheduleEvent[]) => void;
+  /** Event kinds (label, icon, tone) by `event.kind`. */
+  kinds?: Record<string, EventKind>;
+  /** Event lines per day before "+N more". */
+  maxEventsPerDay?: number;
+  /** Caller actions in the header (e.g. a "Schedule" button). */
+  actions?: ReactNode;
+  className?: string;
+}
+/**
+ * Month view of scheduled work: a Monday-first grid with up to N events per day.
+ * Keyboard: arrows move by day/week, Home/End to the week edges, PageUp/PageDown by month,
+ * Enter/Space selects.
+ */
+export declare function MonthCalendar({ events, today, defaultMonth, onMonthChange, defaultSelected, onSelectDate, kinds, maxEventsPerDay, actions, className }: MonthCalendarProps): import("react").JSX.Element;
+//#endregion
+//#region src/scheduling/MonthCalendar/block.meta.d.ts
+declare const meta$42: BlockMeta;
+//#endregion
+//#region src/scheduling/WeekCalendar/WeekCalendar.d.ts
+export interface WeekCalendarProps {
+  events?: ScheduleEvent[];
+  /** The app's "today" (the block never reads the clock). */
+  today?: Date;
+  /** Current time for the "now" line, shown when it falls in the visible week. Defaults to `today`. */
+  now?: Date;
+  /** A date inside the week shown first (uncontrolled). Defaults to `today`. */
+  defaultWeek?: Date;
+  /** Called with the Monday of the newly shown week. */
+  onWeekChange?: (weekStart: Date) => void;
+  /** Makes events buttons. */
+  onEventClick?: (event: ScheduleEvent) => void;
+  kinds?: Record<string, EventKind>;
+  /** Hour the grid scrolls to on mount. */
+  scrollToHour?: number;
+  /** Pixels per hour. */
+  hourHeight?: number;
+  /** Max height of the scrolling time grid in px. */
+  height?: number;
+  actions?: ReactNode;
+  className?: string;
+}
+/** Week view: seven day columns over a scrolling 24-hour time grid, with a "now" line. */
+export declare function WeekCalendar({ events, today, now, defaultWeek, onWeekChange, onEventClick, kinds, scrollToHour, hourHeight, height, actions, className }: WeekCalendarProps): import("react").JSX.Element;
+//#endregion
+//#region src/scheduling/WeekCalendar/block.meta.d.ts
+declare const meta$75: BlockMeta;
+//#endregion
+//#region src/scheduling/AgendaList/AgendaList.d.ts
+export interface AgendaListProps {
+  events?: ScheduleEvent[];
+  /** The app's "today": labels the Today/Tomorrow groups. */
+  today?: Date;
+  /** Only events on or after this day. Defaults to `today`; pass null for all. */
+  from?: Date | null;
+  /** Number of days shown from `from`. Default 7; null for no limit. */
+  days?: number | null;
+  /** Makes each row a button. */
+  onEventClick?: (event: ScheduleEvent) => void;
+  kinds?: Record<string, EventKind>;
+  title?: string;
+  /** Max height of the scrolling list in px. */
+  maxHeight?: number;
+  emptyTitle?: string;
+  emptyDescription?: string;
+  /** Heading level of the title, to fit the page outline (default h3); inner headings use the next level. */
+  titleAs?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** Upcoming scheduled work grouped by day, each row with a kind tile, time range and location. */
+export declare function AgendaList({ events, today, from, days, onEventClick, kinds, title: titleProp, maxHeight, emptyTitle: emptyTitleProp, emptyDescription: emptyDescriptionProp, titleAs: TitleTag, className }: AgendaListProps): import("react").JSX.Element;
+//#endregion
+//#region src/scheduling/AgendaList/block.meta.d.ts
+declare const meta$2: BlockMeta;
+//#endregion
+//#region src/scheduling/TimeSlotPicker/TimeSlotPicker.d.ts
+export interface TimeSlot {
+  /** Submitted value, e.g. "09:30". */
+  value: string;
+  /** Visible label. Defaults to `value`. */
+  label?: string;
+  /** Taken slots render struck through and disabled. Default true. */
+  available?: boolean;
+}
+export interface TimeSlotPickerProps {
+  slots?: TimeSlot[];
+  /** Controlled value. */
+  value?: string | null;
+  /** Uncontrolled initial value. */
+  defaultValue?: string | null;
+  onValueChange?: (value: string) => void;
+  /** Group label (the fieldset legend). */
+  legend?: string;
+  /** Secondary line under the legend, e.g. the chosen date. */
+  description?: string;
+  /** Form field name. */
+  name?: string;
+  /** Slot columns from the `sm` breakpoint (two on small screens). */
+  columns?: 2 | 3 | 4 | 6;
+  /** Max height of the scrolling slot list in px. */
+  maxHeight?: number;
+  className?: string;
+}
+/**
+ * Pick one time slot. Native radio semantics: Tab enters the group, arrow keys move and select,
+ * taken slots are disabled.
+ */
+export declare function TimeSlotPicker({ slots, value, defaultValue, onValueChange, legend: legendProp, description, name, columns, maxHeight, className }: TimeSlotPickerProps): import("react").JSX.Element;
+//#endregion
+//#region src/scheduling/TimeSlotPicker/block.meta.d.ts
+declare const meta$70: BlockMeta;
+//#endregion
+//#region src/scheduling/TimeSlotPicker/fixtures.d.ts
+/** Half-hour slots from 09:00 to 21:00 with a few already taken. */
+export declare const sampleTimeSlots: TimeSlot[];
+//#endregion
+//#region src/scheduling/shared/fixtures.d.ts
+/** The sample calendar's "today" (Wed 15 Apr 2026, 10:20). Pass your own `today` in apps. */
+declare const sampleToday: Date;
+/** Sample scheduled work for April 2026 (jobs, deploys, reviews, backups, maintenance). */
+declare const sampleEvents: ScheduleEvent[];
+//#endregion
+//#region src/shell/AppSidebar/fixtures.d.ts
+export declare const appSidebarNavGroups: NavGroup[];
+export declare const appSidebarWorkspaces: Workspace[];
+export interface AppSidebarUsage {
+  label: string;
+  value: number;
+  max: number;
+  /** Formatted value, e.g. "8.2k / 10k requests". */
+  valueLabel?: string;
+}
+export declare const appSidebarUsage: AppSidebarUsage;
+export declare const appSidebarUser: UserMenuUser;
+//#endregion
+//#region src/shell/AppSidebar/AppSidebar.d.ts
+export interface AppSidebarHeaderProps {
+  /** Icon rail: shows only the brand mark. */
+  collapsed?: boolean;
+  /** Workspaces for the switcher; `null` shows the logo + wordmark instead. */
+  workspaces?: Workspace[] | null;
+  currentWorkspaceId?: string;
+  onWorkspaceChange?: (workspace: Workspace) => void;
+  onCreateWorkspace?: () => void;
+  className?: string;
+}
+/** Sidebar top: workspace switcher (or the brand logo), the brand mark alone in the icon rail. */
+export declare function AppSidebarHeader({ collapsed, workspaces, currentWorkspaceId, onWorkspaceChange, onCreateWorkspace, className }: AppSidebarHeaderProps): import("react").JSX.Element;
+export interface AppSidebarNavProps {
+  groups?: NavGroup[];
+  currentHref?: string;
+  collapsed?: boolean;
+  /** Accessible name of the nav landmark. */
+  label?: string;
+  onNavigate?: (item: NavItem) => void;
+  className?: string;
+}
+/** Sidebar body: the NavList (icon rail with tooltips when collapsed). */
+export declare function AppSidebarNav({ groups, currentHref, collapsed, label, onNavigate, className }: AppSidebarNavProps): import("react").JSX.Element;
+export interface AppSidebarFooterProps {
+  collapsed?: boolean;
+  /** Plan usage meter; `null` hides it. */
+  usage?: AppSidebarUsage | null;
+  /** Help link; `null` hides it. */
+  helpHref?: string | null;
+  helpLabel?: string;
+  /** Signed-in user; `null` hides the user menu. */
+  user?: UserMenuUser | null;
+  userMenuItems?: UserMenuEntry[];
+  onSignOut?: () => void;
+  className?: string;
+}
+/** Sidebar bottom: usage meter, help link and the user menu (avatar only in the icon rail). */
+export declare function AppSidebarFooter({ collapsed, usage, helpHref, helpLabel, user, userMenuItems, onSignOut, className }: AppSidebarFooterProps): import("react").JSX.Element;
+export interface AppSidebarProps extends AppSidebarHeaderProps, Omit<AppSidebarNavProps, 'className' | 'groups' | 'label'>, Omit<AppSidebarFooterProps, 'className'> {
+  navGroups?: NavGroup[];
+  navLabel?: string;
+}
+/**
+ * Complete application sidebar column (chrome surface): workspace switcher header, NavList body
+ * and a footer with usage, help and the user menu. Inside SidebarLayout, use the parts
+ * (AppSidebarHeader / AppSidebarNav / AppSidebarFooter) in its three slots.
+ */
+export declare function AppSidebar({ collapsed, workspaces, currentWorkspaceId, onWorkspaceChange, onCreateWorkspace, navGroups, navLabel, currentHref, onNavigate, usage, helpHref, helpLabel, user, userMenuItems, onSignOut, className }: AppSidebarProps): import("react").JSX.Element;
+//#endregion
+//#region src/shell/AppSidebar/block.meta.d.ts
+declare const meta$3: BlockMeta;
+//#endregion
+//#region src/shell/EnvironmentBadge/EnvironmentBadge.d.ts
+export type EnvironmentTone = 'primary' | 'warning' | 'info' | 'neutral' | 'destructive';
+/** Default tone per environment name; anything else is neutral. */
+export declare const environmentTones: Record<string, EnvironmentTone>;
+export interface EnvironmentBadgeProps {
+  /** Environment name, e.g. `production`, `staging`, `preview`. */
+  environment?: string;
+  /** Region or cluster shown after the environment, e.g. `eu-west`; `null` hides it. */
+  region?: string | null;
+  /** Overrides the tone looked up from `environmentTones`. */
+  tone?: EnvironmentTone;
+  /** Prefix read by screen readers only. */
+  srLabel?: string;
+  className?: string;
+}
+/** Environment + region chip for the topbar or a page header: "production · eu-west". */
+export declare function EnvironmentBadge({ environment, region, tone, srLabel, className }: EnvironmentBadgeProps): import("react").JSX.Element;
+//#endregion
+//#region src/shell/AppTopbar/AppTopbar.d.ts
+export interface AppTopbarProps {
+  /** Location trail; `null` hides it. */
+  breadcrumbs?: BreadcrumbItem[] | null;
+  /** Replaces the breadcrumb (custom title, tabs…). */
+  breadcrumb?: ReactNode;
+  /** Environment chip after the breadcrumb; `null` hides it. */
+  environment?: EnvironmentBadgeProps | null;
+  /** Search control; defaults to GlobalSearch (⌘K). `null` hides it. */
+  search?: ReactNode;
+  /** Notifications; `null` hides the bell. */
+  notifications?: NotificationItem[] | null;
+  onNotificationSelect?: (notification: NotificationItem) => void;
+  onMarkAllRead?: () => void;
+  /** Theme control: a one-button cycle, the segmented switcher, or none. */
+  theme?: 'cycle' | 'segmented' | null;
+  /** Signed-in user; `null` hides the user menu. */
+  user?: UserMenuUser | null;
+  userMenuItems?: UserMenuEntry[];
+  onSignOut?: () => void;
+  className?: string;
+}
+/**
+ * Topbar contents: breadcrumb (+ environment chip) on the left; ⌘K search, notifications, theme
+ * and user menu on the right. Renders no <header>: put it in SidebarLayout's `topbar` slot or a
+ * header of your own.
+ */
+export declare function AppTopbar({ breadcrumbs, breadcrumb, environment, search, notifications, onNotificationSelect, onMarkAllRead, theme, user, userMenuItems, onSignOut, className }: AppTopbarProps): import("react").JSX.Element;
+//#endregion
+//#region src/shell/AppTopbar/fixtures.d.ts
+export declare const appTopbarBreadcrumbs: BreadcrumbItem[];
+export declare const appTopbarNotifications: NotificationItem[];
+//#endregion
+//#region src/shell/AppTopbar/block.meta.d.ts
+declare const meta$4: BlockMeta;
+//#endregion
+//#region src/shell/EnvironmentBadge/block.meta.d.ts
+declare const meta$21: BlockMeta;
+//#endregion
+//#region src/shell/GlobalSearch/GlobalSearch.d.ts
+export type GlobalSearchGroup = 'pages' | 'records' | 'actions' | 'recent';
+export interface GlobalSearchProps {
+  pages?: CommandItem[];
+  records?: CommandItem[];
+  actions?: CommandItem[];
+  /** Shown first while the query is empty. */
+  recent?: CommandItem[];
+  /** Called with every chosen item and the group it came from (after the item's own onSelect). */
+  onSelect?: (item: CommandItem, group: GlobalSearchGroup) => void;
+  /** Group headings. */
+  labels?: Partial<Record<GlobalSearchGroup, string>>;
+  /** Registers ⌘K / Ctrl+K. */
+  shortcut?: boolean;
+  open?: boolean;
+  defaultOpen?: boolean;
+  onOpenChange?: (open: boolean) => void;
+  placeholder?: string;
+  /** Text of the trigger button. */
+  triggerLabel?: string;
+  /** Classes for the trigger (e.g. `hidden md:inline-flex`). */
+  className?: string;
+}
+/** ⌘K search: a CommandPalette pre-wired with recent items and Pages / Records / Actions groups. */
+export declare function GlobalSearch({ pages, records, actions, recent, onSelect, labels, shortcut, open, defaultOpen, onOpenChange, placeholder: placeholderProp, triggerLabel: triggerLabelProp, className }: GlobalSearchProps): import("react").JSX.Element;
+//#endregion
+//#region src/shell/GlobalSearch/fixtures.d.ts
+export declare const globalSearchPages: CommandItem[];
+export declare const globalSearchRecords: CommandItem[];
+export declare const globalSearchActions: CommandItem[];
+export declare const globalSearchRecent: CommandItem[];
+//#endregion
+//#region src/shell/GlobalSearch/block.meta.d.ts
+declare const meta$31: BlockMeta;
+//#endregion
+//#region src/tables/DataTable/data-table-utils.d.ts
+export type SortDirectionValue = 'ascending' | 'descending';
+export type CellValue = string | number | boolean | Date | null | undefined;
+export type DataTableColumnVariant = 'default' | 'mono' | 'muted' | 'numeric';
+/** Body-cell classes of each column variant. */
+export declare const COLUMN_VARIANT_CLASSES: Record<DataTableColumnVariant, string>;
+/** Effective alignment of a column (numeric columns default to right). */
+export declare function columnAlign<T>(column: DataTableColumn<T>): DataTableColumn<T>['align'];
+/** One typed column of a DataTable. */
+export interface DataTableColumn<T> {
+  /** Stable key (sorting, visibility). */
+  id: string;
+  /** Header text; also the column's name in the visibility menu. */
+  header: string;
+  /** Raw value: used to sort, and rendered when `cell` is absent. */
+  accessor?: (row: T) => CellValue;
+  /** Custom cell rendering. */
+  cell?: (row: T) => ReactNode;
+  sortable?: boolean;
+  align?: 'left' | 'right' | 'center';
+  /** Can be hidden from the column menu (default true). */
+  hideable?: boolean;
+  /** Hidden until turned on in the column menu. */
+  defaultHidden?: boolean;
+  /**
+   * Presentational preset for the body cells: `mono` (monospace ids, regions), `muted`
+   * (secondary text), `numeric` (monospace tabular figures, right-aligned unless `align` is set).
+   */
+  variant?: DataTableColumnVariant;
+  /** Classes for the body cells (merged after the variant's). */
+  className?: string;
+  /** Classes for the header cell (e.g. a width). */
+  headClassName?: string;
+  /** Initial width in px (resizable or pinned tables; default 160). */
+  width?: number;
+  /** Smallest width a resize can reach (default 60). */
+  minWidth?: number;
+  /** Largest width a resize can reach (default 640). */
+  maxWidth?: number;
+  /** Shows a resize handle when the table is `resizable` (default true). */
+  resizable?: boolean;
+  /** Can be pinned from the column menu (default true). */
+  pinnable?: boolean;
+  /** Inline editing: Enter or F2 on the cell edits it (needs `onCellEdit` on the table). */
+  editable?: boolean | ((row: T) => boolean);
+  /** Editor of an editable cell (default a text input). */
+  editor?: DataTableCellEditor;
+  /** Value the editor starts from (default the accessor's value). */
+  editValue?: (row: T) => string | number | null | undefined;
+}
+/** Editor of an editable column. */
+export type DataTableCellEditor = {
+  type: 'text';
+  placeholder?: string;
+} | {
+  type: 'number';
+  min?: number;
+  max?: number;
+  step?: number;
+} | {
+  type: 'select';
+  options: ReadonlyArray<{
+    value: string;
+    label: string;
+  }>;
+};
+export interface SortState {
+  columnId: string;
+  direction: SortDirectionValue;
+}
+/** Compares two cell values: nulls last, numbers and dates numerically, strings with localeCompare (numeric). */
+export declare function compareValues(a: CellValue, b: CellValue): number;
+/** Client-side sort (stable). Returns the input order when there is no sort or the column has no accessor. */
+export declare function sortRows<T>(rows: readonly T[], columns: ReadonlyArray<DataTableColumn<T>>, sort: SortState | null): T[];
+/** Number of pages for a row count (at least 1). */
+export declare function pageCountOf(total: number, pageSize: number): number;
+/** Client-side pagination: the rows of a 1-based page (clamped to the valid range). */
+export declare function paginate<T>(rows: readonly T[], page: number, pageSize: number): T[];
+/** Header checkbox state for the rows on screen. */
+export declare function selectionState(visibleIds: readonly string[], selected: ReadonlySet<string>): {
+  checked: boolean;
+  indeterminate: boolean;
+};
+/** Selects all of `ids` when not all are selected; otherwise clears them. Other selections are kept. */
+export declare function toggleAll(ids: readonly string[], selected: ReadonlySet<string>): Set<string>;
+export declare function toggleOne(id: string, selected: ReadonlySet<string>): Set<string>;
+/** Default cell text for a raw value. */
+export declare function formatCell(value: CellValue): ReactNode;
+/** Groups rows by a field key or by a function returning the group key. */
+export type DataTableGroupBy<T> = Extract<keyof T, string> | ((row: T) => string | number | null | undefined);
+/** One group of rows, in display order. */
+export interface DataTableGroup<T> {
+  /** Group key (`''` for rows without a value). */
+  key: string;
+  rows: T[];
+}
+/** Group key of a row (`''` when the value is null or undefined). */
+export declare function groupKeyOf<T>(row: T, groupBy: DataTableGroupBy<T>): string;
+/**
+ * Splits rows into groups, keeping the row order inside each group. Groups follow `order` (the
+ * keys' first appearance in it, e.g. the unsorted input) and then any key not seen there.
+ */
+export declare function groupRows<T>(rows: readonly T[], groupBy: DataTableGroupBy<T>, order?: readonly T[]): DataTableGroup<T>[];
+//#endregion
+//#region src/tables/DataTable/column-sizing.d.ts
+/** Column widths in px by column id. */
+type ColumnWidths = Readonly<Record<string, number>>;
+/** Columns pinned to the start (left in LTR) and end edges, in display order. */
+interface PinnedColumns {
+  left?: readonly string[];
+  right?: readonly string[];
+}
+type PinSide = 'left' | 'right';
+export declare const DEFAULT_COLUMN_WIDTH = 160;
+export declare const MIN_COLUMN_WIDTH = 60;
+export declare const MAX_COLUMN_WIDTH = 640;
+/** Clamps a width to the column's limits (rounded to whole px). */
+export declare function clampColumnWidth<T>(column: DataTableColumn<T>, width: number): number;
+/** Effective width of a column: the widths map, then `column.width`, then the default. */
+export declare function columnWidthOf<T>(column: DataTableColumn<T>, widths: ColumnWidths): number;
+/** Pins a column to a side (appended to that side) or unpins it (`null`). */
+export declare function setColumnPin(pinned: PinnedColumns, id: string, side: PinSide | null): PinnedColumns;
+/** Display order: start-pinned columns (pin order), unpinned columns (column order), end-pinned columns. */
+export declare function orderColumns<T>(columns: ReadonlyArray<DataTableColumn<T>>, pinned: PinnedColumns): Array<DataTableColumn<T>>;
+//#endregion
+//#region src/tables/PaginationFooter/PaginationFooter.d.ts
+export interface PaginationFooterLabels {
+  rowsPerPage: string;
+  rowsPerPageLabel: string;
+  rangeSummary: (from: number, to: number, total: number) => string;
+  paginationNav: (noun: string) => string;
+  previous: string;
+  next: string;
+  page: (page: number) => string;
+}
+export interface PaginationFooterProps {
+  /** Per-key overrides; omitted keys retain the existing provider translations and defaults. */
+  labels?: Partial<PaginationFooterLabels>;
+  /** Total number of rows. */
+  total?: number;
+  /** Current page, 1-based (controlled). */
+  page?: number;
+  defaultPage?: number;
+  onPageChange?: (page: number) => void;
+  /** Rows per page (controlled). */
+  pageSize?: number;
+  defaultPageSize?: number;
+  onPageSizeChange?: (pageSize: number) => void;
+  pageSizeOptions?: readonly number[];
+  /** What the rows are, for the accessible names ("Deployments"). */
+  noun?: string;
+  locale?: string;
+  className?: string;
+}
+/** Table footer: rows-per-page Select, a "1–10 of 97" summary and numbered Pagination. Stacks on small screens. */
+export declare function PaginationFooter({ total, page: pageProp, defaultPage, onPageChange, pageSize: sizeProp, defaultPageSize, onPageSizeChange, pageSizeOptions, noun: nounProp, locale: localeProp, className, labels }: PaginationFooterProps): import("react").JSX.Element;
+//#endregion
+//#region src/tables/DataTable/labels.d.ts
+/** Per-instance table chrome, including the composed PaginationFooter. Caller data stays caller-owned. */
+interface DataTableLabels extends PaginationFooterLabels {
+  /** Non-virtual table overflow region; virtualized regions keep the caller caption. */
+  scrollRegion: string;
+  selectionCount: (count: number) => string;
+  columns: string;
+  visibleColumns: string;
+  pinColumns: string;
+  pinnedLeft: string;
+  pinnedRight: string;
+  pinLeft: string;
+  pinRight: string;
+  unpinned: string;
+  density: string;
+  comfortable: string;
+  compact: string;
+  resizeColumn: (label: string) => string;
+  columnWidth: (width: number) => string;
+  defaultView: string;
+  defaultViewOption: string;
+  modified: string;
+  views: string;
+  saveChanges: string;
+  saveAs: string;
+  renameView: string;
+  deleteView: string;
+  resetChanges: string;
+  saveViewTitle: string;
+  renameViewTitle: string;
+  viewName: string;
+  cancel: string;
+  saveView: string;
+  rename: string;
+  closeDialog: string;
+  selection: string;
+  selectAll: string;
+  selectRow: (label: string) => string;
+  selectGroup: (group: string) => string;
+  groupRows: (count: number) => string;
+  noGroup: string;
+  actions: string;
+  rowActions: (label: string) => string;
+  emptyTitle: string;
+  emptyDescription: string;
+  loading: (caption: string) => string;
+  editHint: string;
+  editLabel: (column: string, row: string) => string;
+  editError: string;
+  enterNumber: string;
+  minimumValue: (min: number) => string;
+  maximumValue: (max: number) => string;
+}
+//#endregion
+//#region src/tables/DataTable/editable-cell.d.ts
+/** One committed cell edit, as `onCellEdit` receives it. */
+interface DataTableCellEdit<T> {
+  row: T;
+  rowId: string;
+  columnId: string;
+  /** Parsed value: a string (text, select) or a number / null (number editor). */
+  value: string | number | null;
+  /** Value the editor started from. */
+  previous: string | number | null;
+}
+/**
+ * Result of `onCellEdit`: nothing or `true` accepts the edit (the parent updates `rows`); a string
+ * rejects it and is shown inline as the error; `false` rejects with a generic message. A thrown
+ * error (or a rejected promise) rejects with its message.
+ */
+type DataTableCellEditResult = void | boolean | string;
+type DataTableCellEditHandler<T> = (edit: DataTableCellEdit<T>) => DataTableCellEditResult | Promise<DataTableCellEditResult>;
+interface EditableCellProps<T> {
+  labels?: Partial<DataTableLabels>;
+  row: T;
+  rowId: string;
+  rowLabel: string;
+  column: DataTableColumn<T>;
+  onCellEdit: DataTableCellEditHandler<T>;
+  /** Id of the shared "Press Enter or F2 to edit" hint. */
+  hintId: string;
+  /** The cell's display content. */
+  children: ReactNode;
+}
+/**
+ * An editable body cell's content. At rest it is a button showing the value (Enter, F2 or a click
+ * edits); while editing, an input or a select: Enter or Tab commits, Escape cancels. `onCellEdit`
+ * can reject the value with a message, shown inline under the editor.
+ */
+export declare function EditableCell<T>({ row, rowId, rowLabel, column, onCellEdit, hintId, children, labels }: EditableCellProps<T>): import("react").JSX.Element;
+//#endregion
+//#region src/tables/DataTable/views.d.ts
+/** What a saved view captures. Every field is optional: a missing field keeps the table's default. */
+interface DataTableViewState {
+  /** Opaque filter state of the page's toolbar (see the table's `filters` / `onFiltersChange`). */
+  filters?: unknown;
+  sort?: SortState | null;
+  hiddenColumns?: readonly string[];
+  columnWidths?: ColumnWidths;
+  pinnedColumns?: PinnedColumns;
+  /** A field key, or `null` for no grouping (function `groupBy`s cannot be saved). */
+  groupBy?: string | null;
+}
+interface DataTableView {
+  id: string;
+  name: string;
+  state: DataTableViewState;
+}
+/** Whether two view states are equivalent (key order and empty values ignored). */
+export declare function sameViewState(a: DataTableViewState, b: DataTableViewState): boolean;
+interface ViewSwitcherProps {
+  labels?: Partial<DataTableLabels>;
+  views: readonly DataTableView[];
+  activeId: string | null;
+  /** The table differs from the active view (or from the defaults when none is active). */
+  dirty: boolean;
+  onSelect: (id: string | null) => void;
+  onSaveAs: (name: string) => void;
+  onSave: () => void;
+  onRename: (id: string, name: string) => void;
+  onDelete: (id: string) => void;
+  onReset: () => void;
+}
+/** "Views" menu: switch between saved views, save the current table as a view, rename, delete, reset. */
+declare function ViewSwitcher({ labels, views, activeId, dirty, onSelect, onSaveAs, onSave, onRename, onDelete, onReset }: ViewSwitcherProps): import("react").JSX.Element;
+//#endregion
+//#region src/tables/DataTable/data-table-props.d.ts
+interface DataTableCommonProps<T> {
+  /** Per-key overrides; omitted keys keep existing defaults and provider translations. */
+  labels?: Partial<DataTableLabels>;
+  rows?: readonly T[];
+  columns?: ReadonlyArray<DataTableColumn<T>>;
+  /** Stable row id (defaults to `row.id`). */
+  getRowId?: (row: T) => string;
+  /** Row name for selection and menu labels (defaults to the first column's value). */
+  getRowLabel?: (row: T) => string;
+  /** Table name (screen-reader caption unless `showCaption`). */
+  caption?: string;
+  showCaption?: boolean;
+  /** Row selection with a select-all header checkbox (current page). */
+  selectable?: boolean;
+  /** Native radio name in single mode. Supplied names must be unique per page. */
+  selectionName?: string;
+  selectedId?: string | null;
+  defaultSelectedId?: string | null;
+  onSelectedIdChange?: (id: string) => void;
+  isRowDisabled?: (row: T) => boolean;
+  selectedIds?: readonly string[];
+  defaultSelectedIds?: readonly string[];
+  onSelectionChange?: (ids: string[]) => void;
+  /** Rendered in the toolbar while rows are selected. */
+  bulkActions?: (selectedIds: string[]) => ReactNode;
+  /**
+   * Shows the "N selected" text in the toolbar while rows are selected (default true). Turn it
+   * off when the page renders its own count, e.g. a BulkActionBar.
+   */
+  selectionSummary?: boolean;
+  /** Row-actions menu items. */
+  rowActions?: (row: T) => Array<MoreMenuAction | 'separator'>;
+  sort?: SortState | null;
+  defaultSort?: SortState | null;
+  onSortChange?: (sort: SortState) => void;
+  /** Rows arrive sorted (server side): headers still toggle, rows are not re-sorted. */
+  manualSorting?: boolean;
+  defaultPageSize?: number;
+  pageSizeOptions?: readonly number[];
+  /** Controlled row density. */
+  density?: TableDensity;
+  /** Initial density; omitted, the table follows the surrounding DensityProvider (comfortable outside one). */
+  defaultDensity?: TableDensity;
+  onDensityChange?: (density: TableDensity) => void;
+  showDensityToggle?: boolean;
+  showColumnMenu?: boolean;
+  loading?: boolean;
+  loadingRows?: number;
+  emptyState?: ReactNode;
+  /**
+   * Groups rows under header rows (a field key or a function returning the group key). Groups keep
+   * the order in which their keys first appear in `rows`; sorting applies inside each group, and
+   * pagination pages through the grouped rows (each header shows the group's full count).
+   */
+  groupBy?: DataTableGroupBy<T>;
+  /** Header text of a group (default: the key, or "No group" for rows without a value). */
+  groupLabel?: (key: string, rows: readonly T[]) => ReactNode;
+  /** Group headers render a keyboard-accessible collapse button (default true). */
+  collapsibleGroups?: boolean;
+  /** Controlled collapsed group keys. */
+  collapsedGroups?: readonly string[];
+  /** Group keys collapsed initially. */
+  defaultCollapsedGroups?: readonly string[];
+  onCollapsedGroupsChange?: (keys: string[]) => void;
+  /** Called when a saved view switches grouping (a field key, or `null` for none). */
+  onGroupByChange?: (groupBy: string | null) => void;
+  /** Controlled hidden column ids (default: columns with `defaultHidden`). */
+  hiddenColumns?: readonly string[];
+  onHiddenColumnsChange?: (ids: string[]) => void;
+  /** Resize handles on the column headers (pointer drag, or arrow keys on the focused handle). */
+  resizable?: boolean;
+  /** Controlled column widths in px by column id. */
+  columnWidths?: ColumnWidths;
+  defaultColumnWidths?: ColumnWidths;
+  onColumnWidthsChange?: (widths: Record<string, number>) => void;
+  /** Controlled pinned columns (sticky at the start or end edge while scrolling sideways). */
+  pinnedColumns?: PinnedColumns;
+  defaultPinnedColumns?: PinnedColumns;
+  onPinnedColumnsChange?: (pinned: PinnedColumns) => void;
+  /** Pin / unpin from the column menu (default true when pinning is in use: a pinned prop or callback). */
+  showPinMenu?: boolean;
+  /**
+   * Renders only the rows in view (plus overscan) inside a scrolling body with a sticky header.
+   * `'auto'` (default) turns it on above `virtualizeThreshold` rendered rows (with pagination,
+   * the rows of the current page). The table exposes `aria-rowcount` and each row its
+   * `aria-rowindex`; selection (select-all covers every row) and grouping keep working.
+   * Limits: rows get a fixed height (`rowHeight`), so multi-line cells are clipped; a row that
+   * scrolls out of view unmounts, so focus inside it (or an open inline editor) is lost; a group's
+   * header row renders only while it is in view.
+   */
+  virtualize?: boolean | 'auto';
+  virtualizeThreshold?: number;
+  /** Row height in px for virtualization (default by density: 44 comfortable, 36 compact). */
+  rowHeight?: number;
+  /** Classes of the virtualized scroll container: its max height (default `max-h-[32rem]`). */
+  virtualContainerClassName?: string;
+  /**
+   * Inline editing of `editable` columns. Return nothing to accept (and update `rows`), or a
+   * message (or throw) to reject: the message is shown inline under the editor.
+   */
+  onCellEdit?: DataTableCellEditHandler<T>;
+  /** Saved views (controlled). Each captures filters, sort, visible columns, widths, pinning and grouping. */
+  views?: readonly DataTableView[];
+  defaultViews?: readonly DataTableView[];
+  onViewsChange?: (views: DataTableView[]) => void;
+  activeViewId?: string | null;
+  defaultActiveViewId?: string | null;
+  onActiveViewChange?: (id: string | null) => void;
+  /** Shows the view switcher (default: when views are in use). */
+  showViewSwitcher?: boolean;
+  /** Opaque filter state of the page's toolbar, saved with views. */
+  filters?: unknown;
+  /** Called when a view (or a reset) restores filters. */
+  onFiltersChange?: (filters: unknown) => void;
+  /** Left side of the toolbar (title, search, FilterBar…). */
+  toolbar?: ReactNode;
+  className?: string;
+}
+type DataTableProps<T> = DataTableCommonProps<T> & ({
+  selectionMode: 'single';
+  paginated?: false;
+  /** Consumer-supplied accessible group label; the kit adds no default. */
+  legend?: ReactNode;
+  'aria-label'?: string;
+  'aria-labelledby'?: string;
+} | {
+  selectionMode?: 'none' | 'multiple';
+  paginated?: boolean;
+  legend?: never;
+  'aria-label'?: never;
+  'aria-labelledby'?: never;
+});
+//#endregion
+//#region src/tables/DataTable/fixtures.d.ts
+interface DeploymentRow {
+  id: string;
+  name: string;
+  region: string;
+  status: 'running' | 'queued' | 'paused' | 'degraded' | 'failed';
+  requests: number;
+  cost: number;
+  updatedAt: Date;
+}
+/** Deterministic deployments (the first 24 are DEPLOYMENT_ROWS); large counts exercise virtualization. */
+export declare function generateDeployments(count: number): DeploymentRow[];
+/** 24 deployments: enough for two pages at the default page size. */
+export declare const DEPLOYMENT_ROWS: DeploymentRow[];
+/** Columns for DEPLOYMENT_ROWS. */
+export declare const DEPLOYMENT_COLUMNS: DataTableColumn<DeploymentRow>[];
+//#endregion
+//#region src/tables/DataTable/DataTable.d.ts
+/**
+ * Generic data table on the kit Table: typed columns, sortable headers (aria-sort), row selection
+ * with select-all / indeterminate, column visibility menu, density toggle, row actions, loading
+ * and empty states, client-side sort + pagination, optional collapsible row groups (`groupBy`),
+ * column resize and pinning, row virtualization, inline cell editing and saved views.
+ */
+export declare function DataTable<T = (typeof DEPLOYMENT_ROWS)[number]>({ rows, columns, getRowId, getRowLabel, caption, showCaption, selectable: selectableProp, selectionMode, selectionName, legend, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, selectedId, defaultSelectedId, onSelectedIdChange, isRowDisabled, selectedIds, defaultSelectedIds, onSelectionChange, bulkActions, selectionSummary, rowActions, sort: sortProp, defaultSort, onSortChange, manualSorting, paginated: paginatedProp, defaultPageSize, pageSizeOptions, density: densityProp, defaultDensity, onDensityChange, showDensityToggle, showColumnMenu, loading, loadingRows, emptyState, groupBy, groupLabel, collapsibleGroups, collapsedGroups: collapsedProp, defaultCollapsedGroups, onCollapsedGroupsChange, onGroupByChange, hiddenColumns: hiddenProp, onHiddenColumnsChange, resizable, columnWidths: widthsProp, defaultColumnWidths, onColumnWidthsChange, pinnedColumns: pinnedProp, defaultPinnedColumns, onPinnedColumnsChange, showPinMenu, virtualize, virtualizeThreshold, rowHeight: rowHeightProp, virtualContainerClassName, onCellEdit, views: viewsProp, defaultViews, onViewsChange, activeViewId, defaultActiveViewId, onActiveViewChange, showViewSwitcher, filters, onFiltersChange, toolbar, className, labels }: DataTableProps<T>): import("react").JSX.Element;
+//#endregion
+//#region src/tables/DataTable/column-menu.d.ts
+interface ColumnVisibilityMenuProps<T> {
+  columns: ReadonlyArray<DataTableColumn<T>>;
+  hidden: ReadonlySet<string>;
+  onToggle: (columnId: string, visible: boolean) => void;
+  label?: string;
+  labels?: Partial<DataTableLabels>;
+  /** Pin side of a column; with `onPin`, the menu gets a "Pin columns" section. */
+  pinOf?: (columnId: string) => PinSide | null;
+  onPin?: (columnId: string, side: PinSide | null) => void;
+}
+/**
+ * "Columns" menu: one checkbox item per hideable column (the last visible column cannot be
+ * hidden) and, when pinning is on, a submenu per visible column to pin it left, right or unpin it.
+ */
+export declare function ColumnVisibilityMenu<T>({ columns, hidden, onToggle, label: labelProp, labels, pinOf, onPin }: ColumnVisibilityMenuProps<T>): import("react").JSX.Element;
+//#endregion
+//#region src/tables/DataTable/density-toggle.d.ts
+interface DensityToggleProps {
+  labels?: Partial<DataTableLabels>;
+  value: TableDensity;
+  onChange: (density: TableDensity) => void;
+}
+/** Two-icon segmented control: comfortable or compact rows. */
+export declare function DensityToggle({ value, onChange, labels }: DensityToggleProps): import("react").JSX.Element;
+//#endregion
+//#region src/tables/DataTable/resize-handle.d.ts
+interface ColumnResizeHandleProps {
+  labels?: Partial<DataTableLabels>;
+  /** Column name for the accessible label ("Resize Region column"). */
+  label: string;
+  width: number;
+  min: number;
+  max: number;
+  onResize: (width: number) => void;
+  /** Called once a drag or a key press ends a resize. */
+  onResizeEnd?: (width: number) => void;
+}
+/**
+ * Column resize handle at the end edge of a header cell: a focusable `role="separator"` with
+ * aria-valuenow/min/max (the width in px). Drag it with a pointer; from the keyboard,
+ * ArrowLeft/ArrowRight change the width by 10px (Shift: 50px), Home/End jump to the limits.
+ */
+export declare function ColumnResizeHandle({ label, width, min, max, onResize, onResizeEnd, labels }: ColumnResizeHandleProps): import("react").JSX.Element;
+//#endregion
+//#region src/tables/DataTable/block.meta.d.ts
+declare const meta$16: BlockMeta;
+//#endregion
+//#region src/tables/FilterBar/FilterBar.d.ts
+export interface FilterField {
+  id: string;
+  label: string;
+  options: readonly string[];
+}
+export interface ActiveFilter {
+  field: string;
+  value: string;
+}
+export interface SavedView {
+  value: string;
+  label: string;
+  query?: string;
+  filters: readonly ActiveFilter[];
+}
+export interface FilterBarLabels {
+  searchLandmark: string;
+  searchLabel: string;
+  searchPlaceholder: string;
+  savedViewLabel: string;
+  savedViewPlaceholder: string;
+  addFilter: string;
+  activeFilters: string;
+  filters: string;
+  clearAll: string;
+  removeFilter: (field: string, value: string) => string;
+  resultCount: (count: number) => string;
+}
+export interface FilterBarProps {
+  /** Per-key overrides take precedence over the legacy search props and provider catalog. */
+  labels?: Partial<FilterBarLabels>;
+  fields?: readonly FilterField[];
+  /** Search text (controlled). */
+  query?: string;
+  defaultQuery?: string;
+  onQueryChange?: (query: string) => void;
+  /** Active filters (controlled). */
+  filters?: readonly ActiveFilter[];
+  defaultFilters?: readonly ActiveFilter[];
+  onFiltersChange?: (filters: ActiveFilter[]) => void;
+  /** Saved views; picking one applies its query and filters. Empty hides the Select. */
+  views?: readonly SavedView[];
+  defaultView?: string | null;
+  onViewChange?: (view: SavedView) => void;
+  searchLabel?: string;
+  placeholder?: string;
+  /** Optional result count shown at the end ("12 results"). */
+  resultCount?: number;
+  className?: string;
+}
+/**
+ * Filter bar: search Input, saved views Select, an "Add filter" Menu (multi-select per field),
+ * removable filter chips (Token) and Clear all.
+ */
+export declare function FilterBar({ fields, query: queryProp, defaultQuery, onQueryChange, filters: filtersProp, defaultFilters, onFiltersChange, views, defaultView, onViewChange, searchLabel: searchLabelProp, placeholder: placeholderProp, resultCount, className, labels }: FilterBarProps): import("react").JSX.Element;
+//#endregion
+//#region src/tables/FilterBar/block.meta.d.ts
+declare const meta$27: BlockMeta;
+//#endregion
+//#region src/tables/FilterBar/fixtures.d.ts
+export declare const DEPLOYMENT_FILTER_FIELDS: FilterField[];
+export declare const DEPLOYMENT_DEFAULT_FILTERS: ActiveFilter[];
+export declare const DEPLOYMENT_SAVED_VIEWS: SavedView[];
+//#endregion
+//#region src/tables/PaginationFooter/block.meta.d.ts
+declare const meta$46: BlockMeta;
+//#endregion
+//#region src/tables/TruncatedCollectionFooter/TruncatedCollectionFooter.d.ts
+export interface TruncatedCollectionFooterProps {
+  /** Number of records already loaded; never an estimated total. */
+  visibleCount: number;
+  /** More records exist beyond this first page, making the count a lower bound. */
+  hasMore: boolean;
+  /** Localized noun used in the default summary label and note. */
+  noun?: string;
+  /** Number-formatting locale; translated defaults come from I18nProvider. */
+  locale?: string;
+  /** Plain text label before the count; null hides it. */
+  summaryLabel?: ReactNode;
+  /** Replaces the entire count, including the lower-bound marker. Return plain text nodes. */
+  formatCount?: (count: number, hasMore: boolean) => ReactNode;
+  /** Plain text note or formatter, rendered only when hasMore is true. */
+  truncationNote?: ((count: number) => ReactNode) | ReactNode;
+  /** Id of the note for a consumer's aria-describedby reference. */
+  noteId?: string;
+  className?: string;
+}
+/** Static first-page summary with no total, navigation, focus stops or live region. */
+export declare function TruncatedCollectionFooter({ visibleCount, hasMore, noun: nounProp, locale: localeProp, summaryLabel, formatCount, truncationNote, noteId, className }: TruncatedCollectionFooterProps): import("react").JSX.Element;
+//#endregion
+//#region src/tables/TruncatedCollectionFooter/block.meta.d.ts
+declare const meta$73: BlockMeta;
+//#endregion
+//#region src/tables/InlineEditRow/fixtures.d.ts
+interface EditableMember {
+  id: string;
+  name: string;
+  email: string;
+  role: string;
+  seats: number;
+}
+export declare const EDITABLE_MEMBER_FIELDS: InlineEditField<EditableMember>[];
+export declare const EDITABLE_MEMBERS: EditableMember[];
+//#endregion
+//#region src/tables/InlineEditRow/InlineEditRow.d.ts
+export interface InlineEditField<T> {
+  key: Extract<keyof T, string>;
+  label: string;
+  type?: 'text' | 'number' | 'email';
+  align?: 'left' | 'right';
+  required?: boolean;
+  /** Read-mode cell classes. */
+  className?: string;
+}
+export interface InlineEditRowProps<T extends object> {
+  row: T;
+  fields: ReadonlyArray<InlineEditField<T>>;
+  /** Called with the edited row on Save (or Enter). */
+  onSave?: (next: T) => void;
+  onCancel?: () => void;
+  /** Row name for the Edit button label ("Edit Ana Lopez"). */
+  rowLabel?: string;
+  /** Start in edit mode. */
+  defaultEditing?: boolean;
+}
+/**
+ * A table row that switches into edit mode: inputs replace the cells, with Save and Cancel.
+ * Enter saves, Escape cancels; focus moves to the first input and back to Edit afterwards.
+ */
+export declare function InlineEditRow<T extends object>({ row, fields, onSave, onCancel, rowLabel, defaultEditing }: InlineEditRowProps<T>): import("react").JSX.Element;
+export interface InlineEditTableProps<T extends object> {
+  rows?: readonly T[];
+  fields?: ReadonlyArray<InlineEditField<T>>;
+  getRowId?: (row: T) => string;
+  caption?: string;
+  /** Called with the saved row; rows also update locally. */
+  onRowSave?: (row: T) => void;
+  className?: string;
+}
+/** Standalone demo of InlineEditRow: a small editable table that keeps its rows in state. */
+export declare function InlineEditTable<T extends object = EditableMember>({ rows: initialRows, fields, getRowId, caption, onRowSave, className }: InlineEditTableProps<T>): import("react").JSX.Element;
+//#endregion
+//#region src/tables/InlineEditRow/block.meta.d.ts
+declare const meta$34: BlockMeta;
+//#endregion
+//#region src/tables/SubordinateList/SubordinateList.d.ts
+export interface SubordinateListPagination {
+  /** Positive server page size. */
+  limit: number;
+  /** Zero-based server offset. */
+  offset: number;
+  total: number;
+  onPageChange: (offset: number) => void;
+}
+export interface SubordinateListError {
+  title: string;
+  message: string;
+  /** null hides the error code chip. */
+  code: string | number | null;
+}
+export interface SubordinateListProps<T> {
+  title: string;
+  headingLevel: 'h2' | 'h3';
+  /** Server total, or the length of an unpaginated collection (including zero). */
+  count: number;
+  columns: ReadonlyArray<DataTableColumn<T>>;
+  rows: readonly T[];
+  getRowId: (row: T) => string;
+  pagination: SubordinateListPagination | null;
+  loading: boolean;
+  error: SubordinateListError | null;
+  onRetry: () => void | Promise<void>;
+  /** Host-supplied EmptyStates composition. */
+  emptyState: ReactNode;
+}
+/** Read-only list section with explicit host data and no demo defaults. */
+export declare function SubordinateList<T>({ title, headingLevel, count, columns, rows, getRowId, pagination, loading, error, onRetry, emptyState }: SubordinateListProps<T>): import("react").JSX.Element;
+//#endregion
+//#region src/tables/SubordinateList/block.meta.d.ts
+declare const meta$68: BlockMeta;
+//#endregion
+//#region src/team/MembersTable/fixtures.d.ts
+interface Member {
+  id: string;
+  name: string;
+  email: string;
+  avatarUrl?: string;
+  role: string;
+  /** ISO date of the last activity; null when the member never signed in. */
+  lastActive: string | null;
+}
+declare const members$1: Member[];
+//#endregion
+//#region src/team/MembersTable/MembersTable.d.ts
+export interface MembersTableProps {
+  members?: Member[];
+  roles?: RoleOption[];
+  /** Id of the signed-in member: shown with a "You" badge, and their role and removal are locked. */
+  currentUserId?: string;
+  onRoleChange?: (memberId: string, role: string) => void;
+  onRemove?: (member: Member) => void;
+  onEmail?: (member: Member) => void;
+  /** Table caption (screen-reader only by default). */
+  caption?: string;
+  className?: string;
+}
+/** Workspace members: avatar, name and email, inline role select, last activity and a row menu. */
+export declare function MembersTable({ members, roles, currentUserId, onRoleChange, onRemove, onEmail, caption, className }: MembersTableProps): import("react").JSX.Element;
+//#endregion
+//#region src/team/MembersTable/block.meta.d.ts
+declare const meta$39: BlockMeta;
+//#endregion
+//#region src/team/NotificationMatrix/fixtures.d.ts
+interface NotificationChannel {
+  id: string;
+  label: string;
+}
+interface NotificationEvent {
+  id: string;
+  label: string;
+  description?: string;
+  /** Channels that are always on for this event (shown checked and disabled). */
+  locked?: string[];
+}
+type NotificationMatrixValue = Record<string, string[]>;
+export declare const notificationChannels: NotificationChannel[];
+export declare const notificationEvents: NotificationEvent[];
+export declare const notificationDefaults: NotificationMatrixValue;
+//#endregion
+//#region src/team/NotificationMatrix/NotificationMatrix.d.ts
+export interface NotificationMatrixProps {
+  channels?: NotificationChannel[];
+  events?: NotificationEvent[];
+  /** Event id → enabled channel ids (controlled). */
+  value?: NotificationMatrixValue;
+  defaultValue?: NotificationMatrixValue;
+  onValueChange?: (value: NotificationMatrixValue) => void;
+  caption?: string;
+  className?: string;
+}
+/**
+ * Event × channel grid of checkboxes. Column headers toggle a channel for every event, the last
+ * column toggles every channel for one event; both show the mixed state. Locked cells stay on.
+ */
+export declare function NotificationMatrix({ channels, events, value: valueProp, defaultValue, onValueChange, caption, className }: NotificationMatrixProps): import("react").JSX.Element;
+//#endregion
+//#region src/team/NotificationMatrix/block.meta.d.ts
+declare const meta$43: BlockMeta;
+//#endregion
+//#region src/team/PendingInvitations/fixtures.d.ts
+interface Invitation {
+  id: string;
+  email: string;
+  role: string;
+  invitedBy?: string;
+  /** ISO date the invitation was sent. */
+  invitedAt: string;
+  /** ISO date it expires. */
+  expiresAt?: string;
+}
+declare const invitations$1: Invitation[];
+//#endregion
+//#region src/team/PendingInvitations/PendingInvitations.d.ts
+export interface PendingInvitationsProps {
+  invitations?: Invitation[];
+  /** Resends one invitation. A returned promise shows a loading state. */
+  onResend?: (invitation: Invitation) => void | Promise<void>;
+  onRevoke?: (invitation: Invitation) => void;
+  title?: ReactNode;
+  headingLevel?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** Pending invitations with who sent them, expiry, and resend / revoke actions. */
+export declare function PendingInvitations({ invitations, onResend, onRevoke, title, headingLevel: Heading, className }: PendingInvitationsProps): import("react").JSX.Element;
+//#endregion
+//#region src/team/PendingInvitations/block.meta.d.ts
+declare const meta$48: BlockMeta;
+//#endregion
+//#region src/team/ProfileHeader/fixtures.d.ts
+interface ProfileMetaItem {
+  icon?: LucideIcon;
+  label: string;
+}
+interface Profile {
+  name: string;
+  /** Role or title shown as a badge. */
+  role?: string;
+  /** One-line headline under the name. */
+  headline?: string;
+  avatarUrl?: string;
+  meta?: ProfileMetaItem[];
+}
+declare const profile$1: Profile;
+//#endregion
+//#region src/team/ProfileHeader/ProfileHeader.d.ts
+export interface ProfileHeaderProps {
+  profile?: Profile;
+  /** Called with the picked image; the avatar previews it right away. `null` hides the change action. */
+  onAvatarChange?: ((file: File) => void) | null;
+  /** Called by the Edit profile button. `null` hides it. */
+  onEdit?: (() => void) | null;
+  /** Extra actions next to Edit. */
+  actions?: ReactNode;
+  headingLevel?: 'h1' | 'h2';
+  className?: string;
+}
+/** Profile header: large avatar with a change action, name, role, headline, meta row and edit button. */
+export declare function ProfileHeader({ profile, onAvatarChange, onEdit, actions, headingLevel: Heading, className }: ProfileHeaderProps): import("react").JSX.Element;
+//#endregion
+//#region src/team/ProfileHeader/block.meta.d.ts
+declare const meta$52: BlockMeta;
+//#endregion
+//#region src/team/SessionsDevices/fixtures.d.ts
+type DeviceKind = 'desktop' | 'mobile' | 'tablet';
+interface DeviceSession {
+  id: string;
+  /** Device name, e.g. "MacBook Pro". */
+  device: string;
+  /** Browser or client, e.g. "Chrome 128 on macOS". */
+  client: string;
+  kind: DeviceKind;
+  location: string;
+  ip?: string;
+  /** ISO date of the last request. */
+  lastSeen: string;
+  /** The session making this request. */
+  current?: boolean;
+}
+declare const deviceSessions: DeviceSession[];
+//#endregion
+//#region src/team/SessionsDevices/SessionsDevices.d.ts
+export interface SessionsDevicesProps {
+  sessions?: DeviceSession[];
+  onRevoke?: (session: DeviceSession) => void;
+  /** Signs out every session except the current one. */
+  onRevokeOthers?: (sessions: DeviceSession[]) => void;
+  title?: ReactNode;
+  description?: ReactNode;
+  headingLevel?: 'h2' | 'h3' | 'h4';
+  className?: string;
+}
+/** Signed-in sessions and devices: client, location, last seen, the current one marked, and revoke. */
+export declare function SessionsDevices({ sessions, onRevoke, onRevokeOthers, title, description, headingLevel: Heading, className }: SessionsDevicesProps): import("react").JSX.Element;
+//#endregion
+//#region src/team/SessionsDevices/block.meta.d.ts
+declare const meta$58: BlockMeta;
+//#endregion
+export { type ApiKeyExpiry, type ApiKeyScope, type Assistant, type AssistantStatus, type AuthFormAccessibilityProps, type AuthHeaderProps, type AuthIdentifierConfig, type AuthSignUpField, type AuthSignUpValidationMessages, type AuthUnavailableState, type AuthValidationMessages, type BlockMeta, type CodeFile, type CodePanelMarker, type CodeProblem, type ColumnResizeHandleProps, type ColumnVisibilityMenuProps, type ColumnWidths, type ConfirmDestructiveDialogProps, type ConsoleEntry, type CostPoint, type DangerZoneAction, type DataTableCellEdit, type DataTableCellEditHandler, type DataTableCellEditResult, type DataTableLabels, type DataTableProps, type DataTableView, type DataTableViewState, ViewSwitcher as DataTableViewSwitcher, type ViewSwitcherProps as DataTableViewSwitcherProps, type DensityToggleProps, type DeploymentRow, type DeviceKind, type DeviceSession, type EditableMember, type EvalMetric, type EvalRow, type EventKind, type EventTone, type FeedbackAction, type FlowConnection, type FlowConnectionRejection, type FlowEdge, type FlowHandle, type FlowNode, type FlowNodeData, type FlowNodeKind, type FlowNodeRenderProps, type FlowNodeRenderer, type FlowTone, type FlowValidationIssue, type Invitation, type LogLevel, type LogLine, type MarketingAction, type Member, type ModelKey, type ModelKeyStatus, type MonacoReady, type NodeInspectorProps, type NodePaletteProps, type NotificationChannel, type NotificationEvent, type NotificationMatrixValue, type PageChromeAction, type PaletteItem, type PanelHeading, type PinSide, type PinnedColumns, type PlanSummaryProps, type ProblemSeverity, type Profile, type ProfileMetaItem, type RoleOption, type RunConsoleProps, type ScheduleEvent, type SpanDetailsProps, type SpanKind, type SsoProvider, type SummaryPlan, type TokenUsagePeriod, type TraceSpan, type TrafficRow, type UploadItem, type UploadStatus, type ValidationIssue, meta$1 as activityFeedMeta, meta$2 as agendaListMeta, meta$3 as appSidebarMeta, meta$4 as appTopbarMeta, meta$5 as assistantCardGridMeta, meta$6 as bulkActionBarMeta, meta$7 as chartCardMeta, meta$8 as codePanelMeta, meta$9 as commentThreadMeta, meta$10 as comparisonTableMeta, meta$11 as confirmDestructiveMeta, meta$12 as costBreakdownMeta, meta$13 as createApiKeyDialogMeta, meta$14 as credentialDisclosureDialogMeta, meta$15 as dangerZoneMeta, meta$16 as dataTableMeta, meta$17 as dateRangeFilterMeta, meta$18 as descriptionListCardMeta, meta$19 as dialogWizardMeta, meta$20 as emptyStatesMeta, meta$21 as environmentBadgeMeta, meta$22 as errorPanelMeta, meta$23 as evaluationScorecardMeta, meta$24 as faqMeta, meta$25 as featureGridMeta, meta$26 as fileUploadPanelMeta, meta$27 as filterBarMeta, meta$28 as flowBuilderMeta, meta$29 as forgotPasswordFormMeta, meta$30 as formSectionMeta, meta$31 as globalSearchMeta, meta$32 as heroMeta, meta$33 as inlineCalloutMeta, meta$34 as inlineEditRowMeta, meta$35 as inviteMembersDialogMeta, meta$36 as invoiceTableMeta, meta$37 as kpiRowMeta, meta$38 as logViewerMeta, meta$39 as membersTableMeta, meta$40 as mfaChallengeMeta, meta$41 as modelKeysListMeta, meta$42 as monthCalendarMeta, meta$43 as notificationMatrixMeta, meta$44 as pageHeaderMeta, meta$45 as pageToolbarMeta, meta$46 as paginationFooterMeta, meta$47 as paymentMethodCardMeta, meta$48 as pendingInvitationsMeta, meta$49 as planCardMeta, meta$50 as planDefinitionCardMeta, meta$51 as pricingTableMeta, meta$52 as profileHeaderMeta, meta$53 as promptEditorMeta, meta$54 as quotaMetersMeta, meta$55 as resetPasswordFormMeta, meta$56 as resourceCardGridMeta, deviceSessions as sampleDeviceSessions, invitations$1 as sampleInvitations, members$1 as sampleMembers, profile$1 as sampleProfile, sampleEvents as sampleScheduleEvents, sampleToday as sampleScheduleToday, meta$57 as sectionHeaderMeta, meta$58 as sessionsDevicesMeta, meta$59 as settingsRowMeta, meta$60 as signInFormMeta, meta$61 as signUpFormMeta, meta$62 as skeletonsMeta, meta$63 as spendVsBudgetMeta, meta$64 as ssoButtonsMeta, meta$65 as statCardMeta, meta$66 as statusTimelineMeta, meta$67 as stickyActionBarMeta, meta$68 as subordinateListMeta, meta$69 as systemBannerMeta, meta$70 as timeSlotPickerMeta, meta$71 as tokenCostCardMeta, meta$72 as traceWaterfallMeta, meta$73 as truncatedCollectionFooterMeta, validationIssues$1 as validationIssues, meta$74 as validationSummaryMeta, meta$75 as weekCalendarMeta };
+//# sourceMappingURL=index.d.ts.map