@wix/himalaya-cli 0.1405.0 → 0.1407.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/dev-server/src/app-config.d.ts

@@ -62,6 +62,7 @@ export interface NavigationConfig {
     site?: import("@wix/himalaya/core").SiteNavConfig;
     /** Signed release allowlist for contained browser Tier-5 `_stream` requests. */
     streamPolicy?: StreamPolicy;
+    topBarLogo?: import("@wix/himalaya/core").TopBarLogo;
     splash?: SplashConfig;
     locale?: LocaleConfig;
     backAffordance?: BackAffordanceConfig;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/dev-server/src/app-module.d.ts

@@ -227,6 +227,9 @@ export interface DerivedAppMeta {
     site?: import("@wix/himalaya/core").SiteNavConfig;
     /** Forwarded from AppConfig.navigation.streamPolicy — the signed browser stream allowlist. */
     streamPolicy?: import("@wix/himalaya/core").StreamPolicy;
+    /** Forwarded from AppConfig.navigation.topBarLogo — the app-wide logo for tab-stack roots
+     *  (RFC 0066 amendment "top-bar gap items"). */
+    topBarLogo?: import("@wix/himalaya/core").TopBarLogo;
     /** Forwarded from AppConfig.`splash` — the in-app splash surface. NOTE the
      *  asymmetry with the fields above: this reads the TOP-LEVEL `config.splash`, not
      *  `config.navigation.splash`, because the same block also drives the build-time

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/dev-server/src/wix-cache-policy.d.ts

@@ -6,11 +6,74 @@ export interface WixCacheRule {
     ttl: number;
     swr: number;
     tag: string | null;
+    queueOffline?: true;
+    /** How a resend of this write is deduplicated (§2.1). The client applies what it receives. */
+    idempotency?: OfflineIdempotency;
+    /** Seconds a queued write may wait before it is dead-lettered as `expired` (§6), already clamped. */
+    queueMaxAge?: number;
 }
+/** RFC 0072 §2.1 — how an endpoint dedupes a resend after an ambiguous attempt. */
+export type OfflineIdempotency = "header" | "clientId" | "conflictIsApplied" | "unsentOnly";
 export interface WixCachePolicy {
     rules: WixCacheRule[];
     defaultCacheable: boolean;
 }
+/** One endpoint whose writes may queue offline (§2.1): a method, ONE exact path, and the dedupe
+ *  mechanism Task 0 observed live, with the evidence. An app rule queues only when it names this
+ *  endpoint exactly — a prefix would take in its siblings (`/wix-data/v2/items` covers
+ *  `/wix-data/v2/items/bulk/remove`), whose dedupe nobody verified. */
+export interface OfflineQueueableEndpoint {
+    method: string;
+    path: string;
+    idempotency: OfflineIdempotency;
+    /** The write carries personal data even where no personal read prefix says so (§6). */
+    personal: boolean;
+    /** Where the Task 0 probe that justifies `idempotency` is recorded. */
+    evidence: string;
+}
+/** RFC 0072 §2.1 — deny-by-default: a write queues only if its endpoint is here. No row exists
+ *  until its Task 0 probe is recorded, and none assumes an endpoint honours `Idempotency-Key`. */
+export declare const OFFLINE_QUEUEABLE: readonly OfflineQueueableEndpoint[];
+/** RFC 0072 §2.1 — never queueable, whatever an app declares: money, identity, stored value and
+ *  capacity holds. `/gift-cards` and `/loyalty` have no trailing slash on purpose
+ *  (`/loyalty-accounts/v1/accounts/{id}/adjust-points`). Checked before the allow-table. */
+export declare const NEVER_QUEUEABLE_PREFIXES: readonly string[];
+/** RFC 0072 §2.1 — a path any of whose segments, split on `-`, is one of these is never queueable:
+ *  every checkout, payment, order, refund and hold route, under whatever allow prefix it sits. */
+export declare const NEVER_QUEUEABLE_TOKENS: readonly string[];
+/** RFC 0072 §6 — personal WRITES the personal-read list misses: a form submission carries a name,
+ *  an email and a phone. */
+export declare const OFFLINE_PERSONAL_WRITE_PREFIXES: readonly string[];
+/** RFC 0072 §6 (D2) — how long a queued write may wait: 7 days, or 24 hours for personal data. */
+export declare const OFFLINE_MAX_AGE: number;
+export declare const OFFLINE_PERSONAL_MAX_AGE = 86400;
+/** RFC 0072 §2.1 — whether `path` is on the never-queueable floor. Every client runs the same
+ *  check on the concrete call path (core/schema/fixtures/offline-writes/never-queueable.json). */
+export declare function isNeverQueueable(path: string): boolean;
+/** Why a declared `queueOffline` rule does not queue, as a stable code (§2.2). */
+export type OfflineQueueRefusalCode = "never_queueable" | "not_queueable" | "missing_method" | "missing_tag" | "absolute_url";
+export interface OfflineQueueRefusal {
+    code: OfflineQueueRefusalCode;
+    method: string | null;
+    pathPrefix: string;
+}
+/** Every rule of `declared` that asks to queue offline but will not, with the coded reason, so
+ *  `himalaya-dev app validate` and the dev-server can say so instead of dropping it silently. */
+export declare function offlineQueueRefusals(declared?: DeclaredWixCache, table?: readonly OfflineQueueableEndpoint[]): OfflineQueueRefusal[];
+/** RFC 0072 §2.2 — the effective queueing of one app rule:
+ *  `app_wants AND on OFFLINE_QUEUEABLE AND NOT never_queueable AND method AND tag`, with the
+ *  mechanism and the clamped max age stamped on, so no client needs the table. */
+export declare function stampOfflineQueue(rule: WixCacheRule, declared: {
+    queueOffline?: boolean;
+    queueMaxAge?: number;
+}, table?: readonly OfflineQueueableEndpoint[]): WixCacheRule;
+/** RFC 0072 §2.2 — re-vet every queue rule of a served `wixCachePolicy` against the allow-table.
+ *  An operator overlay (or an admin override) is deep-merged OVER the stamped policy, and its
+ *  `rules` array replaces the stamped one wholesale — so a rule it carries with `queueOffline`
+ *  would otherwise reach every client unchecked, with any mechanism and any max age. Here such a
+ *  rule is stamped exactly like an app's own (or stripped), so the served queueing is always the
+ *  table's. Rules without a queue key pass through untouched. */
+export declare function sanitizeServedOfflineQueue<T>(policy: T, table?: readonly OfflineQueueableEndpoint[]): T;
 /** The path a rule's prefix names: itself, or the path of an absolute `https://host/path` prefix
  *  (an account-level read a worker makes to a full Wix URL) — so the platform denies apply to it. */
 export declare function rulePath(pathPrefix: string): string;
@@ -34,4 +97,4 @@ export type DeclaredWixCache = AppCacheConfig;
  *      `defaultCacheable: true` can never make a PII path cacheable by matching nothing.
  * Everything is clamped under the platform envelope (PII denies, TTL ceiling).
  */
-export declare function resolveWixCachePolicy(appName: string, declared?: DeclaredWixCache): WixCachePolicy;
+export declare function resolveWixCachePolicy(appName: string, declared?: DeclaredWixCache, queueable?: readonly OfflineQueueableEndpoint[]): WixCachePolicy;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/sdk/wix-platform/src/index.d.ts

@@ -198,3 +198,4 @@ export declare const monitoring: {
 };
 /** Capability version, for bundles that gate on min binary version. */
 export declare const version = 2;
+export { offline, isOfflineWriteBlocked, isOfflineWriteOutcomeUnknown, type Sent, type Queued, type OfflineResult, type OfflineEvent, type OfflineEventType, type PendingWrite, type RejectedWrite, } from "./offline.js";

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/sdk/wix-platform/src/offline.d.ts

@@ -0,0 +1,66 @@
+/** The endpoint answered: `value` is what the call would have returned without the option. */
+export interface Sent<T> {
+    status: "sent";
+    value: T;
+}
+/** The write waits in the outbox; `writeId` identifies it in events, `pending()` and `rejected()`. */
+export interface Queued {
+    status: "queued";
+    writeId: string;
+    tag: string;
+}
+export type OfflineResult<T> = Sent<T> | Queued;
+export type OfflineEventType = "queued" | "applied" | "rejected";
+export interface OfflineEvent {
+    writeId: string;
+    tag: string;
+    status?: number;
+    code?: string;
+    reason?: string;
+}
+export interface PendingWrite {
+    writeId: string;
+    tag: string;
+    createdAt: number;
+    attempts: number;
+}
+export interface RejectedWrite {
+    writeId: string;
+    tag: string;
+    /** `http` | `conflict` | `expired` | `outcome_unknown` | `unauthorized`. */
+    reason: string;
+    status?: number;
+    code?: string;
+    method: string;
+    pathTemplate: string;
+    createdAt: number;
+    rejectedAt: number;
+    /** The request body, while the write has not expired: for "retry" or "copy your text". */
+    body?: string;
+}
+/** `wixApi.call` with `{ offline: "queue" }`. On a runtime without offline writes the call is a plain
+ *  live call, reported as `sent`. */
+declare function call<T>(method: string, path: string, body?: unknown, headers?: Record<string, string>): Promise<OfflineResult<T>>;
+/** The two offline errors a worker branches on (`err.code`). */
+export declare function isOfflineWriteBlocked(e: unknown): e is Error & {
+    code: "offline_write_blocked";
+    reason: string;
+};
+/** An `unsentOnly` write whose outcome is unknown: say "we couldn't confirm this went through". */
+export declare function isOfflineWriteOutcomeUnknown(e: unknown): e is Error & {
+    code: "offline_write_outcome_unknown";
+};
+export declare const offline: {
+    call: typeof call;
+    /** This scope's queued writes (no bodies). */
+    pending: (opts?: {
+        tag?: string;
+    }) => Promise<PendingWrite[]>;
+    /** This scope's rejected writes. */
+    rejected: () => Promise<RejectedWrite[]>;
+    /** Clear one rejected write. A retry is a new write with a new `writeId`. */
+    dismiss: (writeId: string) => Promise<boolean>;
+    /** `queued`, `applied` and `rejected`, delivered while this worker runs. Returns an unsubscribe. */
+    on: (type: OfflineEventType, cb: (e: OfflineEvent) => void) => (() => void);
+};
+export {};

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/ts/src/define-app.d.ts

@@ -676,6 +676,16 @@ export interface AppCacheRule {
     swr?: number;
     /** Resource family for write-through purge, e.g. "stores/products". */
     tag?: string;
+    /**
+     * RFC 0072 — let a worker queue this endpoint's writes while offline (`{ offline: "queue" }` at
+     * the call site). Default false. Takes effect only where the platform allow-table lists the
+     * endpoint (method + this exact path) and it is not a payment, identity, stored-value or hold
+     * route; `method` and `tag` are then required. The server stamps the dedupe mechanism.
+     */
+    queueOffline?: boolean;
+    /** Seconds a queued write may wait before it is dropped as expired. Clamped to 7 days, and to
+     *  24 hours for personal data. Defaults to that ceiling. */
+    queueMaxAge?: number;
 }
 export interface AppCacheConfig {
     /** Behavior for a request no rule matches. Defaults to false (deny). */

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/ts/src/schema.d.ts

@@ -2700,6 +2700,8 @@ export interface NavigationConfig {
      *  links resolve as before. Build it with `siteNavConfig()` from
      *  `@himalaya/core/site-shell`; resolution is `resolveSiteLink()`. */
     site?: SiteNavConfig;
+    /** RFC 0066 amendment "top-bar gap items" — app-wide logo for tab-stack roots. */
+    topBarLogo?: TopBarLogo;
     scheme: string;
     deepLinkPatterns: DeepLinkPattern[];
     linkableScreens: LinkableScreen[];
@@ -2903,6 +2905,86 @@ export interface TopBarConfig {
     leading?: string;
     /** Content-under-bar: "" | "opaque" (default) | "transparent" | "immersive". */
     style?: string;
+    /** RFC 0066 §1 — toolbar items (drawn after the legacy `actions`). */
+    items?: ToolbarItem[];
+    /** RFC 0066 §1 — "" / "automatic" (default) | "large" | "inline". */
+    titleDisplay?: string;
+    /** RFC 0066 §1 — the literal subtitle (the fallback for `subtitlePath`). */
+    subtitle?: string;
+    /** RFC 0066 §1 — "" / "visible" (default) | "hidden". */
+    visibility?: string;
+    /** RFC 0066 §1 — bar fill token. iOS 26 keeps the system glass (amendment R12). */
+    background?: TokenRef;
+    /** RFC 0066 amendment — the screen's logo; overrides `NavigationConfig.topBarLogo`. */
+    logo?: TopBarLogo;
+    /** RFC 0066 amendment — the title as a menu. */
+    titleMenu?: TopBarTitleMenu;
+    /** RFC 0066 amendment — live subtitle (`$service:`); `subtitle` is the fallback. */
+    subtitlePath?: string;
+    /** RFC 0066 amendment — "" / "pinned" (default) | "hide_on_scroll". */
+    scrollBehavior?: string;
+    /** RFC 0066 amendment — truthy ⇒ leaving the presentation asks to discard. Unset/unresolved ⇒ false. */
+    dirtyPath?: string;
+}
+/** RFC 0066 §1 (+ its "top-bar gap items" amendment) — one top-bar item. Test id `toolbar.<id>`
+ *  (`toolbar-<id>` on web and React Native). Every tap carries an existing `Action`
+ *  (invariant 15). Bindings are `$service:` sentinels resolved by the screen host. */
+export interface ToolbarItem {
+    id: string;
+    /** "leading" | "trailing" (default) | "principal" | "bottom" | "keyboard" | "overflow". */
+    placement?: string;
+    /** Text button when there is no icon; the accessible name always. */
+    label?: string;
+    icon?: IconRef;
+    onTap?: Action;
+    /** "" | "cancel" | "confirm" | "destructive". */
+    role?: string;
+    disabled?: boolean;
+    /** OR'd with `disabled`. For Save, bind "nothing to save" (e.g. `cannotSave`), never the dirty flag. */
+    disabledPath?: string;
+    /** Non-empty ⇒ the item opens a menu. */
+    menu?: MenuItem[];
+    /** "principal" only: a custom title view. */
+    content?: Component;
+    /** Truthy ⇒ a progress indicator replaces the item. Unset/unresolved ⇒ false. */
+    loadingPath?: string;
+    /** Set ⇒ the item draws an avatar; `label` stays the accessible name ("Profile" by default). */
+    avatar?: ToolbarAvatar;
+    /** Live label; `label` is the fallback. */
+    labelPath?: string;
+}
+/** RFC 0066 amendment — an avatar item. Images are absolute https URLs (resolve a Wix
+ *  media id with `wixMediaUrl` before publishing). */
+export interface ToolbarAvatar {
+    imageUrl?: string;
+    initials?: string;
+    imageUrlPath?: string;
+    initialsPath?: string;
+}
+/** RFC 0066 amendment — the bar logo, per screen (`TopBarConfig.logo`) or app-wide
+ *  (`NavigationConfig.topBarLogo`). `imageUrlPath` resolves by the parent's context: the
+ *  screen host per screen, the nav worker app-wide. */
+export interface TopBarLogo {
+    imageUrl?: string;
+    imageUrlDark?: string;
+    /** Baked asset name; wins over `imageUrl`. */
+    imageAsset?: string;
+    /** Optional business name beside a mark-only logo. */
+    name?: string;
+    /** "" / "title" (default) | "leading" | "none". */
+    placement?: string;
+    imageUrlPath?: string;
+    /** Default: the app's display name. */
+    accessibilityLabel?: string;
+}
+/** RFC 0066 amendment — the title as a menu (switch location or feed). */
+export interface TopBarTitleMenu {
+    items?: MenuItem[];
+    selectedId?: string;
+    /** `selectedId` is the fallback. */
+    selectedIdPath?: string;
+    /** Default "<title>, switch". */
+    accessibilityLabel?: string;
 }
 /** RFC 0010 (top-bar amendment) — one trailing top-bar action. Reuses the
  *  design-system icon name, the `NavBadge` overlay, and the same `Action`

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/ts/src/validator.d.ts

@@ -272,6 +272,181 @@ export declare const screenDescriptorSchema: {
                 readonly style: {
                     readonly type: "string";
                 };
+                readonly items: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/toolbarItem";
+                    };
+                };
+                readonly titleDisplay: {
+                    readonly type: "string";
+                };
+                readonly subtitle: {
+                    readonly type: "string";
+                };
+                readonly visibility: {
+                    readonly type: "string";
+                };
+                readonly background: {
+                    readonly $ref: "#/$defs/tokenRef";
+                };
+                readonly logo: {
+                    readonly $ref: "#/$defs/topBarLogo";
+                };
+                readonly titleMenu: {
+                    readonly $ref: "#/$defs/topBarTitleMenu";
+                };
+                readonly subtitlePath: {
+                    readonly type: "string";
+                };
+                readonly scrollBehavior: {
+                    readonly type: "string";
+                };
+                readonly dirtyPath: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly toolbarItem: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["id"];
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly placement: {
+                    readonly type: "string";
+                };
+                readonly label: {
+                    readonly type: "string";
+                };
+                readonly icon: {
+                    readonly type: "string";
+                };
+                readonly onTap: {
+                    readonly $ref: "#/$defs/action";
+                };
+                readonly role: {
+                    readonly type: "string";
+                };
+                readonly disabled: {
+                    readonly type: "boolean";
+                };
+                readonly disabledPath: {
+                    readonly type: "string";
+                };
+                readonly menu: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/topBarMenuItem";
+                    };
+                };
+                readonly content: {
+                    readonly $ref: "#/$defs/component";
+                };
+                readonly loadingPath: {
+                    readonly type: "string";
+                };
+                readonly avatar: {
+                    readonly $ref: "#/$defs/toolbarAvatar";
+                };
+                readonly labelPath: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly toolbarAvatar: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly imageUrl: {
+                    readonly type: "string";
+                };
+                readonly initials: {
+                    readonly type: "string";
+                };
+                readonly imageUrlPath: {
+                    readonly type: "string";
+                };
+                readonly initialsPath: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly topBarLogo: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly imageUrl: {
+                    readonly type: "string";
+                };
+                readonly imageUrlDark: {
+                    readonly type: "string";
+                };
+                readonly imageAsset: {
+                    readonly type: "string";
+                };
+                readonly name: {
+                    readonly type: "string";
+                };
+                readonly placement: {
+                    readonly type: "string";
+                };
+                readonly imageUrlPath: {
+                    readonly type: "string";
+                };
+                readonly accessibilityLabel: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly topBarTitleMenu: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly items: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/topBarMenuItem";
+                    };
+                };
+                readonly selectedId: {
+                    readonly type: "string";
+                };
+                readonly selectedIdPath: {
+                    readonly type: "string";
+                };
+                readonly accessibilityLabel: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly topBarMenuItem: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["id", "label"];
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly label: {
+                    readonly type: "string";
+                };
+                readonly icon: {
+                    readonly type: "string";
+                };
+                readonly destructive: {
+                    readonly type: "boolean";
+                };
+                readonly disabled: {
+                    readonly type: "boolean";
+                };
+                readonly action: {
+                    readonly $ref: "#/$defs/action";
+                };
             };
         };
         readonly topBarAction: {
@@ -1260,6 +1435,181 @@ export declare const widgetSnapshotSchema: {
                 readonly style: {
                     readonly type: "string";
                 };
+                readonly items: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/toolbarItem";
+                    };
+                };
+                readonly titleDisplay: {
+                    readonly type: "string";
+                };
+                readonly subtitle: {
+                    readonly type: "string";
+                };
+                readonly visibility: {
+                    readonly type: "string";
+                };
+                readonly background: {
+                    readonly $ref: "#/$defs/tokenRef";
+                };
+                readonly logo: {
+                    readonly $ref: "#/$defs/topBarLogo";
+                };
+                readonly titleMenu: {
+                    readonly $ref: "#/$defs/topBarTitleMenu";
+                };
+                readonly subtitlePath: {
+                    readonly type: "string";
+                };
+                readonly scrollBehavior: {
+                    readonly type: "string";
+                };
+                readonly dirtyPath: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly toolbarItem: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["id"];
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly placement: {
+                    readonly type: "string";
+                };
+                readonly label: {
+                    readonly type: "string";
+                };
+                readonly icon: {
+                    readonly type: "string";
+                };
+                readonly onTap: {
+                    readonly $ref: "#/$defs/action";
+                };
+                readonly role: {
+                    readonly type: "string";
+                };
+                readonly disabled: {
+                    readonly type: "boolean";
+                };
+                readonly disabledPath: {
+                    readonly type: "string";
+                };
+                readonly menu: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/topBarMenuItem";
+                    };
+                };
+                readonly content: {
+                    readonly $ref: "#/$defs/component";
+                };
+                readonly loadingPath: {
+                    readonly type: "string";
+                };
+                readonly avatar: {
+                    readonly $ref: "#/$defs/toolbarAvatar";
+                };
+                readonly labelPath: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly toolbarAvatar: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly imageUrl: {
+                    readonly type: "string";
+                };
+                readonly initials: {
+                    readonly type: "string";
+                };
+                readonly imageUrlPath: {
+                    readonly type: "string";
+                };
+                readonly initialsPath: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly topBarLogo: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly imageUrl: {
+                    readonly type: "string";
+                };
+                readonly imageUrlDark: {
+                    readonly type: "string";
+                };
+                readonly imageAsset: {
+                    readonly type: "string";
+                };
+                readonly name: {
+                    readonly type: "string";
+                };
+                readonly placement: {
+                    readonly type: "string";
+                };
+                readonly imageUrlPath: {
+                    readonly type: "string";
+                };
+                readonly accessibilityLabel: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly topBarTitleMenu: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly items: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/topBarMenuItem";
+                    };
+                };
+                readonly selectedId: {
+                    readonly type: "string";
+                };
+                readonly selectedIdPath: {
+                    readonly type: "string";
+                };
+                readonly accessibilityLabel: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly topBarMenuItem: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["id", "label"];
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly label: {
+                    readonly type: "string";
+                };
+                readonly icon: {
+                    readonly type: "string";
+                };
+                readonly destructive: {
+                    readonly type: "boolean";
+                };
+                readonly disabled: {
+                    readonly type: "boolean";
+                };
+                readonly action: {
+                    readonly $ref: "#/$defs/action";
+                };
             };
         };
         readonly topBarAction: {