@wildo-ai/saas-models 1.0.1

package/dist/esm/config/frontend/navigation.shared.schemas.d.ts

@@ -0,0 +1,684 @@
+/**
+ * Navigation — Configuration Schemas
+ *
+ * Zone-first, operation-driven navigation configuration model.
+ * Decomposes navigation into four independent axes:
+ *
+ * 1. **Meaning** (input signals) — contextual facts at navigation time (source zone, operation,
+ *    cardinality, viewport, depth). NOT configured — these are inputs to resolution.
+ * 2. **Transition** (verb) — HOW content arrives: push, replace, split, overlay, inplace, promote.
+ *    This is the primary thing that gets configured per zone.
+ * 3. **Placement** (zones) — WHERE content lives: primary, secondary, companion, overlay.
+ *    Zones are structural layout areas AND source context for resolution.
+ * 4. **Appearance** (visual) — HOW content renders in its slot: panel, drawer, dialog, sheet.
+ *    Only meaningful for split and overlay transitions.
+ *
+ * Key design decisions:
+ * - Zones own their complete behavior (no global defaults + override pattern)
+ * - Operations are transition keys; cardinality drives appearance only
+ * - Embedding (tabs/sections within a parent) is view composition, not navigation
+ * - `contentModel` (single/tabbed) is orthogonal to transitions
+ *
+ * @see _code_archive/docs-archive/navigation/navigation-v3-reflection.md
+ */
+import { z } from 'zod';
+import { ViewportBreakpoint, DisplayDirection } from '@wildo-ai/zod-decorators';
+import { CoreResourceOperation } from '../../resources/resources.shared.core.definitions.js';
+/**
+ * Navigation transition verbs — HOW content arrives at its destination.
+ *
+ * These are the six fundamental navigation actions. Every user-triggered
+ * navigation event resolves to exactly one of these verbs. The source zone's
+ * `transitions` map determines which verb fires for each operation.
+ *
+ * Four zone-level transitions: `push`, `replace`, `split`, `overlay`
+ * Two cross-context transitions: `inplace` (element-level), `promote` (escape to primary)
+ *
+ * `push` behavior depends on the zone's `contentModel`:
+ * - In `single` zones: stack-based (new content on top, back pops)
+ * - In `tabbed` zones: opens a new tab (or activates existing for same resource)
+ */
+export declare enum NavigationTransition {
+    /**
+     * Content added to the zone's stack (single) or as a new tab (tabbed).
+     * Back navigation pops the stack or switches to the previous tab.
+     * URL adds a new path segment.
+     */
+    PUSH = "push",
+    /**
+     * Content replaces the current content in the zone. No stack entry — the previous
+     * content is gone from the zone's state (but remains in browser history).
+     * URL replaces the current segment.
+     */
+    REPLACE = "replace",
+    /**
+     * Content opens in an adjacent zone (secondary or companion).
+     * Creates a side-by-side layout. The source zone's content remains visible.
+     * Back navigation un-splits (closes the adjacent zone).
+     * URL adds a split segment.
+     */
+    SPLIT = "split",
+    /**
+     * Content opens in a floating layer above the entire layout (dialog or sheet).
+     * The underlying layout remains visible but non-interactive.
+     * Back navigation or Escape dismisses the overlay.
+     * URL adds an overlay param/hash.
+     */
+    OVERLAY = "overlay",
+    /**
+     * Element-level transformation within the current view. A specific item in a
+     * list/section transforms from one mode to another (read → edit, or a new
+     * create form materializes inline). The parent view stays. The zone stack is
+     * unchanged. Surrounding items remain visible.
+     *
+     * Fundamentally different from `replace` (which swaps the entire zone content).
+     * `inplace` operates at the element level, not the zone level.
+     *
+     * No lifecycle modifiers (`persistent`/`ephemeral`) are valid on `inplace`.
+     * No appearance to configure — the element transforms within its existing slot.
+     *
+     * URL serialization: query param on the current URL (e.g., `?editing=<childId>`
+     * or `?creating=<resourceType>`).
+     *
+     * @example
+     * // Click "edit" on a child in parent's inline section → item transforms to edit form
+     * transitions: { [CoreResourceOperation.UPDATE]: NavigationTransition.INPLACE }
+     *
+     * // Click "add" in a relationship section → create form appears inline in the list
+     * transitions: { [CoreResourceOperation.CREATE]: NavigationTransition.INPLACE }
+     */
+    INPLACE = "inplace",
+    /**
+     * Escape the current context and open content at primary scope.
+     * Abandons the current context: overlays close, companion/secondary dismiss.
+     * The promoted content becomes the primary zone's top content.
+     *
+     * Use case: a link within an overlay should open as a full primary view,
+     * or a nested detail in a companion zone should "pop out" to primary.
+     *
+     * Fundamentally different from `push` (which stays in the current zone) and
+     * from `replace` (which replaces content within the same zone). `promote`
+     * crosses zones and always targets primary.
+     *
+     * No lifecycle modifiers (`persistent`/`ephemeral`) are valid on `promote`.
+     * No appearance to configure — content fills primary (same as push/replace).
+     *
+     * URL serialization: full URL change (promoted resource becomes the primary route).
+     *
+     * @example
+     * // From an overlay, a link should open as primary (close overlay, show in primary)
+     * transitions: { [CoreResourceOperation.READ]: NavigationTransition.PROMOTE }
+     */
+    PROMOTE = "promote"
+}
+/**
+ * Named layout zones — configurable structural areas WHERE content lives.
+ *
+ * Zones serve four purposes:
+ * 1. **Structural** — which physical areas exist in the layout (declared in config)
+ * 2. **Source context** — the same operation resolves differently FROM primary vs FROM secondary
+ * 3. **Responsive** — each zone carries its own collapse behavior per viewport
+ * 4. **Content model** — each zone independently manages single-stack or tabbed content
+ *
+ * Note: `overlay` is NOT a named zone — it's an implicit layer always available.
+ * Overlay is a runtime destination, not a configurable zone. See `NavigationZone`
+ * in the frontend runtime types for the full set including overlay.
+ */
+export declare enum NavigationZoneName {
+    /** Main content area. Lists, root-level reads, primary workspace. Always exists. */
+    PRIMARY = "primary",
+    /**
+     * First adjacent zone. Detail content in list-detail patterns.
+     * Only exists if declared in config. Appears when a `split` transition targets it.
+     * Typical use: showing item details alongside a list.
+     */
+    SECONDARY = "secondary",
+    /**
+     * Persistent supplementary content. Reference panels, docs, notes, threads.
+     * Only exists if declared in config. Usually hidden by default (`defaultVisible: false`).
+     * Activated by `split` with `persistent: true` or explicit user toggle.
+     * Typical use: Slack thread panel, VS Code terminal, documentation sidebar.
+     */
+    COMPANION = "companion"
+}
+/**
+ * How a zone manages multiple items. Orthogonal to transitions.
+ *
+ * The transition says "content arrives" — the content model says
+ * "how does the zone accommodate it." Any zone can use any content model,
+ * regardless of which transitions it supports.
+ */
+export declare enum NavigationZoneContentModel {
+    /**
+     * Navigation stack: new content pushes on top, previous preserved underneath.
+     * Only one item visible at a time. Back navigation pops the stack.
+     * `replace` replaces the top without adding to the stack.
+     * This is the default for all zones.
+     */
+    SINGLE = "single",
+    /**
+     * Parallel tabs: `push` creates a new tab (or activates existing for the same resource).
+     * Tab bar is visible, showing all open tabs. No depth stack within tabs.
+     * `replace` replaces the active tab's content. Close is an explicit action (not back).
+     * When no tabs remain, `onEmpty` behavior applies.
+     */
+    TABBED = "tabbed"
+}
+/**
+ * Responsive collapse behavior when viewport shrinks below a zone's breakpoint.
+ *
+ * Only applies to secondary and companion zones. Primary never collapses.
+ * When viewport grows back past the breakpoint, collapsed content migrates
+ * back to its original zone (content is preserved).
+ */
+export declare enum ResponsiveCollapseMode {
+    /**
+     * Zone hides. Its content joins primary's navigation stack.
+     * The user sees the content in-context within primary.
+     * Back navigation pops back to primary's previous content.
+     */
+    PUSH = "push",
+    /**
+     * Zone hides. Its content opens as an overlay on top of primary.
+     * The user sees the content as a floating sheet/dialog.
+     * Dismiss returns to the underlying primary content.
+     */
+    OVERLAY = "overlay"
+}
+/**
+ * What happens when a zone's last content is dismissed.
+ * Only meaningful for secondary and companion zones (primary never empties,
+ * overlay auto-dismisses by definition).
+ */
+export declare enum ZoneEmptyBehavior {
+    /**
+     * Zone hides, adjacent zones expand to fill the space.
+     * Example: closing the last detail → layout returns to list-only.
+     * This is the default for all non-primary zones.
+     */
+    COLLAPSE = "collapse",
+    /**
+     * Zone stays visible with an empty-state placeholder.
+     * Example: "Select an item to view details" message. Keeps layout stable.
+     * Useful when the user frequently toggles between items.
+     */
+    EMPTY_STATE = "emptyState"
+}
+/**
+ * Visual presentation for overlay transitions.
+ * Determines how floating content renders above the layout.
+ */
+export declare enum OverlayAppearance {
+    /**
+     * Centered modal dialog with backdrop.
+     * Best for focused tasks: create forms, confirmations, destructive actions.
+     * Blocks underlying content visually. Escape or backdrop click dismisses.
+     */
+    DIALOG = "dialog",
+    /**
+     * Side or bottom drawer panel that slides in from an edge.
+     * Best for contextual content that benefits from seeing the underlying layout.
+     * Less disruptive than dialog. Common for detail views on mobile.
+     */
+    SHEET = "sheet"
+}
+/**
+ * Visual presentation for split transitions.
+ * Determines how adjacent zone content renders alongside the source zone.
+ */
+export declare enum SplitAppearance {
+    /**
+     * Standard vertical side panel.
+     * Content appears beside the source zone with a resizable divider.
+     * Most common for list-detail patterns.
+     */
+    PANEL = "panel",
+    /**
+     * Horizontal drawer (bottom panel).
+     * Content appears below the source zone.
+     * Used for companion panels like terminals, output logs, reference docs.
+     */
+    DRAWER = "drawer"
+}
+/**
+ * A value that is either a plain `T` (applies at all viewports) or a
+ * viewport-keyed partial record for per-breakpoint control.
+ *
+ * This pattern is used throughout the navigation config for responsive properties:
+ * `responsiveCollapse`, `appearance`, `contentSectionConfig`, `transition`.
+ *
+ * @example
+ * // Plain value — same everywhere
+ * responsiveCollapse: ResponsiveCollapseMode.PUSH
+ *
+ * // Viewport-discriminated — different per breakpoint
+ * responsiveCollapse: { [ViewportBreakpoint.VERT_TABLET]: ResponsiveCollapseMode.PUSH, [ViewportBreakpoint.MOBILE]: ResponsiveCollapseMode.OVERLAY }
+ *
+ * // Overlay appearance — sheet on tablet, dialog on mobile
+ * overlay: { [ViewportBreakpoint.VERT_TABLET]: OverlayAppearance.SHEET, [ViewportBreakpoint.MOBILE]: OverlayAppearance.DIALOG }
+ */
+export type ViewportDiscriminated<T> = T | Partial<Record<ViewportBreakpoint, T>>;
+/**
+ * Zod schema factory for `ViewportDiscriminated<T>`.
+ *
+ * Produces a union: the plain inner schema OR a record keyed by `ViewportBreakpoint`
+ * with inner schema values. The record must have at least one key.
+ *
+ * @param innerSchema - Zod schema for the value type at each breakpoint.
+ */
+export declare function viewportDiscriminatedSchema<T extends z.ZodType>(innerSchema: T): z.ZodUnion<readonly [T, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, T>]>;
+/**
+ * Extended transition with lifecycle modifiers.
+ *
+ * Most transitions are simple verbs (just the enum value). The object form
+ * adds lifecycle semantics for two specific patterns:
+ *
+ * - **Companion pattern**: `{ transition: NavigationTransition.SPLIT, persistent: true }`
+ *   The split zone persists when the source zone's content changes.
+ *   Without `persistent`, a split zone would clear when primary navigates away.
+ *
+ * - **Inspect pattern**: `{ transition: NavigationTransition.OVERLAY, ephemeral: true }`
+ *   The overlay auto-closes when the source zone's stack changes.
+ *   Without `ephemeral`, overlays stay open until explicitly dismissed.
+ *
+ * Semantic constraints (enforced by `.refine()`):
+ * - `persistent` is only valid on `split` transitions
+ * - `ephemeral` is only valid on `overlay` transitions
+ * - `persistent` and `ephemeral` are mutually exclusive
+ * - `inplace` and `promote` do not accept any modifier (they are always simple verbs)
+ */
+export declare const TransitionObjectSchema: z.ZodObject<{
+    transition: z.ZodEnum<typeof NavigationTransition>;
+    persistent: z.ZodOptional<z.ZodBoolean>;
+    ephemeral: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type TransitionObject = z.infer<typeof TransitionObjectSchema>;
+/**
+ * A transition configuration: either a simple verb string or an object with modifiers.
+ *
+ * @example
+ * // Simple verb
+ * transitions: { read: NavigationTransition.SPLIT, create: NavigationTransition.OVERLAY }
+ *
+ * // Object with lifecycle modifier
+ * transitions: { read: { transition: NavigationTransition.SPLIT, persistent: true } }
+ */
+export declare const TransitionConfigSchema: z.ZodUnion<readonly [z.ZodEnum<typeof NavigationTransition>, z.ZodObject<{
+    transition: z.ZodEnum<typeof NavigationTransition>;
+    persistent: z.ZodOptional<z.ZodBoolean>;
+    ephemeral: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip, core.$ZodObjectExtra>]>;
+export type TransitionConfig = z.infer<typeof TransitionConfigSchema>;
+/**
+ * Operation → transition mapping for a zone.
+ *
+ * Partial record — only operations that the zone handles need entries.
+ * Missing operations fall back to the framework's hardcoded defaults.
+ *
+ * Keys are `CoreResourceOperation` values such as `read`, `list`, `create`,
+ * `update`, `delete`, and `search`.
+ *
+ * @example
+ * transitions: {
+ *   read:    NavigationTransition.SPLIT,       // click item → split to secondary
+ *   list:    NavigationTransition.REPLACE,     // "View all" → replace primary
+ *   create:  NavigationTransition.OVERLAY,     // new item → dialog
+ *   update:  NavigationTransition.INPLACE,     // edit → transform element inline
+ *   delete:  NavigationTransition.OVERLAY,     // confirm → dialog
+ *   search:  NavigationTransition.PUSH,        // advanced search → full-surface route
+ * }
+ *
+ * // From an overlay, promote a link to primary view
+ * transitions: {
+ *   read:    NavigationTransition.PROMOTE,     // link in overlay → escape to primary
+ * }
+ */
+/** Partial record — only operations that the zone handles need entries. Missing operations fall back to framework defaults. */
+export declare const ZoneTransitionsSchema: z.ZodType<Partial<Record<CoreResourceOperation, TransitionConfig>>>;
+export type ZoneTransitions = Partial<Record<CoreResourceOperation, TransitionConfig>>;
+/**
+ * Transition → visual appearance for a zone. Values are viewport-discriminated.
+ *
+ * Only `split` and `overlay` transitions have meaningful appearance choices.
+ * `push`, `replace`, `inplace`, and `promote` have no appearance to configure:
+ * - `push`/`replace` fill the zone
+ * - `inplace` transforms an element within the current view
+ * - `promote` fills primary (same as push/replace)
+ *
+ * @example
+ * appearance: {
+ *   split:   SplitAppearance.PANEL,                                                       // always side panel
+ *   overlay: { [ViewportBreakpoint.VERT_TABLET]: OverlayAppearance.SHEET, [ViewportBreakpoint.MOBILE]: OverlayAppearance.DIALOG },   // sheet on tablet, dialog on mobile
+ * }
+ */
+export declare const ZoneAppearanceSchema: z.ZodObject<{
+    split: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof SplitAppearance>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof SplitAppearance>>]>>;
+    overlay: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof OverlayAppearance>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof OverlayAppearance>>]>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type ZoneAppearance = z.infer<typeof ZoneAppearanceSchema>;
+/**
+ * Full zone configuration.
+ *
+ * Each declared zone in the layout owns its complete behavior:
+ * which transition fires for each operation, how content appears,
+ * and how the zone responds to viewport changes.
+ *
+ * Note: `minWidth`, `maxWidth`, `defaultVisible`, `onEmpty`,
+ * and `responsiveCollapse` are only meaningful for secondary and companion zones.
+ * Primary never collapses, never empties, and takes remaining space.
+ * Setting these on primary has no effect.
+ */
+export declare const ZoneConfigSchema: z.ZodObject<{
+    contentModel: z.ZodDefault<z.ZodEnum<typeof NavigationZoneContentModel>>;
+    transitions: z.ZodType<Partial<Record<CoreResourceOperation, NavigationTransition | {
+        transition: NavigationTransition;
+        persistent?: boolean;
+        ephemeral?: boolean;
+    }>>, unknown, z.core.$ZodTypeInternals<Partial<Record<CoreResourceOperation, NavigationTransition | {
+        transition: NavigationTransition;
+        persistent?: boolean;
+        ephemeral?: boolean;
+    }>>, unknown>>;
+    appearance: z.ZodOptional<z.ZodObject<{
+        split: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof SplitAppearance>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof SplitAppearance>>]>>;
+        overlay: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof OverlayAppearance>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof OverlayAppearance>>]>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    minWidth: z.ZodOptional<z.ZodNumber>;
+    maxWidth: z.ZodOptional<z.ZodNumber>;
+    defaultVisible: z.ZodOptional<z.ZodBoolean>;
+    onEmpty: z.ZodOptional<z.ZodEnum<typeof ZoneEmptyBehavior>>;
+    responsiveCollapse: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof ResponsiveCollapseMode>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof ResponsiveCollapseMode>>]>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type ZoneConfig = z.infer<typeof ZoneConfigSchema>;
+/**
+ * App-level navigation configuration: from OUTSIDE the zone system.
+ *
+ * Covers navigation triggered by sidebar clicks, command palette selections,
+ * hotkey shortcuts, toast actions, and notification clicks.
+ *
+ * App-level navigation causes a **layout reset**: primary content is replaced,
+ * secondary and companion zones are cleared. This is fundamentally different
+ * from zone-level navigation where the source zone's content persists.
+ *
+ * @example
+ * appLevel: {
+ *   transitions: {
+ *     list:    NavigationTransition.REPLACE,   // sidebar "Projects" → replace primary, clear others
+ *     read:    NavigationTransition.REPLACE,   // command palette "Go to X" → replace primary
+ *     create:  NavigationTransition.OVERLAY,   // quick action "New X" → dialog
+ *     search:  NavigationTransition.REPLACE,   // command/menu search surface → replace primary
+ *   },
+ *   appearance: { overlay: OverlayAppearance.DIALOG },
+ * }
+ */
+export declare const AppLevelConfigSchema: z.ZodObject<{
+    transitions: z.ZodType<Partial<Record<CoreResourceOperation, NavigationTransition | {
+        transition: NavigationTransition;
+        persistent?: boolean;
+        ephemeral?: boolean;
+    }>>, unknown, z.core.$ZodTypeInternals<Partial<Record<CoreResourceOperation, NavigationTransition | {
+        transition: NavigationTransition;
+        persistent?: boolean;
+        ephemeral?: boolean;
+    }>>, unknown>>;
+    appearance: z.ZodOptional<z.ZodObject<{
+        split: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof SplitAppearance>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof SplitAppearance>>]>>;
+        overlay: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof OverlayAppearance>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof OverlayAppearance>>]>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type AppLevelConfig = z.infer<typeof AppLevelConfigSchema>;
+/**
+ * Navigation from within an overlay (dialog or sheet).
+ *
+ * When already in an overlay, transitions behave differently to avoid
+ * nesting overlays. Typically all operations `push` within the overlay's
+ * own stack instead of opening new overlays.
+ *
+ * No appearance config — the content is already inside an overlay.
+ *
+ * @example
+ * fromOverlay: {
+ *   transitions: {
+ *     read:    NavigationTransition.PUSH,   // push within overlay — don't nest modals
+ *     list:    NavigationTransition.PUSH,
+ *     create:  NavigationTransition.PUSH,
+ *     search:  NavigationTransition.PUSH,
+ *   },
+ * }
+ */
+export declare const FromOverlayConfigSchema: z.ZodObject<{
+    transitions: z.ZodType<Partial<Record<CoreResourceOperation, NavigationTransition | {
+        transition: NavigationTransition;
+        persistent?: boolean;
+        ephemeral?: boolean;
+    }>>, unknown, z.core.$ZodTypeInternals<Partial<Record<CoreResourceOperation, NavigationTransition | {
+        transition: NavigationTransition;
+        persistent?: boolean;
+        ephemeral?: boolean;
+    }>>, unknown>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type FromOverlayConfig = z.infer<typeof FromOverlayConfigSchema>;
+/**
+ * Companion-specific split geometry.
+ * Controls how the companion zone is sized and positioned relative to the main content area.
+ */
+export declare const CompanionSplitConfigSchema: z.ZodObject<{
+    ratio: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    orientation: z.ZodDefault<z.ZodEnum<typeof DisplayDirection>>;
+    resizable: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type CompanionSplitConfig = z.infer<typeof CompanionSplitConfigSchema>;
+/**
+ * Top-level split geometry — describes the physical relationship between zones.
+ *
+ * This is a top-level config (not per-zone) because it describes the INTER-zone
+ * layout: how much space each zone gets, and the split direction.
+ *
+ * @example
+ * split: {
+ *   autoSplit: true,                                    // LIST pre-splits when primary.read = NavigationTransition.SPLIT
+ *   ratio: [40, 60],                                    // 40% primary, 60% secondary
+ *   orientation: DisplayDirection.VERTICAL,              // side-by-side
+ *   resizable: true,                                     // divider is draggable
+ *   companion: {
+ *     ratio: [70, 30],                                   // companion takes 30%
+ *     orientation: DisplayDirection.HORIZONTAL,         // bottom panel
+ *     resizable: true,
+ *   },
+ * }
+ */
+export declare const SplitConfigSchema: z.ZodObject<{
+    autoSplit: z.ZodDefault<z.ZodBoolean>;
+    ratio: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    orientation: z.ZodDefault<z.ZodEnum<typeof DisplayDirection>>;
+    resizable: z.ZodDefault<z.ZodBoolean>;
+    companion: z.ZodOptional<z.ZodObject<{
+        ratio: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        orientation: z.ZodDefault<z.ZodEnum<typeof DisplayDirection>>;
+        resizable: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type SplitConfig = z.infer<typeof SplitConfigSchema>;
+/**
+ * Global viewport override — applies across ALL zones at a given breakpoint.
+ *
+ * Use for sweeping mobile/tablet overrides that affect the entire app.
+ * For per-zone responsive behavior, use `ZoneConfig.responsiveCollapse` and
+ * viewport-discriminated appearance values instead.
+ *
+ * @example
+ * // In NavigationLayout:
+ * [ViewportBreakpoint.MOBILE]: {
+ *   transitions: {
+ *     read:   NavigationTransition.PUSH,    // mobile: no splits, everything pushes
+ *     create: { transition: NavigationTransition.OVERLAY, ephemeral: true }, // mobile: create opens as an inspect-style ephemeral overlay
+ *   },
+ * }
+ */
+export declare const ViewportOverrideSchema: z.ZodObject<{
+    transitions: z.ZodOptional<z.ZodType<Partial<Record<CoreResourceOperation, NavigationTransition | {
+        transition: NavigationTransition;
+        persistent?: boolean;
+        ephemeral?: boolean;
+    }>>, unknown, z.core.$ZodTypeInternals<Partial<Record<CoreResourceOperation, NavigationTransition | {
+        transition: NavigationTransition;
+        persistent?: boolean;
+        ephemeral?: boolean;
+    }>>, unknown>>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type ViewportOverride = z.infer<typeof ViewportOverrideSchema>;
+/**
+ * The complete navigation layout configuration for an application.
+ *
+ * This is the single configuration object that defines the entire navigation
+ * behavior. It specifies which zones exist, how each zone handles operations,
+ * how zones are sized relative to each other, and global overrides.
+ *
+ * Resolution order (from highest to lowest priority):
+ * 1. Per-operation frontend override (`operation.operationFrontendConfig.navigationOverrides`)
+ * 2. Per-relationship override (`display.inParentNavigation.transition`)
+ * 3. Global viewport override (`ViewportBreakpoint.MOBILE` / `ViewportBreakpoint.VERT_TABLET` blocks)
+ * 4. Source context `transitions[operation]` + `appearance[transition]`
+ * 5. Framework hardcoded fallback
+ *
+ * @example
+ * const layout: NavigationLayout = {
+ *   zones: {
+ *     primary: { transitions: { read: NavigationTransition.SPLIT, create: NavigationTransition.OVERLAY, update: NavigationTransition.INPLACE } },
+ *     secondary: { transitions: { read: NavigationTransition.PUSH }, onEmpty: ZoneEmptyBehavior.COLLAPSE },
+ *   },
+ *   appLevel: { transitions: { list: NavigationTransition.REPLACE, create: NavigationTransition.OVERLAY } },
+ *   fromOverlay: { transitions: { read: NavigationTransition.PROMOTE } },
+ *   split: { autoSplit: true, ratio: [40, 60] },
+ *   maxDepth: 2,
+ * };
+ */
+export declare const NavigationLayoutSchema: z.ZodObject<{
+    zones: z.ZodObject<{
+        primary: z.ZodObject<{
+            contentModel: z.ZodDefault<z.ZodEnum<typeof NavigationZoneContentModel>>;
+            transitions: z.ZodType<Partial<Record<CoreResourceOperation, NavigationTransition | {
+                transition: NavigationTransition;
+                persistent?: boolean;
+                ephemeral?: boolean;
+            }>>, unknown, z.core.$ZodTypeInternals<Partial<Record<CoreResourceOperation, NavigationTransition | {
+                transition: NavigationTransition;
+                persistent?: boolean;
+                ephemeral?: boolean;
+            }>>, unknown>>;
+            appearance: z.ZodOptional<z.ZodObject<{
+                split: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof SplitAppearance>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof SplitAppearance>>]>>;
+                overlay: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof OverlayAppearance>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof OverlayAppearance>>]>>;
+            }, z.core.$strip, core.$ZodObjectExtra>>;
+            minWidth: z.ZodOptional<z.ZodNumber>;
+            maxWidth: z.ZodOptional<z.ZodNumber>;
+            defaultVisible: z.ZodOptional<z.ZodBoolean>;
+            onEmpty: z.ZodOptional<z.ZodEnum<typeof ZoneEmptyBehavior>>;
+            responsiveCollapse: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof ResponsiveCollapseMode>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof ResponsiveCollapseMode>>]>>;
+        }, z.core.$strip, core.$ZodObjectExtra>;
+        secondary: z.ZodOptional<z.ZodObject<{
+            contentModel: z.ZodDefault<z.ZodEnum<typeof NavigationZoneContentModel>>;
+            transitions: z.ZodType<Partial<Record<CoreResourceOperation, NavigationTransition | {
+                transition: NavigationTransition;
+                persistent?: boolean;
+                ephemeral?: boolean;
+            }>>, unknown, z.core.$ZodTypeInternals<Partial<Record<CoreResourceOperation, NavigationTransition | {
+                transition: NavigationTransition;
+                persistent?: boolean;
+                ephemeral?: boolean;
+            }>>, unknown>>;
+            appearance: z.ZodOptional<z.ZodObject<{
+                split: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof SplitAppearance>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof SplitAppearance>>]>>;
+                overlay: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof OverlayAppearance>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof OverlayAppearance>>]>>;
+            }, z.core.$strip, core.$ZodObjectExtra>>;
+            minWidth: z.ZodOptional<z.ZodNumber>;
+            maxWidth: z.ZodOptional<z.ZodNumber>;
+            defaultVisible: z.ZodOptional<z.ZodBoolean>;
+            onEmpty: z.ZodOptional<z.ZodEnum<typeof ZoneEmptyBehavior>>;
+            responsiveCollapse: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof ResponsiveCollapseMode>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof ResponsiveCollapseMode>>]>>;
+        }, z.core.$strip, core.$ZodObjectExtra>>;
+        companion: z.ZodOptional<z.ZodObject<{
+            contentModel: z.ZodDefault<z.ZodEnum<typeof NavigationZoneContentModel>>;
+            transitions: z.ZodType<Partial<Record<CoreResourceOperation, NavigationTransition | {
+                transition: NavigationTransition;
+                persistent?: boolean;
+                ephemeral?: boolean;
+            }>>, unknown, z.core.$ZodTypeInternals<Partial<Record<CoreResourceOperation, NavigationTransition | {
+                transition: NavigationTransition;
+                persistent?: boolean;
+                ephemeral?: boolean;
+            }>>, unknown>>;
+            appearance: z.ZodOptional<z.ZodObject<{
+                split: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof SplitAppearance>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof SplitAppearance>>]>>;
+                overlay: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof OverlayAppearance>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof OverlayAppearance>>]>>;
+            }, z.core.$strip, core.$ZodObjectExtra>>;
+            minWidth: z.ZodOptional<z.ZodNumber>;
+            maxWidth: z.ZodOptional<z.ZodNumber>;
+            defaultVisible: z.ZodOptional<z.ZodBoolean>;
+            onEmpty: z.ZodOptional<z.ZodEnum<typeof ZoneEmptyBehavior>>;
+            responsiveCollapse: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof ResponsiveCollapseMode>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof ResponsiveCollapseMode>>]>>;
+        }, z.core.$strip, core.$ZodObjectExtra>>;
+    }, z.core.$strip, core.$ZodObjectExtra>;
+    appLevel: z.ZodOptional<z.ZodObject<{
+        transitions: z.ZodType<Partial<Record<CoreResourceOperation, NavigationTransition | {
+            transition: NavigationTransition;
+            persistent?: boolean;
+            ephemeral?: boolean;
+        }>>, unknown, z.core.$ZodTypeInternals<Partial<Record<CoreResourceOperation, NavigationTransition | {
+            transition: NavigationTransition;
+            persistent?: boolean;
+            ephemeral?: boolean;
+        }>>, unknown>>;
+        appearance: z.ZodOptional<z.ZodObject<{
+            split: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof SplitAppearance>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof SplitAppearance>>]>>;
+            overlay: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof OverlayAppearance>, z.ZodRecord<z.ZodEnum<typeof ViewportBreakpoint> & z.core.$partial, z.ZodEnum<typeof OverlayAppearance>>]>>;
+        }, z.core.$strip, core.$ZodObjectExtra>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    fromOverlay: z.ZodOptional<z.ZodObject<{
+        transitions: z.ZodType<Partial<Record<CoreResourceOperation, NavigationTransition | {
+            transition: NavigationTransition;
+            persistent?: boolean;
+            ephemeral?: boolean;
+        }>>, unknown, z.core.$ZodTypeInternals<Partial<Record<CoreResourceOperation, NavigationTransition | {
+            transition: NavigationTransition;
+            persistent?: boolean;
+            ephemeral?: boolean;
+        }>>, unknown>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    split: z.ZodOptional<z.ZodObject<{
+        autoSplit: z.ZodDefault<z.ZodBoolean>;
+        ratio: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        orientation: z.ZodDefault<z.ZodEnum<typeof DisplayDirection>>;
+        resizable: z.ZodDefault<z.ZodBoolean>;
+        companion: z.ZodOptional<z.ZodObject<{
+            ratio: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            orientation: z.ZodDefault<z.ZodEnum<typeof DisplayDirection>>;
+            resizable: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip, core.$ZodObjectExtra>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    "<md": z.ZodOptional<z.ZodObject<{
+        transitions: z.ZodOptional<z.ZodType<Partial<Record<CoreResourceOperation, NavigationTransition | {
+            transition: NavigationTransition;
+            persistent?: boolean;
+            ephemeral?: boolean;
+        }>>, unknown, z.core.$ZodTypeInternals<Partial<Record<CoreResourceOperation, NavigationTransition | {
+            transition: NavigationTransition;
+            persistent?: boolean;
+            ephemeral?: boolean;
+        }>>, unknown>>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+    "<lg": z.ZodOptional<z.ZodObject<{
+        transitions: z.ZodOptional<z.ZodType<Partial<Record<CoreResourceOperation, NavigationTransition | {
+            transition: NavigationTransition;
+            persistent?: boolean;
+            ephemeral?: boolean;
+        }>>, unknown, z.core.$ZodTypeInternals<Partial<Record<CoreResourceOperation, NavigationTransition | {
+            transition: NavigationTransition;
+            persistent?: boolean;
+            ephemeral?: boolean;
+        }>>, unknown>>>;
+    }, z.core.$strip, core.$ZodObjectExtra>>;
+}, z.core.$strip, core.$ZodObjectExtra>;
+export type NavigationLayout = z.infer<typeof NavigationLayoutSchema>;
+//# sourceMappingURL=navigation.shared.schemas.d.ts.map