import { TSchema, Static } from '@sinclair/typebox';
export { Kind, Static, TArray, TObject, TProperties, TRecord, TSchema, TUnion, Type, TypeGuard } from '@sinclair/typebox';
import * as value from '@sinclair/typebox/value';
export { value as Value };
import { S as SerializableRequest, U as UploadProgress, a as SerializableResponse, R as Routes, E as ExtractRequestBody, b as ExtractResponseBody, c as ServerToClientMessage, N as NoyaManager, d as SyncOptionsBase, e as SyncURLOption, f as SyncConfig, C as ClientToServerMessage, P as ParentToEmbeddedMessage, g as ServerScriptManagerOptions, h as SyncAdapter, i as ParentFrameSyncOptions, A as AssetStoreIndexedDB, j as StoreAsset, k as ExtendedPatch, W as WebSocketSyncOptions, l as SimplePatch, H as HistoryEntry, m as ExtendedPathKey, D as DrainInputQueueOptions, I as InputQueueItem, n as AssetManager } from './ActivityEventsManager-CGLeq_mC.mjs';
export { o as AIGenerateImage, aa as AIGenerateImageOptions, p as AIGenerateImageRequest, q as AIGenerateImageResponse, a8 as AIGenerateObjectOptions, r as AIGenerateRequest, s as AIGenerateResponse, a9 as AIGenerateTextOptions, t as AIGenerateTextRequest, u as AIGenerateTextResponse, ab as AIGeneratedImage, a7 as AIImageInput, ac as AIManager, a4 as AIToolDefinition, a6 as AIToolInvocation, bl as AccessPolicy, cm as AccessType, ce as ActionHandler, a3 as ActivityEventsManager, O as AdapterHandlers, ai as AssetStoreMemory, aj as AssetStoreRemote, cu as AssetTranscriptionResult, ad as AssetUploadProgress, $ as AvoidRect, aI as BranchInfo, a5 as CallableAIToolsMap, aW as ClientCommit, aX as ClientConnectionStatus, ak as ConnectionEvent, al as ConnectionEventManager, Q as ConnectionMessage, ae as CreateAssetOptions, bv as CreateMutatorParameters, aN as CreateParams, b6 as DefaultSharedConnectionData, co as Destructor, a0 as EmbeddedToParentMessage, ap as EvalManager, am as EvalRequest, an as EvalResponse, bX as EvaluateScriptFilesOptions, bV as EvaluateScriptOptions, bW as EvaluateScriptUrlOptions, bT as ExecResult, aC as FilePropertyManager, aB as FilePropertyManagerOptions, aG as GitFileCommittedMessage, G as GitFileCreateOperation, v as GitFileDeleteOperation, aE as GitFileEditHandle, aD as GitFileEditServerMessage, aF as GitFileEditSession, w as GitFileInfo, x as GitFilePatchRequestBody, y as GitFilePatchResponseBody, z as GitFileRenameOperation, aM as GitManager, aL as GitManagerOptions, aH as GitRepo, cf as HistorySnapshot, ag as IAssetStore, aO as IOManager, aS as LogManager, aR as LogManagerOptions, b8 as MULTIPLAYER_POLICY_METADATA_KEY, aT as MenuManager, aV as MultiplayerPatchMetadata, bb as MultiplayerPolicyAction, bd as MultiplayerPolicyDefinition, bc as MultiplayerPolicyLet, b3 as MultiplayerStateManager, b0 as MultiplayerStateManagerError, a$ as MultiplayerStateManagerErrorType, b1 as MultiplayerStateManagerMode, b2 as MultiplayerStateManagerOptions, cl as MultiplayerUser, ah as NoyaAsset, bs as NoyaManagerOptions, cj as OperationManager, a1 as ParentFrameMessageHandler, by as PipelineManager, a_ as PipelineStatus, be as PolicyAuthContext, bo as PolicyViolation, bz as PublishCallback, bA as PublishingManager, c3 as QuickJSContextLike, c2 as QuickJSHandleLike, c6 as QuickJSModuleFactory, c5 as QuickJSModuleLike, c4 as QuickJSRuntimeLike, bM as RPCErrorResponse, bP as RPCManager, bH as RPCRequestPayload, bO as RPCResponseMessage, bI as RPCResponsePayload, bN as RPCStatus, bK as RPCStreamChunkResponse, bL as RPCStreamEndResponse, bJ as RPCSuccessResponse, T as ReconnectingWebSocket, X as ReconnectingWebSocketState, aY as RejectInitReason, aZ as RejectPatchReason, aJ as RepoFilesFetchState, aK as RepoFilesState, bC as ResourceEditHandle, bB as ResourceEditServerMessage, bD as ResourceEditSession, bF as ResourceManager, bE as ResourceManagerOptions, B as RouteDefinition, F as RouteKey, b9 as SERVER_COMPUTED_METADATA_KEY, ba as SERVER_SCRIPTS_METADATA_KEY, ao as SafeEval, bU as SandboxManager, bQ as SandboxPhase, bR as SandboxState, bZ as ScriptEvaluationError, bY as ScriptEvaluationResult, J as ScriptEvaluatorFile, b_ as ScriptEvaluatorManager, K as ScriptEvaluatorRequest, L as ScriptEvaluatorResponse, b$ as Secret, c1 as SecretManager, c0 as SecretManagerOptions, b5 as SelectionRange, bk as ServerComputed, bi as ServerComputedDefinition, bf as ServerComputedEvent, bg as ServerComputedTarget, bh as ServerComputedValueFactory, bj as ServerScriptDefinition, c9 as ServerScriptEnvironment, aQ as ServerScriptLogEntry, ca as ServerScriptLogEvent, aP as ServerScriptLogLevel, cd as ServerScriptManager, c8 as ServerScriptMode, cb as ServerScriptRuntimeBindings, c7 as ServerScriptTarget, bm as ServerScripts, b7 as SharedConnectionDataManager, b4 as SharedConnectionMetadata, as as SimplePatchWithStringPath, ck as StateManager, cg as StateManagerOptions, a2 as StreamFilter, cp as SyncAdapterOptions, cr as Task, bw as TaskArtifact, cq as TaskManager, bx as TaskMetadata, cn as TokenPayload, cs as TranscribeOptions, cv as TranscriptionManager, ct as TranscriptionResult, bG as TypedBody, af as UpdateAssetOptions, V as UserActivityDetector, cy as UserManager, M as WorkspaceMemberUser, ar as apply, ay as applyExtendedPatch, aq as applyPatchToString, bq as applyServerComputedMetadata, Y as createDefaultMessageHandler, ch as createEditHistoryEntry, aA as createExtended, aU as createHash, bS as createInitialSandboxState, bu as createMutatorParametersSchema, ci as createPatchHistoryEntry, bt as defaultMergeHistoryEntries, bp as enforceMultiplayerPolicies, at as extractItemId, br as filterStateForReadAccess, cx as findNoyaUser, bn as getServerScriptDefinitions, Z as isEmbeddedToParentMessage, _ as isParentToEmbeddedMessage, cw as requestTranscription, cc as serializeServerScriptLogValue, aw as toExtendedPatch, az as toExtendedPatches, au as toExtendedPathKey, ax as toSimplePatch, av as toSimplePath } from './ActivityEventsManager-CGLeq_mC.mjs';
import { Resource, SchemaDefsOrReferences } from '@noya-app/noya-schemas';
import { StorageAdapter as StorageAdapter$1 } from '@noya-app/git-remote';
import { Observable } from '@noya-app/observable';
import { ConnectionEvent, WebSocketConnection } from '@noya-app/noya-multiplayer-react';
import { GitInterface, StorageAdapter } from '@noya-app/git-remote/git';
export { CreateGitInterfaceOptions, GitInterface, StorageAdapter } from '@noya-app/git-remote/git';
import * as tree_visit_lib_types from 'tree-visit/lib/types';
import * as tree_visit from 'tree-visit';
import { MenuItem, SelectableMenuItem } from '@noya-app/noya-designsystem';
import '@noya-app/emitter';
import '@noya-app/noya-utils';
import '@noya-app/task-runner';
import 'mutative';
import '@noya-app/noya-pipeline';
import 'mutative/dist/interface.js';

declare const clientId$: Observable<string | undefined>;
declare const clientName$: Observable<string | undefined>;
declare const clientImage$: Observable<string | undefined>;
declare function setClientName(name: string | undefined): void;
declare function setClientId(id: string | undefined): void;
declare function setClientImage(image: string | undefined): void;

type RPCRequest<K extends keyof Routes> = {
    id: string;
    route: K;
    body: ExtractRequestBody<K>;
};
type RPCResponse<K extends keyof Routes> = {
    id: string;
    route: K;
    body: ExtractResponseBody<K>;
};
type RPCError = {
    id: string;
    error: string;
};
type RPCStreamChunk = {
    id: string;
    chunk: string;
};
type RPCStreamEnd<K extends keyof Routes> = {
    id: string;
    route: K;
    body: ExtractResponseBody<K>;
};
type RPCFetchOptions = {
    baseUrl: string;
    token?: string;
    streaming?: boolean;
    debug?: boolean;
    onUploadProgress?: (progress: UploadProgress) => void;
};
type RPCManagerMessage = {
    id: string;
    type: "end";
    response: SerializableResponse;
} | {
    id: string;
    type: "chunk";
    chunk: string;
} | {
    id: string;
    type: "error";
    error: string;
};
declare function fetchRPCStream(request: SerializableRequest, options: RPCFetchOptions): AsyncGenerator<RPCManagerMessage>;
declare function fetchRPC(request: SerializableRequest, options: RPCFetchOptions): Promise<RPCManagerMessage>;

/**
 * Get sync configuration from options
 */
declare function getSyncConfig(options: SyncOptionsBase | SyncURLOption): Promise<SyncConfig>;
/**
 * Handle adapter messages by updating the appropriate managers
 */
declare function handleAdapterMessage<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any> = Record<string, unknown>>(message: ServerToClientMessage<S>, noyaManager: NoyaManager<S, M, E, MenuT, I>): void;
/**
 * Apply a server-to-client message to the NoyaManager by updating adapter-managed
 * subsystems (assets, resources, secrets, etc.) and enqueuing the message into
 * the MultiplayerStateManager for state updates.
 */
declare function applyServerMessage<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any> = Record<string, unknown>>(message: ServerToClientMessage<S>, noyaManager: NoyaManager<S, M, E, MenuT, I>, options?: {
    pushToMSM?: boolean;
}): void;

type EmbeddedRemoteConnectionOptions = {
    url: SyncURLOption;
    debug?: boolean;
};
type EmbeddedRemoteConnection<S> = {
    sendMessage: (message: ClientToServerMessage<S>) => void;
    destroy: () => void;
};
type EmbeddedRemoteConnectionDependencies<S> = {
    getSyncConfig?: typeof getSyncConfig;
    createWebSocketConnection?: (url: URL, options?: {
        debug?: boolean;
        onConnectionEvent?: (event: ConnectionEvent<S>) => void;
    }) => WebSocketConnection<S>;
    fetchRPC?: typeof fetchRPC;
    fetchRPCStream?: typeof fetchRPCStream;
    applyServerMessage?: typeof applyServerMessage;
};
/**
 * Minimal remote connection used by the embedded host to proxy child messages
 * directly to the multiplayer server without routing through the parent's MSM.
 */
declare function createEmbeddedRemoteConnection<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any> = Record<string, unknown>>(noyaManager: NoyaManager<S, M, E, MenuT, I>, { url, debug }: EmbeddedRemoteConnectionOptions, dependencies?: EmbeddedRemoteConnectionDependencies<S>): EmbeddedRemoteConnection<S>;

/**
 * Parent-frame multiplayer router for embedded apps.
 *
 * Decides how to handle a child iframe's multiplayer message:
 * - Remote active: forward via parent's MSM → adapter sends to server
 * - Offline/demo: apply against localStorage and echo the server-style response
 *
 * For a full overview of how embedded parent helpers compose together,
 * see `createEmbeddedHost` in `embeddedHost.ts`.
 */

type RouteEmbeddedMultiplayerOptions<S> = {
    /**
     * When true, forwards through the active sync adapter (e.g., websocket).
     * When false, falls back to localStorage processing.
     */
    isRemoteActive: boolean;
    /**
     * Optional remote sender used to forward child messages directly to the server.
     * Required when isRemoteActive=true.
     */
    sendRemoteMessage?: (message: ClientToServerMessage<S>) => void;
    /**
     * Local storage key for demo/offline mode. Required when isRemoteActive=false.
     */
    localStorageKey?: string;
    /**
     * Sends a message from parent to child frame.
     */
    sendToChild: (message: ParentToEmbeddedMessage<S>) => void;
};
/**
 * Route a child "multiplayer.message" to either the active sync adapter
 * (remote) or to localStorage (demo/offline), and forward any server-to-client
 * responses to the child.
 */
declare function routeEmbeddedMultiplayerMessage<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any> = Record<string, unknown>>(noyaManager: NoyaManager<S, M, E, MenuT, I>, payload: ClientToServerMessage<S>, { isRemoteActive, sendRemoteMessage, localStorageKey, sendToChild, }: RouteEmbeddedMultiplayerOptions<S>): Promise<void>;

/**
 * Embedded Host (Parent) — Overview
 *
 * This module provides `createEmbeddedHost`, a small controller that wires the
 * parent frame to an embedded child app. It composes a set of helpers so the
 * parent does not need to re-implement transport, routing, or RPC bridging.
 *
 * How it fits together
 * - Child uses `parentFrameSync` (auto-selected by `isEmbeddedApp`) and sends:
 *   - multiplayer messages (init/patch/shared...) → parent
 *   - rpc requests → parent
 *   - receives: connection events, server-to-client messages, rpc responses
 *
 * - Parent composes these helpers:
 *   - `webSocketSync` — activates remote sync when a multiplayer URL is present
 *   - `forwardConnectionEventsToChild` — forwards connection state and all
 *     server-to-client messages to the child
 *   - `routeEmbeddedMultiplayerMessage` — routes child multiplayer messages to
 *     either the active remote sync (MSM) or to local storage (demo/offline)
 *   - `bridgeRpcRequestToNetwork` — proxies child RPC to HTTP/stream and emits
 *     `chunk`, `end`, `error` messages to the child
 *   - `processLocalStorageMessage` — offline “server” that returns server-style
 *     messages for init/patch when operating locally
 *   - `applyServerMessage` — applies server-to-client messages to the parent
 *     manager and enqueues MultiplayerStateManager updates
 *   - `getOfflineStorageKey` — computes a stable local key for demo/offline
 *
 * Typical usage
 *
 *   const host = createEmbeddedHost(noyaManager, {
 *     multiplayerUrl,                     // undefined for offline/demo
 *     offlineStorageKey: getOfflineStorageKey(fileId),
 *     sendToChild: (message) => postMessageToChild(message),
 *     debug: false,
 *   });
 *
 *   // From child → parent (multiplayer)
 *   host.handleChildMultiplayer(payload);
 *
 *   // From child → parent (RPC)
 *   await host.bridgeChildRpc(request, { baseUrl, token, debug });
 *
 *   // Cleanup
 *   host.destroy();
 */

type RouteFn<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any>> = (noyaManager: NoyaManager<S, M, E, MenuT, I>, payload: ClientToServerMessage<S>, options: RouteEmbeddedMultiplayerOptions<S>) => void;
type EmbeddedHostDependencies<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any>> = {
    createRemoteConnection?: typeof createEmbeddedRemoteConnection;
    routeEmbeddedMultiplayerMessage?: RouteFn<S, M, E, MenuT, I>;
};
type EmbeddedHostOptions<S> = {
    multiplayerUrl?: string;
    offlineStorageKey: string;
    /** Sends a message to the child iframe */
    sendToChild: (message: ParentToEmbeddedMessage<S>) => void;
    /** Optional debug flag passed to sync adapter */
    debug?: boolean;
};
type EmbeddedHost<S> = {
    destroy: () => void;
    /** Route a child multiplayer message through remote or local paths */
    handleChildMultiplayer: (payload: ClientToServerMessage<S>) => void;
    /** Bridge a child RPC request to the network and emit responses to child */
    bridgeChildRpc: (request: SerializableRequest, config?: {
        baseUrl: string;
        token: string;
        debug?: boolean;
    }) => Promise<void>;
};
/**
 * Create a minimal embedded host controller that composes the parent helpers.
 *
 * - Initializes websocket sync when a multiplayer URL is present.
 * - Forwards connection events and server messages to the child.
 * - Routes child multiplayer messages to remote or local paths.
 * - Bridges child RPC requests over HTTP/stream and replies to the child.
 */
declare function createEmbeddedHost<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any> = Record<string, unknown>>(noyaManager: NoyaManager<S, M, E, MenuT, I>, options: EmbeddedHostOptions<S>, dependencies?: EmbeddedHostDependencies<S, M, E, MenuT, I>): EmbeddedHost<S>;

type LocalGitFileEditorOptions = {
    getGit: () => Promise<GitInterface>;
    sendMessage: (message: ServerToClientMessage<any>) => void;
    onPersistNeeded?: (repoId: string, ref: string, filePath: string) => void;
};
/**
 * A simple local git file editor that handles file editing without
 * multiplayer complexity. Since there's only one local client,
 * we can directly apply patches without conflict resolution.
 */
declare class LocalGitFileEditor {
    private options;
    private files;
    constructor(options: LocalGitFileEditorOptions);
    handleMessage(message: ClientToServerMessage<any>): Promise<boolean>;
    private open;
    private close;
    private patch;
    /**
     * Get the current content of a file being edited.
     * Returns undefined if the file is not open.
     */
    getContent(repoId: string, filePath: string, ref: string): string | undefined;
    /**
     * Check if a file has unsaved changes.
     */
    isDirty(repoId: string, filePath: string, ref: string): boolean;
    /**
     * Persist the file to git by committing it.
     * Returns the new commit OID if successful.
     */
    persist(repoId: string, filePath: string, ref: string): Promise<{
        oid: string;
    } | undefined>;
    /**
     * Get all files that have unsaved changes.
     */
    getDirtyFiles(): Array<{
        repoId: string;
        ref: string;
        filePath: string;
    }>;
}

type LocalStorageMigrationOptions<S> = {
    fromVersion: number;
    toVersion: number;
    currentState: S;
    newSchema: TSchema;
};
type ProcessLocalStorageMessageOptions<S> = {
    onSchemaMigration?: (options: LocalStorageMigrationOptions<S>) => Promise<S | undefined> | S | undefined;
};
/**
 * A small helper that processes ClientToServer multiplayer messages
 * against localStorage and returns the ServerToClient reply.
 *
 * This mirrors the behavior of localStorageSync so callers can reuse logic
 * (e.g. embedded parent frames handling child messages).
 */
declare function processLocalStorageMessage<S>(key: string, message: ClientToServerMessage<S>, options?: ProcessLocalStorageMessageOptions<S>): Promise<ServerToClientMessage<S> | null>;

type LocalStorageSyncOptions = {
    key: string;
    serverScripts?: Pick<ServerScriptManagerOptions, "getQuickJSModule" | "randomUUID">;
    identity?: {
        userId?: string;
        name?: string | null;
        image?: string | null;
        clientId?: string;
    };
    /**
     * Optional factory function that returns a git interface for handling git RPC calls locally.
     * If not provided, git routes will not be available.
     *
     * The factory receives a StorageAdapter that persists git bundles as assets.
     * Using a factory function allows for dynamic imports:
     *
     * ```ts
     * localStorageSync({
     *   key: "my-key",
     *   git: async (storageAdapter) => {
     *     const { createGitInterface } = await import("@noya-app/git-remote/git");
     *     return createGitInterface({ storageAdapter });
     *   },
     * });
     * ```
     */
    git?: (storageAdapter: StorageAdapter) => Promise<GitInterface>;
};
declare function localStorageSync<S, M extends object, E extends object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>>(options: LocalStorageSyncOptions): SyncAdapter<S, M, E, MenuT, I>;
declare function populateLocalStorageSync(entries: [fileId: string, document: string][]): void;

/**
 * Compute a stable offline storage key to use for local/demo mode.
 *
 * Defaults to `"noya-local"` when no fileId is provided. A custom namespace
 * can be supplied to avoid collisions across app contexts.
 */
declare function getOfflineStorageKey(fileId?: string, namespace?: string): string;

/**
 * Subscribe to parent-side connection events and forward child-facing messages.
 * - stateChange → { type: "connection", state: "connected" | "disconnected" }
 * - receive → forwards the original server message to the child
 */
declare function forwardConnectionEventsToChild<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any> = Record<string, unknown>>(noyaManager: NoyaManager<S, M, E, MenuT, I>, send: (message: ParentToEmbeddedMessage<S>) => void): () => void;

declare function parentFrameSync<S, M extends object, E extends object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>>(options?: ParentFrameSyncOptions): SyncAdapter<S, M, E, MenuT, I>;

type LocalResourceStore = {
    list: () => Promise<Resource[]>;
    read: (id: string) => Promise<Resource | null>;
    create: (resource: Resource) => Promise<Resource>;
    update: (id: string, resource: Resource) => Promise<Resource | null>;
    delete: (id: string) => Promise<Resource | null>;
    replaceAll: (resources: Resource[]) => Promise<void>;
    runExclusive: <T>(callback: () => Promise<T>) => Promise<T>;
};
/**
 * Ensure assets are persisted locally when operating without a server.
 * Falls back to in-memory store if IndexedDB is not available.
 */
declare function ensureLocalAssetStore<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any> = Record<string, unknown>>(noyaManager: NoyaManager<S, M, E, MenuT, I>, offlineStorageKey?: string): AssetStoreIndexedDB | undefined;
/**
 * Ensure resources are persisted locally when operating without a server.
 * Falls back to an in-memory store if IndexedDB is unavailable.
 */
declare function ensureLocalResourceStore<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any> = Record<string, unknown>>(noyaManager: NoyaManager<S, M, E, MenuT, I>, offlineStorageKey?: string): LocalResourceStore;
/**
 * Proactively send initialization messages to a child for local/offline mode.
 */
declare function sendLocalInitializationMessages<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any> = Record<string, unknown>>(noyaManager: NoyaManager<S, M, E, MenuT, I>, send: (message: any) => void, options: {
    offlineStorageKey: string;
}): void;

/**
 * Ensure assets are persisted locally when operating without a server.
 * Falls back to in-memory store if IndexedDB is not available.
 */
/**
 * Attempt to handle local asset/resource RPC routes and send a response to the child.
 * Returns true if the request was handled, false to allow other handlers.
 */
declare function bridgeRpcRequestToLocalAssets<S, M extends object, E extends object, MenuT extends string, I extends Record<string, any> = Record<string, unknown>>(noyaManager: NoyaManager<S, M, E, MenuT, I>, request: SerializableRequest, send: (message: ParentToEmbeddedMessage<S>) => void, options: {
    offlineStorageKey: string;
}): Promise<boolean>;

type ParentRpcBridgeOptions = {
    baseUrl: string;
    token: string;
    debug?: boolean;
};
/**
 * Bridge a child-frame RPC request to the network and emit parent-frame messages
 * back to the child using ParentToEmbeddedMessage envelope.
 */
declare function bridgeRpcRequestToNetwork<S = unknown>(request: SerializableRequest, { baseUrl, token, debug }: ParentRpcBridgeOptions, send: (message: ParentToEmbeddedMessage<S>) => void): Promise<void>;

type StubSyncOptions = {
    initialStoreAssetsForDebugging?: StoreAsset[];
    debugOptions?: {
        DEBUG_acceptSamePatchTwice?: boolean;
        transformPatches?: (patches: ExtendedPatch[]) => ExtendedPatch[];
    };
};
declare function stubSync<S, M extends object, E extends object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>>(options?: StubSyncOptions): SyncAdapter<S, M, E, MenuT, I>;

type CreateWebSocketConnection<S> = (url: URL, options?: {
    debug?: boolean;
    onConnectionEvent?: (event: ConnectionEvent<S>) => void;
}) => WebSocketConnection<S>;
type WebSocketSyncDependencies<S> = {
    createWebSocketConnection?: CreateWebSocketConnection<S>;
};
declare function webSocketSync<S, M extends object, E extends object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>>(options: WebSocketSyncOptions, dependencies?: WebSocketSyncDependencies<S>): SyncAdapter<S, M, E, MenuT, I>;

declare function checkType<S>(state: S, schema: TSchema | undefined, defs: SchemaDefsOrReferences, { debug, }?: {
    debug?: boolean;
}): S;
declare function checkTypeSafe(...args: Parameters<typeof checkType>): boolean;
declare function createOrCastValue<T extends TSchema>({ schema, value, defs, }: {
    schema: T;
    value?: unknown;
    defs: SchemaDefsOrReferences;
}): Static<T>;

declare const GIT_BUNDLE_CONTENT_TYPE = "application/x-git-bundle";

declare function diffString(original: string, updated: string): SimplePatch[];
declare function diff(original: any, updated: any, { useExtendedPatches }?: {
    useExtendedPatches?: boolean | undefined;
}): [ExtendedPatch[], ExtendedPatch[]];

type EditOptions = {
    patches: ExtendedPatch[];
    inversePatches?: ExtendedPatch[];
};
declare function addPathPrefixToEditOptions(editOptions: EditOptions, path: string[]): EditOptions;

declare namespace HistoryEntries {
    function merge<S, M = void>(parameters: {
        previous: HistoryEntry<S, M>;
        next: HistoryEntry<S, M>;
        mergeMetadata?: (parameters: {
            previous: M;
            next: M;
        }) => M;
    }): HistoryEntry<S, M>;
    function mergeOperations(parameters: {
        previous: ExtendedPatch;
        next: ExtendedPatch;
    }): ExtendedPatch | "conflict" | "ok";
    function compactPatches(patches: ExtendedPatch[]): ExtendedPatch[];
    function pathsEqual(a: ExtendedPathKey[], b: ExtendedPathKey[]): boolean;
}

declare const MAX_INPUT_QUEUE_LENGTH = 100;
type StoredInputQueueEntry = {
    id: string;
    queue: string;
    payload: unknown;
    enqueuedAt: number;
};
type InputQueueStore = Map<string, Map<string, StoredInputQueueEntry[]>>;
type EnqueueOptions = {
    store: InputQueueStore;
    connectionId: string;
    queue: string;
    payload: unknown;
    onQueueActivity?: (queueName: string) => void;
};
declare function enqueueInput({ store, connectionId, queue, payload, onQueueActivity, }: EnqueueOptions): void;
declare function drainInputQueue(store: InputQueueStore, options?: DrainInputQueueOptions): InputQueueItem[];
declare function clearConnectionQueue(store: InputQueueStore, connectionId: string): void;

declare function isEmbeddedApp(): boolean;

type JwtHeader = {
    alg: string;
    typ: string;
};
declare function createJwt<P extends Record<string, unknown>, H extends JwtHeader = JwtHeader>({ payload, secret, header, }: {
    payload: P;
    secret: string;
    header?: H;
}): Promise<string>;
declare function decodeJwt<P extends Record<string, unknown>, H extends JwtHeader = JwtHeader>({ token, secret, }: {
    token: string;
    secret?: string;
}): Promise<{
    header: H;
    payload: P;
    valid: boolean;
}>;
declare namespace jwt {
    const encode: typeof createJwt;
    const decode: typeof decodeJwt;
    const ERROR: {
        INVALID_JWT_FORMAT: string;
    };
    const DEFAULT_HEADER: JwtHeader;
}

/**
 * A StorageAdapter that stores git bundles as assets using the AssetManager.
 * This is used for local/offline git storage in localStorageSync.
 */
declare class LocalAssetStorageAdapter implements StorageAdapter$1 {
    private assetManager;
    constructor(assetManager: AssetManager);
    initialize(): Promise<void>;
    private findBundleAsset;
    readBundle(id: string): Promise<Uint8Array | null>;
    writeBundle(id: string, data: Uint8Array): Promise<void>;
    listBundleIds(): Promise<string[]>;
    deleteBundle(id: string): Promise<void>;
}

declare function createPipelineRunRequest(): SerializableRequest;
declare function createSecretRequest(name: string, value: string): SerializableRequest;
declare function deleteSecretRequest(name: string): SerializableRequest;

type GetNow = () => number;
type InterpolationSample<S> = {
    state: S;
    timestamp: number;
    invocation?: number;
};
type PredictionSample<S> = {
    state: S;
    timestamp?: number;
    invocation?: number;
};
type StateInterpolatorOptions<S> = {
    /**
     * Returns the current time in milliseconds
     */
    getNow?: GetNow;
    /**
     * How far behind real time the renderer should target
     */
    interpolationDelayMs?: number;
    /**
     * How long to keep history entries used for interpolation
     */
    historyWindowMs?: number;
    /**
     * Maximum number of history entries
     */
    maxHistoryEntries?: number;
    /**
     * Maximum blend factor to apply when lightly blending toward a predicted state
     */
    maxPredictionBlend?: number;
    /**
     * Default timestamp offset to assume for predictions when none is provided
     */
    defaultPredictionDelayMs?: number;
    /**
     * Retrieve the latest server invocation, used for gating prediction blending
     */
    getLatestInvocation?: () => number | undefined;
    /**
     * Domain-specific interpolation function
     */
    interpolate: (previous: S, next: S, t: number) => S;
};
declare class StateInterpolator<S> {
    private history;
    private prediction?;
    private options;
    constructor(initial: InterpolationSample<S>, options: StateInterpolatorOptions<S>);
    getLatestEntry(): InterpolationSample<S> | undefined;
    getHistory(): InterpolationSample<S>[];
    setPrediction(prediction: PredictionSample<S> | undefined): void;
    clearPrediction(): void;
    addConfirmedState(state: S, options?: {
        timestamp?: number;
        invocation?: number;
        resetHistory?: boolean;
    }): void;
    getRenderState(now?: number): S;
}

declare function createValue<T extends TSchema>(schema: T, defs?: SchemaDefsOrReferences): Static<T>;
declare function castValue<T extends TSchema>(schema: T, defs: SchemaDefsOrReferences | undefined, value: unknown): Static<T>;

declare const MenuItemTree: {
    appliedOptions: {};
    _getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
    getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
    baseOptions: tree_visit.BaseOptions<MenuItem<string>>;
    mergeOptions: <O extends Record<string, any>>(options: O) => tree_visit.BaseOptions<MenuItem<string>> & O;
    withOptions: <NewOptions extends Partial<{
        getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
    } & {
        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
    }>>(newOptions: NewOptions) => {
        appliedOptions: {} & NewOptions;
        _getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
        getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
        baseOptions: tree_visit.BaseOptions<MenuItem<string>>;
        mergeOptions: <O extends Record<string, any>>(options: O) => tree_visit.BaseOptions<MenuItem<string>> & NewOptions & O;
        withOptions: <NewOptions_1 extends Partial<{
            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
        } & {
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
        }>>(newOptions: NewOptions_1) => {
            appliedOptions: {} & NewOptions & NewOptions_1;
            _getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
            getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
            baseOptions: tree_visit.BaseOptions<MenuItem<string>>;
            mergeOptions: <O extends Record<string, any>>(options: O) => tree_visit.BaseOptions<MenuItem<string>> & NewOptions & NewOptions_1 & O;
            withOptions: <NewOptions_2 extends Partial<{
                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
            } & {
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            }>>(newOptions: NewOptions_2) => {
                appliedOptions: {} & NewOptions & NewOptions_1 & NewOptions_2;
                _getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                baseOptions: tree_visit.BaseOptions<MenuItem<string>>;
                mergeOptions: <O extends Record<string, any>>(options: O) => tree_visit.BaseOptions<MenuItem<string>> & NewOptions & NewOptions_1 & NewOptions_2 & O;
                withOptions: <NewOptions_3 extends Partial<{
                    getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                } & {
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                }>>(newOptions: NewOptions_3) => {
                    appliedOptions: {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3;
                    _getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                    getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                    baseOptions: tree_visit.BaseOptions<MenuItem<string>>;
                    mergeOptions: <O extends Record<string, any>>(options: O) => tree_visit.BaseOptions<MenuItem<string>> & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & O;
                    withOptions: <NewOptions_4 extends Partial<{
                        getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                    } & {
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    }>>(newOptions: NewOptions_4) => {
                        appliedOptions: {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4;
                        _getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                        getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                        baseOptions: tree_visit.BaseOptions<MenuItem<string>>;
                        mergeOptions: <O extends Record<string, any>>(options: O) => tree_visit.BaseOptions<MenuItem<string>> & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & O;
                        withOptions: <NewOptions_5 extends Partial<{
                            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                        } & {
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        }>>(newOptions: NewOptions_5) => {
                            appliedOptions: {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5;
                            _getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                            getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                            baseOptions: tree_visit.BaseOptions<MenuItem<string>>;
                            mergeOptions: <O extends Record<string, any>>(options: O) => tree_visit.BaseOptions<MenuItem<string>> & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & O;
                            withOptions: <NewOptions_6 extends Partial<{
                                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                            } & {
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            }>>(newOptions: NewOptions_6) => {
                                appliedOptions: {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6;
                                _getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                                getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                                baseOptions: tree_visit.BaseOptions<MenuItem<string>>;
                                mergeOptions: <O extends Record<string, any>>(options: O) => tree_visit.BaseOptions<MenuItem<string>> & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & O;
                                withOptions: <NewOptions_7 extends Partial<{
                                    getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                } & {
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                }>>(newOptions: NewOptions_7) => {
                                    appliedOptions: {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7;
                                    _getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                                    getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                                    baseOptions: tree_visit.BaseOptions<MenuItem<string>>;
                                    mergeOptions: <O extends Record<string, any>>(options: O) => tree_visit.BaseOptions<MenuItem<string>> & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & O;
                                    withOptions: <NewOptions_8 extends Partial<{
                                        getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                    } & {
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    }>>(newOptions: NewOptions_8) => {
                                        appliedOptions: {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8;
                                        _getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                                        getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                                        baseOptions: tree_visit.BaseOptions<MenuItem<string>>;
                                        mergeOptions: <O extends Record<string, any>>(options: O) => tree_visit.BaseOptions<MenuItem<string>> & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & O;
                                        withOptions: <NewOptions_9 extends Partial<{
                                            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                        } & {
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        }>>(newOptions: NewOptions_9) => {
                                            appliedOptions: {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9;
                                            _getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                                            getChildren: (node: MenuItem<string>, indexPath: tree_visit.IndexPath, context?: tree_visit.TraversalContext<MenuItem<string>> | undefined) => MenuItem<string>[];
                                            baseOptions: tree_visit.BaseOptions<MenuItem<string>>;
                                            mergeOptions: <O extends Record<string, any>>(options: O) => tree_visit.BaseOptions<MenuItem<string>> & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9 & O;
                                            withOptions: <NewOptions_10 extends Partial<{
                                                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                            } & {
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            }>>(newOptions: NewOptions_10) => any;
                                            access: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            accessPath: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                                            get: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string> | undefined;
                                            ancestors: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                                            diagram: (node: MenuItem<string>, options: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string) | (({} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9 ? T_1 extends {
                                                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                            } ? void | {
                                                type?: tree_visit.DiagramType | undefined;
                                                flattenSingleChildNodes?: boolean | undefined;
                                            } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "getLabel", {
                                                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                            }> & {
                                                type?: tree_visit.DiagramType | undefined;
                                                flattenSingleChildNodes?: boolean | undefined;
                                            } : never : never) extends infer T ? { [K in keyof T]: ({} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9 ? T_1 extends {
                                                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                            } ? void | {
                                                type?: tree_visit.DiagramType | undefined;
                                                flattenSingleChildNodes?: boolean | undefined;
                                            } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "getLabel", {
                                                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                            }> & {
                                                type?: tree_visit.DiagramType | undefined;
                                                flattenSingleChildNodes?: boolean | undefined;
                                            } : never : never)[K]; } : never)) => string;
                                            find: {
                                                (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string> | undefined;
                                                (node: MenuItem<string>, options: {
                                                    direction?: tree_visit.TraversalDirection | undefined;
                                                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                                }): MenuItem<string> | undefined;
                                                <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S | undefined;
                                                <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                                                    direction?: tree_visit.TraversalDirection | undefined;
                                                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                                                }): S | undefined;
                                            };
                                            findAll: {
                                                (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string>[];
                                                (node: MenuItem<string>, options: {
                                                    direction?: tree_visit.TraversalDirection | undefined;
                                                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                                }): MenuItem<string>[];
                                                <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S[];
                                                <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                                                    direction?: tree_visit.TraversalDirection | undefined;
                                                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                                                }): S[];
                                            };
                                            findPath: {
                                                (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath | undefined;
                                                (node: MenuItem<string>, options: {
                                                    direction?: tree_visit.TraversalDirection | undefined;
                                                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                                }): tree_visit.IndexPath | undefined;
                                            };
                                            findAllPaths: {
                                                (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath[];
                                                (node: MenuItem<string>, options: {
                                                    direction?: tree_visit.TraversalDirection | undefined;
                                                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                                }): tree_visit.IndexPath[];
                                            };
                                            entries: (node: MenuItem<string>) => [tree_visit.IndexPath, MenuItem<string>][];
                                            flat: (node: MenuItem<string>) => MenuItem<string>[];
                                            reduce: <R>(node: MenuItem<string>, nextResult: (result: R, node: MenuItem<string>, indexPath: tree_visit.IndexPath) => R, initialResult: R) => R;
                                            map: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R) => R;
                                            flatMap: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R[]) => R;
                                            visit: {
                                                (node: MenuItem<string>, onEnter: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined): void;
                                                (node: MenuItem<string>, options: {
                                                    direction?: tree_visit.TraversalDirection | undefined;
                                                    onEnter?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined;
                                                    onLeave?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.LeaveReturnValue) | undefined;
                                                }): void;
                                            };
                                            insert: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                            }> & Omit<{
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                            }> & Omit<{
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                            }, "create">)[K]; } : never) => MenuItem<string>;
                                            insertWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                                track: tree_visit.IndexPath[];
                                            }> & Omit<{
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                                track: tree_visit.IndexPath[];
                                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                                track: tree_visit.IndexPath[];
                                            }> & Omit<{
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                                track: tree_visit.IndexPath[];
                                            }, "create">)[K]; } : never) => {
                                                node: MenuItem<string>;
                                                paths: (tree_visit.IndexPath | undefined)[];
                                            };
                                            remove: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                paths: tree_visit.IndexPath[];
                                            }> & Omit<{
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                paths: tree_visit.IndexPath[];
                                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                paths: tree_visit.IndexPath[];
                                            }> & Omit<{
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                paths: tree_visit.IndexPath[];
                                            }, "create">)[K]; } : never) => MenuItem<string>;
                                            removeWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                track: tree_visit.IndexPath[];
                                                paths: tree_visit.IndexPath[];
                                            }> & Omit<{
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                track: tree_visit.IndexPath[];
                                                paths: tree_visit.IndexPath[];
                                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                track: tree_visit.IndexPath[];
                                                paths: tree_visit.IndexPath[];
                                            }> & Omit<{
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                track: tree_visit.IndexPath[];
                                                paths: tree_visit.IndexPath[];
                                            }, "create">)[K]; } : never) => {
                                                node: MenuItem<string>;
                                                paths: (tree_visit.IndexPath | undefined)[];
                                            };
                                            move: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                paths: tree_visit.IndexPath[];
                                                to: tree_visit.IndexPath;
                                            }> & Omit<{
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                paths: tree_visit.IndexPath[];
                                                to: tree_visit.IndexPath;
                                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                paths: tree_visit.IndexPath[];
                                                to: tree_visit.IndexPath;
                                            }> & Omit<{
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                paths: tree_visit.IndexPath[];
                                                to: tree_visit.IndexPath;
                                            }, "create">)[K]; } : never) => MenuItem<string>;
                                            splice: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                                deleteCount?: number | undefined;
                                            }> & Omit<{
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                                deleteCount?: number | undefined;
                                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                                deleteCount?: number | undefined;
                                            }> & Omit<{
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                                deleteCount?: number | undefined;
                                            }, "create">)[K]; } : never) => MenuItem<string>;
                                            spliceWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                                track: tree_visit.IndexPath[];
                                                deleteCount?: number | undefined;
                                            }> & Omit<{
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                                track: tree_visit.IndexPath[];
                                                deleteCount?: number | undefined;
                                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                                track: tree_visit.IndexPath[];
                                                deleteCount?: number | undefined;
                                            }> & Omit<{
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                nodes: MenuItem<string>[];
                                                track: tree_visit.IndexPath[];
                                                deleteCount?: number | undefined;
                                            }, "create">)[K]; } : never) => {
                                                node: MenuItem<string>;
                                                paths: (tree_visit.IndexPath | undefined)[];
                                            };
                                            replace: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                node: MenuItem<string>;
                                            }> & Omit<{
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                node: MenuItem<string>;
                                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 & NewOptions_9, "create", {
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                node: MenuItem<string>;
                                            }> & Omit<{
                                                path: tree_visit.IndexPath;
                                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                                node: MenuItem<string>;
                                            }, "create">)[K]; } : never) => MenuItem<string>;
                                        };
                                        access: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        accessPath: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                                        get: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string> | undefined;
                                        ancestors: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                                        diagram: (node: MenuItem<string>, options: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string) | (({} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 ? T_1 extends {
                                            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                        } ? void | {
                                            type?: tree_visit.DiagramType | undefined;
                                            flattenSingleChildNodes?: boolean | undefined;
                                        } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "getLabel", {
                                            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                        }> & {
                                            type?: tree_visit.DiagramType | undefined;
                                            flattenSingleChildNodes?: boolean | undefined;
                                        } : never : never) extends infer T ? { [K in keyof T]: ({} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8 ? T_1 extends {
                                            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                        } ? void | {
                                            type?: tree_visit.DiagramType | undefined;
                                            flattenSingleChildNodes?: boolean | undefined;
                                        } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "getLabel", {
                                            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                        }> & {
                                            type?: tree_visit.DiagramType | undefined;
                                            flattenSingleChildNodes?: boolean | undefined;
                                        } : never : never)[K]; } : never)) => string;
                                        find: {
                                            (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string> | undefined;
                                            (node: MenuItem<string>, options: {
                                                direction?: tree_visit.TraversalDirection | undefined;
                                                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                            }): MenuItem<string> | undefined;
                                            <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S | undefined;
                                            <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                                                direction?: tree_visit.TraversalDirection | undefined;
                                                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                                            }): S | undefined;
                                        };
                                        findAll: {
                                            (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string>[];
                                            (node: MenuItem<string>, options: {
                                                direction?: tree_visit.TraversalDirection | undefined;
                                                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                            }): MenuItem<string>[];
                                            <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S[];
                                            <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                                                direction?: tree_visit.TraversalDirection | undefined;
                                                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                                            }): S[];
                                        };
                                        findPath: {
                                            (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath | undefined;
                                            (node: MenuItem<string>, options: {
                                                direction?: tree_visit.TraversalDirection | undefined;
                                                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                            }): tree_visit.IndexPath | undefined;
                                        };
                                        findAllPaths: {
                                            (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath[];
                                            (node: MenuItem<string>, options: {
                                                direction?: tree_visit.TraversalDirection | undefined;
                                                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                            }): tree_visit.IndexPath[];
                                        };
                                        entries: (node: MenuItem<string>) => [tree_visit.IndexPath, MenuItem<string>][];
                                        flat: (node: MenuItem<string>) => MenuItem<string>[];
                                        reduce: <R>(node: MenuItem<string>, nextResult: (result: R, node: MenuItem<string>, indexPath: tree_visit.IndexPath) => R, initialResult: R) => R;
                                        map: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R) => R;
                                        flatMap: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R[]) => R;
                                        visit: {
                                            (node: MenuItem<string>, onEnter: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined): void;
                                            (node: MenuItem<string>, options: {
                                                direction?: tree_visit.TraversalDirection | undefined;
                                                onEnter?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined;
                                                onLeave?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.LeaveReturnValue) | undefined;
                                            }): void;
                                        };
                                        insert: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                        }> & Omit<{
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                        }> & Omit<{
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                        }, "create">)[K]; } : never) => MenuItem<string>;
                                        insertWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                            track: tree_visit.IndexPath[];
                                        }> & Omit<{
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                            track: tree_visit.IndexPath[];
                                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                            track: tree_visit.IndexPath[];
                                        }> & Omit<{
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                            track: tree_visit.IndexPath[];
                                        }, "create">)[K]; } : never) => {
                                            node: MenuItem<string>;
                                            paths: (tree_visit.IndexPath | undefined)[];
                                        };
                                        remove: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            paths: tree_visit.IndexPath[];
                                        }> & Omit<{
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            paths: tree_visit.IndexPath[];
                                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            paths: tree_visit.IndexPath[];
                                        }> & Omit<{
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            paths: tree_visit.IndexPath[];
                                        }, "create">)[K]; } : never) => MenuItem<string>;
                                        removeWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            track: tree_visit.IndexPath[];
                                            paths: tree_visit.IndexPath[];
                                        }> & Omit<{
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            track: tree_visit.IndexPath[];
                                            paths: tree_visit.IndexPath[];
                                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            track: tree_visit.IndexPath[];
                                            paths: tree_visit.IndexPath[];
                                        }> & Omit<{
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            track: tree_visit.IndexPath[];
                                            paths: tree_visit.IndexPath[];
                                        }, "create">)[K]; } : never) => {
                                            node: MenuItem<string>;
                                            paths: (tree_visit.IndexPath | undefined)[];
                                        };
                                        move: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            paths: tree_visit.IndexPath[];
                                            to: tree_visit.IndexPath;
                                        }> & Omit<{
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            paths: tree_visit.IndexPath[];
                                            to: tree_visit.IndexPath;
                                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            paths: tree_visit.IndexPath[];
                                            to: tree_visit.IndexPath;
                                        }> & Omit<{
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            paths: tree_visit.IndexPath[];
                                            to: tree_visit.IndexPath;
                                        }, "create">)[K]; } : never) => MenuItem<string>;
                                        splice: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                            deleteCount?: number | undefined;
                                        }> & Omit<{
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                            deleteCount?: number | undefined;
                                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                            deleteCount?: number | undefined;
                                        }> & Omit<{
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                            deleteCount?: number | undefined;
                                        }, "create">)[K]; } : never) => MenuItem<string>;
                                        spliceWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                            track: tree_visit.IndexPath[];
                                            deleteCount?: number | undefined;
                                        }> & Omit<{
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                            track: tree_visit.IndexPath[];
                                            deleteCount?: number | undefined;
                                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                            track: tree_visit.IndexPath[];
                                            deleteCount?: number | undefined;
                                        }> & Omit<{
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            nodes: MenuItem<string>[];
                                            track: tree_visit.IndexPath[];
                                            deleteCount?: number | undefined;
                                        }, "create">)[K]; } : never) => {
                                            node: MenuItem<string>;
                                            paths: (tree_visit.IndexPath | undefined)[];
                                        };
                                        replace: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            node: MenuItem<string>;
                                        }> & Omit<{
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            node: MenuItem<string>;
                                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 & NewOptions_8, "create", {
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            node: MenuItem<string>;
                                        }> & Omit<{
                                            path: tree_visit.IndexPath;
                                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                            node: MenuItem<string>;
                                        }, "create">)[K]; } : never) => MenuItem<string>;
                                    };
                                    access: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    accessPath: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                                    get: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string> | undefined;
                                    ancestors: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                                    diagram: (node: MenuItem<string>, options: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string) | (({} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 ? T_1 extends {
                                        getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                    } ? void | {
                                        type?: tree_visit.DiagramType | undefined;
                                        flattenSingleChildNodes?: boolean | undefined;
                                    } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "getLabel", {
                                        getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                    }> & {
                                        type?: tree_visit.DiagramType | undefined;
                                        flattenSingleChildNodes?: boolean | undefined;
                                    } : never : never) extends infer T ? { [K in keyof T]: ({} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7 ? T_1 extends {
                                        getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                    } ? void | {
                                        type?: tree_visit.DiagramType | undefined;
                                        flattenSingleChildNodes?: boolean | undefined;
                                    } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "getLabel", {
                                        getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                    }> & {
                                        type?: tree_visit.DiagramType | undefined;
                                        flattenSingleChildNodes?: boolean | undefined;
                                    } : never : never)[K]; } : never)) => string;
                                    find: {
                                        (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string> | undefined;
                                        (node: MenuItem<string>, options: {
                                            direction?: tree_visit.TraversalDirection | undefined;
                                            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                        }): MenuItem<string> | undefined;
                                        <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S | undefined;
                                        <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                                            direction?: tree_visit.TraversalDirection | undefined;
                                            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                                        }): S | undefined;
                                    };
                                    findAll: {
                                        (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string>[];
                                        (node: MenuItem<string>, options: {
                                            direction?: tree_visit.TraversalDirection | undefined;
                                            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                        }): MenuItem<string>[];
                                        <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S[];
                                        <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                                            direction?: tree_visit.TraversalDirection | undefined;
                                            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                                        }): S[];
                                    };
                                    findPath: {
                                        (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath | undefined;
                                        (node: MenuItem<string>, options: {
                                            direction?: tree_visit.TraversalDirection | undefined;
                                            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                        }): tree_visit.IndexPath | undefined;
                                    };
                                    findAllPaths: {
                                        (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath[];
                                        (node: MenuItem<string>, options: {
                                            direction?: tree_visit.TraversalDirection | undefined;
                                            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                        }): tree_visit.IndexPath[];
                                    };
                                    entries: (node: MenuItem<string>) => [tree_visit.IndexPath, MenuItem<string>][];
                                    flat: (node: MenuItem<string>) => MenuItem<string>[];
                                    reduce: <R>(node: MenuItem<string>, nextResult: (result: R, node: MenuItem<string>, indexPath: tree_visit.IndexPath) => R, initialResult: R) => R;
                                    map: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R) => R;
                                    flatMap: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R[]) => R;
                                    visit: {
                                        (node: MenuItem<string>, onEnter: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined): void;
                                        (node: MenuItem<string>, options: {
                                            direction?: tree_visit.TraversalDirection | undefined;
                                            onEnter?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined;
                                            onLeave?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.LeaveReturnValue) | undefined;
                                        }): void;
                                    };
                                    insert: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                    }> & Omit<{
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                    }> & Omit<{
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                    }, "create">)[K]; } : never) => MenuItem<string>;
                                    insertWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                        track: tree_visit.IndexPath[];
                                    }> & Omit<{
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                        track: tree_visit.IndexPath[];
                                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                        track: tree_visit.IndexPath[];
                                    }> & Omit<{
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                        track: tree_visit.IndexPath[];
                                    }, "create">)[K]; } : never) => {
                                        node: MenuItem<string>;
                                        paths: (tree_visit.IndexPath | undefined)[];
                                    };
                                    remove: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        paths: tree_visit.IndexPath[];
                                    }> & Omit<{
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        paths: tree_visit.IndexPath[];
                                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        paths: tree_visit.IndexPath[];
                                    }> & Omit<{
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        paths: tree_visit.IndexPath[];
                                    }, "create">)[K]; } : never) => MenuItem<string>;
                                    removeWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        track: tree_visit.IndexPath[];
                                        paths: tree_visit.IndexPath[];
                                    }> & Omit<{
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        track: tree_visit.IndexPath[];
                                        paths: tree_visit.IndexPath[];
                                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        track: tree_visit.IndexPath[];
                                        paths: tree_visit.IndexPath[];
                                    }> & Omit<{
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        track: tree_visit.IndexPath[];
                                        paths: tree_visit.IndexPath[];
                                    }, "create">)[K]; } : never) => {
                                        node: MenuItem<string>;
                                        paths: (tree_visit.IndexPath | undefined)[];
                                    };
                                    move: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        paths: tree_visit.IndexPath[];
                                        to: tree_visit.IndexPath;
                                    }> & Omit<{
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        paths: tree_visit.IndexPath[];
                                        to: tree_visit.IndexPath;
                                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        paths: tree_visit.IndexPath[];
                                        to: tree_visit.IndexPath;
                                    }> & Omit<{
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        paths: tree_visit.IndexPath[];
                                        to: tree_visit.IndexPath;
                                    }, "create">)[K]; } : never) => MenuItem<string>;
                                    splice: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                        deleteCount?: number | undefined;
                                    }> & Omit<{
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                        deleteCount?: number | undefined;
                                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                        deleteCount?: number | undefined;
                                    }> & Omit<{
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                        deleteCount?: number | undefined;
                                    }, "create">)[K]; } : never) => MenuItem<string>;
                                    spliceWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                        track: tree_visit.IndexPath[];
                                        deleteCount?: number | undefined;
                                    }> & Omit<{
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                        track: tree_visit.IndexPath[];
                                        deleteCount?: number | undefined;
                                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                        track: tree_visit.IndexPath[];
                                        deleteCount?: number | undefined;
                                    }> & Omit<{
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        nodes: MenuItem<string>[];
                                        track: tree_visit.IndexPath[];
                                        deleteCount?: number | undefined;
                                    }, "create">)[K]; } : never) => {
                                        node: MenuItem<string>;
                                        paths: (tree_visit.IndexPath | undefined)[];
                                    };
                                    replace: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        node: MenuItem<string>;
                                    }> & Omit<{
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        node: MenuItem<string>;
                                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 & NewOptions_7, "create", {
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        node: MenuItem<string>;
                                    }> & Omit<{
                                        path: tree_visit.IndexPath;
                                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                        node: MenuItem<string>;
                                    }, "create">)[K]; } : never) => MenuItem<string>;
                                };
                                access: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                accessPath: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                                get: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string> | undefined;
                                ancestors: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                                diagram: (node: MenuItem<string>, options: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string) | (({} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 ? T_1 extends {
                                    getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                } ? void | {
                                    type?: tree_visit.DiagramType | undefined;
                                    flattenSingleChildNodes?: boolean | undefined;
                                } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "getLabel", {
                                    getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                }> & {
                                    type?: tree_visit.DiagramType | undefined;
                                    flattenSingleChildNodes?: boolean | undefined;
                                } : never : never) extends infer T ? { [K in keyof T]: ({} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6 ? T_1 extends {
                                    getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                } ? void | {
                                    type?: tree_visit.DiagramType | undefined;
                                    flattenSingleChildNodes?: boolean | undefined;
                                } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "getLabel", {
                                    getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                                }> & {
                                    type?: tree_visit.DiagramType | undefined;
                                    flattenSingleChildNodes?: boolean | undefined;
                                } : never : never)[K]; } : never)) => string;
                                find: {
                                    (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string> | undefined;
                                    (node: MenuItem<string>, options: {
                                        direction?: tree_visit.TraversalDirection | undefined;
                                        predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                    }): MenuItem<string> | undefined;
                                    <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S | undefined;
                                    <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                                        direction?: tree_visit.TraversalDirection | undefined;
                                        predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                                    }): S | undefined;
                                };
                                findAll: {
                                    (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string>[];
                                    (node: MenuItem<string>, options: {
                                        direction?: tree_visit.TraversalDirection | undefined;
                                        predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                    }): MenuItem<string>[];
                                    <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S[];
                                    <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                                        direction?: tree_visit.TraversalDirection | undefined;
                                        predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                                    }): S[];
                                };
                                findPath: {
                                    (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath | undefined;
                                    (node: MenuItem<string>, options: {
                                        direction?: tree_visit.TraversalDirection | undefined;
                                        predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                    }): tree_visit.IndexPath | undefined;
                                };
                                findAllPaths: {
                                    (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath[];
                                    (node: MenuItem<string>, options: {
                                        direction?: tree_visit.TraversalDirection | undefined;
                                        predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                    }): tree_visit.IndexPath[];
                                };
                                entries: (node: MenuItem<string>) => [tree_visit.IndexPath, MenuItem<string>][];
                                flat: (node: MenuItem<string>) => MenuItem<string>[];
                                reduce: <R>(node: MenuItem<string>, nextResult: (result: R, node: MenuItem<string>, indexPath: tree_visit.IndexPath) => R, initialResult: R) => R;
                                map: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R) => R;
                                flatMap: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R[]) => R;
                                visit: {
                                    (node: MenuItem<string>, onEnter: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined): void;
                                    (node: MenuItem<string>, options: {
                                        direction?: tree_visit.TraversalDirection | undefined;
                                        onEnter?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined;
                                        onLeave?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.LeaveReturnValue) | undefined;
                                    }): void;
                                };
                                insert: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                }> & Omit<{
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                }> & Omit<{
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                }, "create">)[K]; } : never) => MenuItem<string>;
                                insertWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                    track: tree_visit.IndexPath[];
                                }> & Omit<{
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                    track: tree_visit.IndexPath[];
                                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                    track: tree_visit.IndexPath[];
                                }> & Omit<{
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                    track: tree_visit.IndexPath[];
                                }, "create">)[K]; } : never) => {
                                    node: MenuItem<string>;
                                    paths: (tree_visit.IndexPath | undefined)[];
                                };
                                remove: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    paths: tree_visit.IndexPath[];
                                }> & Omit<{
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    paths: tree_visit.IndexPath[];
                                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    paths: tree_visit.IndexPath[];
                                }> & Omit<{
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    paths: tree_visit.IndexPath[];
                                }, "create">)[K]; } : never) => MenuItem<string>;
                                removeWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    track: tree_visit.IndexPath[];
                                    paths: tree_visit.IndexPath[];
                                }> & Omit<{
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    track: tree_visit.IndexPath[];
                                    paths: tree_visit.IndexPath[];
                                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    track: tree_visit.IndexPath[];
                                    paths: tree_visit.IndexPath[];
                                }> & Omit<{
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    track: tree_visit.IndexPath[];
                                    paths: tree_visit.IndexPath[];
                                }, "create">)[K]; } : never) => {
                                    node: MenuItem<string>;
                                    paths: (tree_visit.IndexPath | undefined)[];
                                };
                                move: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    paths: tree_visit.IndexPath[];
                                    to: tree_visit.IndexPath;
                                }> & Omit<{
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    paths: tree_visit.IndexPath[];
                                    to: tree_visit.IndexPath;
                                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    paths: tree_visit.IndexPath[];
                                    to: tree_visit.IndexPath;
                                }> & Omit<{
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    paths: tree_visit.IndexPath[];
                                    to: tree_visit.IndexPath;
                                }, "create">)[K]; } : never) => MenuItem<string>;
                                splice: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                    deleteCount?: number | undefined;
                                }> & Omit<{
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                    deleteCount?: number | undefined;
                                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                    deleteCount?: number | undefined;
                                }> & Omit<{
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                    deleteCount?: number | undefined;
                                }, "create">)[K]; } : never) => MenuItem<string>;
                                spliceWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                    track: tree_visit.IndexPath[];
                                    deleteCount?: number | undefined;
                                }> & Omit<{
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                    track: tree_visit.IndexPath[];
                                    deleteCount?: number | undefined;
                                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                    track: tree_visit.IndexPath[];
                                    deleteCount?: number | undefined;
                                }> & Omit<{
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    nodes: MenuItem<string>[];
                                    track: tree_visit.IndexPath[];
                                    deleteCount?: number | undefined;
                                }, "create">)[K]; } : never) => {
                                    node: MenuItem<string>;
                                    paths: (tree_visit.IndexPath | undefined)[];
                                };
                                replace: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    node: MenuItem<string>;
                                }> & Omit<{
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    node: MenuItem<string>;
                                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 & NewOptions_6, "create", {
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    node: MenuItem<string>;
                                }> & Omit<{
                                    path: tree_visit.IndexPath;
                                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                    node: MenuItem<string>;
                                }, "create">)[K]; } : never) => MenuItem<string>;
                            };
                            access: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            accessPath: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                            get: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string> | undefined;
                            ancestors: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                            diagram: (node: MenuItem<string>, options: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string) | (({} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 ? T_1 extends {
                                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                            } ? void | {
                                type?: tree_visit.DiagramType | undefined;
                                flattenSingleChildNodes?: boolean | undefined;
                            } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "getLabel", {
                                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                            }> & {
                                type?: tree_visit.DiagramType | undefined;
                                flattenSingleChildNodes?: boolean | undefined;
                            } : never : never) extends infer T ? { [K in keyof T]: ({} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5 ? T_1 extends {
                                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                            } ? void | {
                                type?: tree_visit.DiagramType | undefined;
                                flattenSingleChildNodes?: boolean | undefined;
                            } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "getLabel", {
                                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                            }> & {
                                type?: tree_visit.DiagramType | undefined;
                                flattenSingleChildNodes?: boolean | undefined;
                            } : never : never)[K]; } : never)) => string;
                            find: {
                                (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string> | undefined;
                                (node: MenuItem<string>, options: {
                                    direction?: tree_visit.TraversalDirection | undefined;
                                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                }): MenuItem<string> | undefined;
                                <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S | undefined;
                                <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                                    direction?: tree_visit.TraversalDirection | undefined;
                                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                                }): S | undefined;
                            };
                            findAll: {
                                (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string>[];
                                (node: MenuItem<string>, options: {
                                    direction?: tree_visit.TraversalDirection | undefined;
                                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                }): MenuItem<string>[];
                                <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S[];
                                <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                                    direction?: tree_visit.TraversalDirection | undefined;
                                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                                }): S[];
                            };
                            findPath: {
                                (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath | undefined;
                                (node: MenuItem<string>, options: {
                                    direction?: tree_visit.TraversalDirection | undefined;
                                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                }): tree_visit.IndexPath | undefined;
                            };
                            findAllPaths: {
                                (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath[];
                                (node: MenuItem<string>, options: {
                                    direction?: tree_visit.TraversalDirection | undefined;
                                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                                }): tree_visit.IndexPath[];
                            };
                            entries: (node: MenuItem<string>) => [tree_visit.IndexPath, MenuItem<string>][];
                            flat: (node: MenuItem<string>) => MenuItem<string>[];
                            reduce: <R>(node: MenuItem<string>, nextResult: (result: R, node: MenuItem<string>, indexPath: tree_visit.IndexPath) => R, initialResult: R) => R;
                            map: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R) => R;
                            flatMap: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R[]) => R;
                            visit: {
                                (node: MenuItem<string>, onEnter: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined): void;
                                (node: MenuItem<string>, options: {
                                    direction?: tree_visit.TraversalDirection | undefined;
                                    onEnter?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined;
                                    onLeave?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.LeaveReturnValue) | undefined;
                                }): void;
                            };
                            insert: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                            }> & Omit<{
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                            }> & Omit<{
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                            }, "create">)[K]; } : never) => MenuItem<string>;
                            insertWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                                track: tree_visit.IndexPath[];
                            }> & Omit<{
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                                track: tree_visit.IndexPath[];
                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                                track: tree_visit.IndexPath[];
                            }> & Omit<{
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                                track: tree_visit.IndexPath[];
                            }, "create">)[K]; } : never) => {
                                node: MenuItem<string>;
                                paths: (tree_visit.IndexPath | undefined)[];
                            };
                            remove: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                paths: tree_visit.IndexPath[];
                            }> & Omit<{
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                paths: tree_visit.IndexPath[];
                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                paths: tree_visit.IndexPath[];
                            }> & Omit<{
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                paths: tree_visit.IndexPath[];
                            }, "create">)[K]; } : never) => MenuItem<string>;
                            removeWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                track: tree_visit.IndexPath[];
                                paths: tree_visit.IndexPath[];
                            }> & Omit<{
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                track: tree_visit.IndexPath[];
                                paths: tree_visit.IndexPath[];
                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                track: tree_visit.IndexPath[];
                                paths: tree_visit.IndexPath[];
                            }> & Omit<{
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                track: tree_visit.IndexPath[];
                                paths: tree_visit.IndexPath[];
                            }, "create">)[K]; } : never) => {
                                node: MenuItem<string>;
                                paths: (tree_visit.IndexPath | undefined)[];
                            };
                            move: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                paths: tree_visit.IndexPath[];
                                to: tree_visit.IndexPath;
                            }> & Omit<{
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                paths: tree_visit.IndexPath[];
                                to: tree_visit.IndexPath;
                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                paths: tree_visit.IndexPath[];
                                to: tree_visit.IndexPath;
                            }> & Omit<{
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                paths: tree_visit.IndexPath[];
                                to: tree_visit.IndexPath;
                            }, "create">)[K]; } : never) => MenuItem<string>;
                            splice: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                                deleteCount?: number | undefined;
                            }> & Omit<{
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                                deleteCount?: number | undefined;
                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                                deleteCount?: number | undefined;
                            }> & Omit<{
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                                deleteCount?: number | undefined;
                            }, "create">)[K]; } : never) => MenuItem<string>;
                            spliceWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                                track: tree_visit.IndexPath[];
                                deleteCount?: number | undefined;
                            }> & Omit<{
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                                track: tree_visit.IndexPath[];
                                deleteCount?: number | undefined;
                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                                track: tree_visit.IndexPath[];
                                deleteCount?: number | undefined;
                            }> & Omit<{
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                nodes: MenuItem<string>[];
                                track: tree_visit.IndexPath[];
                                deleteCount?: number | undefined;
                            }, "create">)[K]; } : never) => {
                                node: MenuItem<string>;
                                paths: (tree_visit.IndexPath | undefined)[];
                            };
                            replace: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                node: MenuItem<string>;
                            }> & Omit<{
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                node: MenuItem<string>;
                            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 & NewOptions_5, "create", {
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                node: MenuItem<string>;
                            }> & Omit<{
                                path: tree_visit.IndexPath;
                                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                                node: MenuItem<string>;
                            }, "create">)[K]; } : never) => MenuItem<string>;
                        };
                        access: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        accessPath: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                        get: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string> | undefined;
                        ancestors: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                        diagram: (node: MenuItem<string>, options: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string) | (({} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 ? T_1 extends {
                            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                        } ? void | {
                            type?: tree_visit.DiagramType | undefined;
                            flattenSingleChildNodes?: boolean | undefined;
                        } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "getLabel", {
                            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                        }> & {
                            type?: tree_visit.DiagramType | undefined;
                            flattenSingleChildNodes?: boolean | undefined;
                        } : never : never) extends infer T ? { [K in keyof T]: ({} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4 ? T_1 extends {
                            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                        } ? void | {
                            type?: tree_visit.DiagramType | undefined;
                            flattenSingleChildNodes?: boolean | undefined;
                        } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "getLabel", {
                            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                        }> & {
                            type?: tree_visit.DiagramType | undefined;
                            flattenSingleChildNodes?: boolean | undefined;
                        } : never : never)[K]; } : never)) => string;
                        find: {
                            (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string> | undefined;
                            (node: MenuItem<string>, options: {
                                direction?: tree_visit.TraversalDirection | undefined;
                                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                            }): MenuItem<string> | undefined;
                            <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S | undefined;
                            <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                                direction?: tree_visit.TraversalDirection | undefined;
                                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                            }): S | undefined;
                        };
                        findAll: {
                            (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string>[];
                            (node: MenuItem<string>, options: {
                                direction?: tree_visit.TraversalDirection | undefined;
                                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                            }): MenuItem<string>[];
                            <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S[];
                            <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                                direction?: tree_visit.TraversalDirection | undefined;
                                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                            }): S[];
                        };
                        findPath: {
                            (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath | undefined;
                            (node: MenuItem<string>, options: {
                                direction?: tree_visit.TraversalDirection | undefined;
                                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                            }): tree_visit.IndexPath | undefined;
                        };
                        findAllPaths: {
                            (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath[];
                            (node: MenuItem<string>, options: {
                                direction?: tree_visit.TraversalDirection | undefined;
                                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                            }): tree_visit.IndexPath[];
                        };
                        entries: (node: MenuItem<string>) => [tree_visit.IndexPath, MenuItem<string>][];
                        flat: (node: MenuItem<string>) => MenuItem<string>[];
                        reduce: <R>(node: MenuItem<string>, nextResult: (result: R, node: MenuItem<string>, indexPath: tree_visit.IndexPath) => R, initialResult: R) => R;
                        map: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R) => R;
                        flatMap: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R[]) => R;
                        visit: {
                            (node: MenuItem<string>, onEnter: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined): void;
                            (node: MenuItem<string>, options: {
                                direction?: tree_visit.TraversalDirection | undefined;
                                onEnter?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined;
                                onLeave?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.LeaveReturnValue) | undefined;
                            }): void;
                        };
                        insert: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                        }> & Omit<{
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                        }> & Omit<{
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                        }, "create">)[K]; } : never) => MenuItem<string>;
                        insertWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                            track: tree_visit.IndexPath[];
                        }> & Omit<{
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                            track: tree_visit.IndexPath[];
                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                            track: tree_visit.IndexPath[];
                        }> & Omit<{
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                            track: tree_visit.IndexPath[];
                        }, "create">)[K]; } : never) => {
                            node: MenuItem<string>;
                            paths: (tree_visit.IndexPath | undefined)[];
                        };
                        remove: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            paths: tree_visit.IndexPath[];
                        }> & Omit<{
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            paths: tree_visit.IndexPath[];
                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            paths: tree_visit.IndexPath[];
                        }> & Omit<{
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            paths: tree_visit.IndexPath[];
                        }, "create">)[K]; } : never) => MenuItem<string>;
                        removeWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            track: tree_visit.IndexPath[];
                            paths: tree_visit.IndexPath[];
                        }> & Omit<{
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            track: tree_visit.IndexPath[];
                            paths: tree_visit.IndexPath[];
                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            track: tree_visit.IndexPath[];
                            paths: tree_visit.IndexPath[];
                        }> & Omit<{
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            track: tree_visit.IndexPath[];
                            paths: tree_visit.IndexPath[];
                        }, "create">)[K]; } : never) => {
                            node: MenuItem<string>;
                            paths: (tree_visit.IndexPath | undefined)[];
                        };
                        move: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            paths: tree_visit.IndexPath[];
                            to: tree_visit.IndexPath;
                        }> & Omit<{
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            paths: tree_visit.IndexPath[];
                            to: tree_visit.IndexPath;
                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            paths: tree_visit.IndexPath[];
                            to: tree_visit.IndexPath;
                        }> & Omit<{
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            paths: tree_visit.IndexPath[];
                            to: tree_visit.IndexPath;
                        }, "create">)[K]; } : never) => MenuItem<string>;
                        splice: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                            deleteCount?: number | undefined;
                        }> & Omit<{
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                            deleteCount?: number | undefined;
                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                            deleteCount?: number | undefined;
                        }> & Omit<{
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                            deleteCount?: number | undefined;
                        }, "create">)[K]; } : never) => MenuItem<string>;
                        spliceWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                            track: tree_visit.IndexPath[];
                            deleteCount?: number | undefined;
                        }> & Omit<{
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                            track: tree_visit.IndexPath[];
                            deleteCount?: number | undefined;
                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                            track: tree_visit.IndexPath[];
                            deleteCount?: number | undefined;
                        }> & Omit<{
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            nodes: MenuItem<string>[];
                            track: tree_visit.IndexPath[];
                            deleteCount?: number | undefined;
                        }, "create">)[K]; } : never) => {
                            node: MenuItem<string>;
                            paths: (tree_visit.IndexPath | undefined)[];
                        };
                        replace: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            node: MenuItem<string>;
                        }> & Omit<{
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            node: MenuItem<string>;
                        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 & NewOptions_4, "create", {
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            node: MenuItem<string>;
                        }> & Omit<{
                            path: tree_visit.IndexPath;
                            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                            node: MenuItem<string>;
                        }, "create">)[K]; } : never) => MenuItem<string>;
                    };
                    access: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    accessPath: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                    get: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string> | undefined;
                    ancestors: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                    diagram: (node: MenuItem<string>, options: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string) | (({} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 ? T_1 extends {
                        getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                    } ? void | {
                        type?: tree_visit.DiagramType | undefined;
                        flattenSingleChildNodes?: boolean | undefined;
                    } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "getLabel", {
                        getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                    }> & {
                        type?: tree_visit.DiagramType | undefined;
                        flattenSingleChildNodes?: boolean | undefined;
                    } : never : never) extends infer T ? { [K in keyof T]: ({} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3 ? T_1 extends {
                        getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                    } ? void | {
                        type?: tree_visit.DiagramType | undefined;
                        flattenSingleChildNodes?: boolean | undefined;
                    } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "getLabel", {
                        getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                    }> & {
                        type?: tree_visit.DiagramType | undefined;
                        flattenSingleChildNodes?: boolean | undefined;
                    } : never : never)[K]; } : never)) => string;
                    find: {
                        (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string> | undefined;
                        (node: MenuItem<string>, options: {
                            direction?: tree_visit.TraversalDirection | undefined;
                            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                        }): MenuItem<string> | undefined;
                        <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S | undefined;
                        <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                            direction?: tree_visit.TraversalDirection | undefined;
                            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                        }): S | undefined;
                    };
                    findAll: {
                        (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string>[];
                        (node: MenuItem<string>, options: {
                            direction?: tree_visit.TraversalDirection | undefined;
                            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                        }): MenuItem<string>[];
                        <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S[];
                        <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                            direction?: tree_visit.TraversalDirection | undefined;
                            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                        }): S[];
                    };
                    findPath: {
                        (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath | undefined;
                        (node: MenuItem<string>, options: {
                            direction?: tree_visit.TraversalDirection | undefined;
                            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                        }): tree_visit.IndexPath | undefined;
                    };
                    findAllPaths: {
                        (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath[];
                        (node: MenuItem<string>, options: {
                            direction?: tree_visit.TraversalDirection | undefined;
                            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                        }): tree_visit.IndexPath[];
                    };
                    entries: (node: MenuItem<string>) => [tree_visit.IndexPath, MenuItem<string>][];
                    flat: (node: MenuItem<string>) => MenuItem<string>[];
                    reduce: <R>(node: MenuItem<string>, nextResult: (result: R, node: MenuItem<string>, indexPath: tree_visit.IndexPath) => R, initialResult: R) => R;
                    map: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R) => R;
                    flatMap: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R[]) => R;
                    visit: {
                        (node: MenuItem<string>, onEnter: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined): void;
                        (node: MenuItem<string>, options: {
                            direction?: tree_visit.TraversalDirection | undefined;
                            onEnter?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined;
                            onLeave?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.LeaveReturnValue) | undefined;
                        }): void;
                    };
                    insert: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                    }> & Omit<{
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                    }> & Omit<{
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                    }, "create">)[K]; } : never) => MenuItem<string>;
                    insertWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                        track: tree_visit.IndexPath[];
                    }> & Omit<{
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                        track: tree_visit.IndexPath[];
                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                        track: tree_visit.IndexPath[];
                    }> & Omit<{
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                        track: tree_visit.IndexPath[];
                    }, "create">)[K]; } : never) => {
                        node: MenuItem<string>;
                        paths: (tree_visit.IndexPath | undefined)[];
                    };
                    remove: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        paths: tree_visit.IndexPath[];
                    }> & Omit<{
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        paths: tree_visit.IndexPath[];
                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        paths: tree_visit.IndexPath[];
                    }> & Omit<{
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        paths: tree_visit.IndexPath[];
                    }, "create">)[K]; } : never) => MenuItem<string>;
                    removeWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        track: tree_visit.IndexPath[];
                        paths: tree_visit.IndexPath[];
                    }> & Omit<{
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        track: tree_visit.IndexPath[];
                        paths: tree_visit.IndexPath[];
                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        track: tree_visit.IndexPath[];
                        paths: tree_visit.IndexPath[];
                    }> & Omit<{
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        track: tree_visit.IndexPath[];
                        paths: tree_visit.IndexPath[];
                    }, "create">)[K]; } : never) => {
                        node: MenuItem<string>;
                        paths: (tree_visit.IndexPath | undefined)[];
                    };
                    move: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        paths: tree_visit.IndexPath[];
                        to: tree_visit.IndexPath;
                    }> & Omit<{
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        paths: tree_visit.IndexPath[];
                        to: tree_visit.IndexPath;
                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        paths: tree_visit.IndexPath[];
                        to: tree_visit.IndexPath;
                    }> & Omit<{
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        paths: tree_visit.IndexPath[];
                        to: tree_visit.IndexPath;
                    }, "create">)[K]; } : never) => MenuItem<string>;
                    splice: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                        deleteCount?: number | undefined;
                    }> & Omit<{
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                        deleteCount?: number | undefined;
                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                        deleteCount?: number | undefined;
                    }> & Omit<{
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                        deleteCount?: number | undefined;
                    }, "create">)[K]; } : never) => MenuItem<string>;
                    spliceWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                        track: tree_visit.IndexPath[];
                        deleteCount?: number | undefined;
                    }> & Omit<{
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                        track: tree_visit.IndexPath[];
                        deleteCount?: number | undefined;
                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                        track: tree_visit.IndexPath[];
                        deleteCount?: number | undefined;
                    }> & Omit<{
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        nodes: MenuItem<string>[];
                        track: tree_visit.IndexPath[];
                        deleteCount?: number | undefined;
                    }, "create">)[K]; } : never) => {
                        node: MenuItem<string>;
                        paths: (tree_visit.IndexPath | undefined)[];
                    };
                    replace: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        node: MenuItem<string>;
                    }> & Omit<{
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        node: MenuItem<string>;
                    }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2 & NewOptions_3, "create", {
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        node: MenuItem<string>;
                    }> & Omit<{
                        path: tree_visit.IndexPath;
                        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                        node: MenuItem<string>;
                    }, "create">)[K]; } : never) => MenuItem<string>;
                };
                access: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>;
                accessPath: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                get: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string> | undefined;
                ancestors: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
                diagram: (node: MenuItem<string>, options: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string) | (({} & NewOptions & NewOptions_1 & NewOptions_2 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 ? T_1 extends {
                    getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                } ? void | {
                    type?: tree_visit.DiagramType | undefined;
                    flattenSingleChildNodes?: boolean | undefined;
                } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "getLabel", {
                    getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                }> & {
                    type?: tree_visit.DiagramType | undefined;
                    flattenSingleChildNodes?: boolean | undefined;
                } : never : never) extends infer T ? { [K in keyof T]: ({} & NewOptions & NewOptions_1 & NewOptions_2 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 & NewOptions_2 ? T_1 extends {
                    getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                } ? void | {
                    type?: tree_visit.DiagramType | undefined;
                    flattenSingleChildNodes?: boolean | undefined;
                } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "getLabel", {
                    getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
                }> & {
                    type?: tree_visit.DiagramType | undefined;
                    flattenSingleChildNodes?: boolean | undefined;
                } : never : never)[K]; } : never)) => string;
                find: {
                    (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string> | undefined;
                    (node: MenuItem<string>, options: {
                        direction?: tree_visit.TraversalDirection | undefined;
                        predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                    }): MenuItem<string> | undefined;
                    <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S | undefined;
                    <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                        direction?: tree_visit.TraversalDirection | undefined;
                        predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                    }): S | undefined;
                };
                findAll: {
                    (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string>[];
                    (node: MenuItem<string>, options: {
                        direction?: tree_visit.TraversalDirection | undefined;
                        predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                    }): MenuItem<string>[];
                    <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S[];
                    <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                        direction?: tree_visit.TraversalDirection | undefined;
                        predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                    }): S[];
                };
                findPath: {
                    (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath | undefined;
                    (node: MenuItem<string>, options: {
                        direction?: tree_visit.TraversalDirection | undefined;
                        predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                    }): tree_visit.IndexPath | undefined;
                };
                findAllPaths: {
                    (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath[];
                    (node: MenuItem<string>, options: {
                        direction?: tree_visit.TraversalDirection | undefined;
                        predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                    }): tree_visit.IndexPath[];
                };
                entries: (node: MenuItem<string>) => [tree_visit.IndexPath, MenuItem<string>][];
                flat: (node: MenuItem<string>) => MenuItem<string>[];
                reduce: <R>(node: MenuItem<string>, nextResult: (result: R, node: MenuItem<string>, indexPath: tree_visit.IndexPath) => R, initialResult: R) => R;
                map: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R) => R;
                flatMap: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R[]) => R;
                visit: {
                    (node: MenuItem<string>, onEnter: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined): void;
                    (node: MenuItem<string>, options: {
                        direction?: tree_visit.TraversalDirection | undefined;
                        onEnter?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined;
                        onLeave?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.LeaveReturnValue) | undefined;
                    }): void;
                };
                insert: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                }> & Omit<{
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                }> & Omit<{
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                }, "create">)[K]; } : never) => MenuItem<string>;
                insertWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                    track: tree_visit.IndexPath[];
                }> & Omit<{
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                    track: tree_visit.IndexPath[];
                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                    track: tree_visit.IndexPath[];
                }> & Omit<{
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                    track: tree_visit.IndexPath[];
                }, "create">)[K]; } : never) => {
                    node: MenuItem<string>;
                    paths: (tree_visit.IndexPath | undefined)[];
                };
                remove: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    paths: tree_visit.IndexPath[];
                }> & Omit<{
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    paths: tree_visit.IndexPath[];
                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    paths: tree_visit.IndexPath[];
                }> & Omit<{
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    paths: tree_visit.IndexPath[];
                }, "create">)[K]; } : never) => MenuItem<string>;
                removeWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    track: tree_visit.IndexPath[];
                    paths: tree_visit.IndexPath[];
                }> & Omit<{
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    track: tree_visit.IndexPath[];
                    paths: tree_visit.IndexPath[];
                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    track: tree_visit.IndexPath[];
                    paths: tree_visit.IndexPath[];
                }> & Omit<{
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    track: tree_visit.IndexPath[];
                    paths: tree_visit.IndexPath[];
                }, "create">)[K]; } : never) => {
                    node: MenuItem<string>;
                    paths: (tree_visit.IndexPath | undefined)[];
                };
                move: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    paths: tree_visit.IndexPath[];
                    to: tree_visit.IndexPath;
                }> & Omit<{
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    paths: tree_visit.IndexPath[];
                    to: tree_visit.IndexPath;
                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    paths: tree_visit.IndexPath[];
                    to: tree_visit.IndexPath;
                }> & Omit<{
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    paths: tree_visit.IndexPath[];
                    to: tree_visit.IndexPath;
                }, "create">)[K]; } : never) => MenuItem<string>;
                splice: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                    deleteCount?: number | undefined;
                }> & Omit<{
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                    deleteCount?: number | undefined;
                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                    deleteCount?: number | undefined;
                }> & Omit<{
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                    deleteCount?: number | undefined;
                }, "create">)[K]; } : never) => MenuItem<string>;
                spliceWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                    track: tree_visit.IndexPath[];
                    deleteCount?: number | undefined;
                }> & Omit<{
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                    track: tree_visit.IndexPath[];
                    deleteCount?: number | undefined;
                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                    track: tree_visit.IndexPath[];
                    deleteCount?: number | undefined;
                }> & Omit<{
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    nodes: MenuItem<string>[];
                    track: tree_visit.IndexPath[];
                    deleteCount?: number | undefined;
                }, "create">)[K]; } : never) => {
                    node: MenuItem<string>;
                    paths: (tree_visit.IndexPath | undefined)[];
                };
                replace: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    node: MenuItem<string>;
                }> & Omit<{
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    node: MenuItem<string>;
                }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1 & NewOptions_2, "create", {
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    node: MenuItem<string>;
                }> & Omit<{
                    path: tree_visit.IndexPath;
                    create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                    node: MenuItem<string>;
                }, "create">)[K]; } : never) => MenuItem<string>;
            };
            access: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>;
            accessPath: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
            get: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string> | undefined;
            ancestors: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
            diagram: (node: MenuItem<string>, options: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string) | (({} & NewOptions & NewOptions_1 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 ? T_1 extends {
                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
            } ? void | {
                type?: tree_visit.DiagramType | undefined;
                flattenSingleChildNodes?: boolean | undefined;
            } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "getLabel", {
                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
            }> & {
                type?: tree_visit.DiagramType | undefined;
                flattenSingleChildNodes?: boolean | undefined;
            } : never : never) extends infer T ? { [K in keyof T]: ({} & NewOptions & NewOptions_1 extends infer T_1 ? T_1 extends {} & NewOptions & NewOptions_1 ? T_1 extends {
                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
            } ? void | {
                type?: tree_visit.DiagramType | undefined;
                flattenSingleChildNodes?: boolean | undefined;
            } : tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "getLabel", {
                getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
            }> & {
                type?: tree_visit.DiagramType | undefined;
                flattenSingleChildNodes?: boolean | undefined;
            } : never : never)[K]; } : never)) => string;
            find: {
                (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string> | undefined;
                (node: MenuItem<string>, options: {
                    direction?: tree_visit.TraversalDirection | undefined;
                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                }): MenuItem<string> | undefined;
                <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S | undefined;
                <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                    direction?: tree_visit.TraversalDirection | undefined;
                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                }): S | undefined;
            };
            findAll: {
                (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string>[];
                (node: MenuItem<string>, options: {
                    direction?: tree_visit.TraversalDirection | undefined;
                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                }): MenuItem<string>[];
                <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S[];
                <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                    direction?: tree_visit.TraversalDirection | undefined;
                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
                }): S[];
            };
            findPath: {
                (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath | undefined;
                (node: MenuItem<string>, options: {
                    direction?: tree_visit.TraversalDirection | undefined;
                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                }): tree_visit.IndexPath | undefined;
            };
            findAllPaths: {
                (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath[];
                (node: MenuItem<string>, options: {
                    direction?: tree_visit.TraversalDirection | undefined;
                    predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
                }): tree_visit.IndexPath[];
            };
            entries: (node: MenuItem<string>) => [tree_visit.IndexPath, MenuItem<string>][];
            flat: (node: MenuItem<string>) => MenuItem<string>[];
            reduce: <R>(node: MenuItem<string>, nextResult: (result: R, node: MenuItem<string>, indexPath: tree_visit.IndexPath) => R, initialResult: R) => R;
            map: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R) => R;
            flatMap: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R[]) => R;
            visit: {
                (node: MenuItem<string>, onEnter: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined): void;
                (node: MenuItem<string>, options: {
                    direction?: tree_visit.TraversalDirection | undefined;
                    onEnter?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined;
                    onLeave?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.LeaveReturnValue) | undefined;
                }): void;
            };
            insert: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
            }> & Omit<{
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
            }> & Omit<{
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
            }, "create">)[K]; } : never) => MenuItem<string>;
            insertWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
                track: tree_visit.IndexPath[];
            }> & Omit<{
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
                track: tree_visit.IndexPath[];
            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
                track: tree_visit.IndexPath[];
            }> & Omit<{
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
                track: tree_visit.IndexPath[];
            }, "create">)[K]; } : never) => {
                node: MenuItem<string>;
                paths: (tree_visit.IndexPath | undefined)[];
            };
            remove: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                paths: tree_visit.IndexPath[];
            }> & Omit<{
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                paths: tree_visit.IndexPath[];
            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                paths: tree_visit.IndexPath[];
            }> & Omit<{
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                paths: tree_visit.IndexPath[];
            }, "create">)[K]; } : never) => MenuItem<string>;
            removeWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                track: tree_visit.IndexPath[];
                paths: tree_visit.IndexPath[];
            }> & Omit<{
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                track: tree_visit.IndexPath[];
                paths: tree_visit.IndexPath[];
            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                track: tree_visit.IndexPath[];
                paths: tree_visit.IndexPath[];
            }> & Omit<{
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                track: tree_visit.IndexPath[];
                paths: tree_visit.IndexPath[];
            }, "create">)[K]; } : never) => {
                node: MenuItem<string>;
                paths: (tree_visit.IndexPath | undefined)[];
            };
            move: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                paths: tree_visit.IndexPath[];
                to: tree_visit.IndexPath;
            }> & Omit<{
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                paths: tree_visit.IndexPath[];
                to: tree_visit.IndexPath;
            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                paths: tree_visit.IndexPath[];
                to: tree_visit.IndexPath;
            }> & Omit<{
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                paths: tree_visit.IndexPath[];
                to: tree_visit.IndexPath;
            }, "create">)[K]; } : never) => MenuItem<string>;
            splice: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
                deleteCount?: number | undefined;
            }> & Omit<{
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
                deleteCount?: number | undefined;
            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
                deleteCount?: number | undefined;
            }> & Omit<{
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
                deleteCount?: number | undefined;
            }, "create">)[K]; } : never) => MenuItem<string>;
            spliceWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
                track: tree_visit.IndexPath[];
                deleteCount?: number | undefined;
            }> & Omit<{
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
                track: tree_visit.IndexPath[];
                deleteCount?: number | undefined;
            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
                track: tree_visit.IndexPath[];
                deleteCount?: number | undefined;
            }> & Omit<{
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                nodes: MenuItem<string>[];
                track: tree_visit.IndexPath[];
                deleteCount?: number | undefined;
            }, "create">)[K]; } : never) => {
                node: MenuItem<string>;
                paths: (tree_visit.IndexPath | undefined)[];
            };
            replace: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                node: MenuItem<string>;
            }> & Omit<{
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                node: MenuItem<string>;
            }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions & NewOptions_1, "create", {
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                node: MenuItem<string>;
            }> & Omit<{
                path: tree_visit.IndexPath;
                create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
                node: MenuItem<string>;
            }, "create">)[K]; } : never) => MenuItem<string>;
        };
        access: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>;
        accessPath: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
        get: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string> | undefined;
        ancestors: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
        diagram: (node: MenuItem<string>, options: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string) | (({} & NewOptions extends infer T_1 ? T_1 extends {} & NewOptions ? T_1 extends {
            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
        } ? void | {
            type?: tree_visit.DiagramType | undefined;
            flattenSingleChildNodes?: boolean | undefined;
        } : tree_visit_lib_types.OptionCheck<{} & NewOptions, "getLabel", {
            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
        }> & {
            type?: tree_visit.DiagramType | undefined;
            flattenSingleChildNodes?: boolean | undefined;
        } : never : never) extends infer T ? { [K in keyof T]: ({} & NewOptions extends infer T_1 ? T_1 extends {} & NewOptions ? T_1 extends {
            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
        } ? void | {
            type?: tree_visit.DiagramType | undefined;
            flattenSingleChildNodes?: boolean | undefined;
        } : tree_visit_lib_types.OptionCheck<{} & NewOptions, "getLabel", {
            getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
        }> & {
            type?: tree_visit.DiagramType | undefined;
            flattenSingleChildNodes?: boolean | undefined;
        } : never : never)[K]; } : never)) => string;
        find: {
            (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string> | undefined;
            (node: MenuItem<string>, options: {
                direction?: tree_visit.TraversalDirection | undefined;
                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
            }): MenuItem<string> | undefined;
            <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S | undefined;
            <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                direction?: tree_visit.TraversalDirection | undefined;
                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
            }): S | undefined;
        };
        findAll: {
            (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string>[];
            (node: MenuItem<string>, options: {
                direction?: tree_visit.TraversalDirection | undefined;
                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
            }): MenuItem<string>[];
            <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S[];
            <S extends MenuItem<string>>(node: MenuItem<string>, options: {
                direction?: tree_visit.TraversalDirection | undefined;
                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
            }): S[];
        };
        findPath: {
            (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath | undefined;
            (node: MenuItem<string>, options: {
                direction?: tree_visit.TraversalDirection | undefined;
                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
            }): tree_visit.IndexPath | undefined;
        };
        findAllPaths: {
            (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath[];
            (node: MenuItem<string>, options: {
                direction?: tree_visit.TraversalDirection | undefined;
                predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
            }): tree_visit.IndexPath[];
        };
        entries: (node: MenuItem<string>) => [tree_visit.IndexPath, MenuItem<string>][];
        flat: (node: MenuItem<string>) => MenuItem<string>[];
        reduce: <R>(node: MenuItem<string>, nextResult: (result: R, node: MenuItem<string>, indexPath: tree_visit.IndexPath) => R, initialResult: R) => R;
        map: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R) => R;
        flatMap: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R[]) => R;
        visit: {
            (node: MenuItem<string>, onEnter: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined): void;
            (node: MenuItem<string>, options: {
                direction?: tree_visit.TraversalDirection | undefined;
                onEnter?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined;
                onLeave?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.LeaveReturnValue) | undefined;
            }): void;
        };
        insert: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
        }> & Omit<{
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
        }> & Omit<{
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
        }, "create">)[K]; } : never) => MenuItem<string>;
        insertWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
            track: tree_visit.IndexPath[];
        }> & Omit<{
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
            track: tree_visit.IndexPath[];
        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
            track: tree_visit.IndexPath[];
        }> & Omit<{
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
            track: tree_visit.IndexPath[];
        }, "create">)[K]; } : never) => {
            node: MenuItem<string>;
            paths: (tree_visit.IndexPath | undefined)[];
        };
        remove: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            paths: tree_visit.IndexPath[];
        }> & Omit<{
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            paths: tree_visit.IndexPath[];
        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            paths: tree_visit.IndexPath[];
        }> & Omit<{
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            paths: tree_visit.IndexPath[];
        }, "create">)[K]; } : never) => MenuItem<string>;
        removeWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            track: tree_visit.IndexPath[];
            paths: tree_visit.IndexPath[];
        }> & Omit<{
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            track: tree_visit.IndexPath[];
            paths: tree_visit.IndexPath[];
        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            track: tree_visit.IndexPath[];
            paths: tree_visit.IndexPath[];
        }> & Omit<{
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            track: tree_visit.IndexPath[];
            paths: tree_visit.IndexPath[];
        }, "create">)[K]; } : never) => {
            node: MenuItem<string>;
            paths: (tree_visit.IndexPath | undefined)[];
        };
        move: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            paths: tree_visit.IndexPath[];
            to: tree_visit.IndexPath;
        }> & Omit<{
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            paths: tree_visit.IndexPath[];
            to: tree_visit.IndexPath;
        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            paths: tree_visit.IndexPath[];
            to: tree_visit.IndexPath;
        }> & Omit<{
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            paths: tree_visit.IndexPath[];
            to: tree_visit.IndexPath;
        }, "create">)[K]; } : never) => MenuItem<string>;
        splice: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
            deleteCount?: number | undefined;
        }> & Omit<{
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
            deleteCount?: number | undefined;
        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
            deleteCount?: number | undefined;
        }> & Omit<{
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
            deleteCount?: number | undefined;
        }, "create">)[K]; } : never) => MenuItem<string>;
        spliceWithPathTracking: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
            track: tree_visit.IndexPath[];
            deleteCount?: number | undefined;
        }> & Omit<{
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
            track: tree_visit.IndexPath[];
            deleteCount?: number | undefined;
        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
            track: tree_visit.IndexPath[];
            deleteCount?: number | undefined;
        }> & Omit<{
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            nodes: MenuItem<string>[];
            track: tree_visit.IndexPath[];
            deleteCount?: number | undefined;
        }, "create">)[K]; } : never) => {
            node: MenuItem<string>;
            paths: (tree_visit.IndexPath | undefined)[];
        };
        replace: (node: MenuItem<string>, options: tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            node: MenuItem<string>;
        }> & Omit<{
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            node: MenuItem<string>;
        }, "create"> extends infer T ? { [K in keyof T]: (tree_visit_lib_types.OptionCheck<{} & NewOptions, "create", {
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            node: MenuItem<string>;
        }> & Omit<{
            path: tree_visit.IndexPath;
            create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
            node: MenuItem<string>;
        }, "create">)[K]; } : never) => MenuItem<string>;
    };
    access: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>;
    accessPath: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
    get: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string> | undefined;
    ancestors: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => MenuItem<string>[];
    diagram: (node: MenuItem<string>, options: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string) | {
        getLabel: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => string;
        type?: tree_visit.DiagramType | undefined;
        flattenSingleChildNodes?: boolean | undefined;
    }) => string;
    find: {
        (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string> | undefined;
        (node: MenuItem<string>, options: {
            direction?: tree_visit.TraversalDirection | undefined;
            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
        }): MenuItem<string> | undefined;
        <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S | undefined;
        <S extends MenuItem<string>>(node: MenuItem<string>, options: {
            direction?: tree_visit.TraversalDirection | undefined;
            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
        }): S | undefined;
    };
    findAll: {
        (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): MenuItem<string>[];
        (node: MenuItem<string>, options: {
            direction?: tree_visit.TraversalDirection | undefined;
            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
        }): MenuItem<string>[];
        <S extends MenuItem<string>>(node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S): S[];
        <S extends MenuItem<string>>(node: MenuItem<string>, options: {
            direction?: tree_visit.TraversalDirection | undefined;
            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => node is S;
        }): S[];
    };
    findPath: {
        (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath | undefined;
        (node: MenuItem<string>, options: {
            direction?: tree_visit.TraversalDirection | undefined;
            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
        }): tree_visit.IndexPath | undefined;
    };
    findAllPaths: {
        (node: MenuItem<string>, predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean): tree_visit.IndexPath[];
        (node: MenuItem<string>, options: {
            direction?: tree_visit.TraversalDirection | undefined;
            predicate: (node: MenuItem<string>, indexPath: tree_visit.IndexPath) => boolean;
        }): tree_visit.IndexPath[];
    };
    entries: (node: MenuItem<string>) => [tree_visit.IndexPath, MenuItem<string>][];
    flat: (node: MenuItem<string>) => MenuItem<string>[];
    reduce: <R>(node: MenuItem<string>, nextResult: (result: R, node: MenuItem<string>, indexPath: tree_visit.IndexPath) => R, initialResult: R) => R;
    map: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R) => R;
    flatMap: <R>(node: MenuItem<string>, transform: (node: MenuItem<string>, transformedChildren: R[], indexPath: tree_visit.IndexPath) => R[]) => R;
    visit: {
        (node: MenuItem<string>, onEnter: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined): void;
        (node: MenuItem<string>, options: {
            direction?: tree_visit.TraversalDirection | undefined;
            onEnter?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.EnterReturnValue) | undefined;
            onLeave?: ((node: MenuItem<string>, indexPath: tree_visit.IndexPath) => tree_visit.LeaveReturnValue) | undefined;
        }): void;
    };
    insert: (node: MenuItem<string>, options: {
        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
        path: tree_visit.IndexPath;
        nodes: MenuItem<string>[];
    }) => MenuItem<string>;
    insertWithPathTracking: (node: MenuItem<string>, options: {
        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
        path: tree_visit.IndexPath;
        nodes: MenuItem<string>[];
        track: tree_visit.IndexPath[];
    }) => {
        node: MenuItem<string>;
        paths: (tree_visit.IndexPath | undefined)[];
    };
    remove: (node: MenuItem<string>, options: {
        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
        paths: tree_visit.IndexPath[];
    }) => MenuItem<string>;
    removeWithPathTracking: (node: MenuItem<string>, options: {
        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
        track: tree_visit.IndexPath[];
        paths: tree_visit.IndexPath[];
    }) => {
        node: MenuItem<string>;
        paths: (tree_visit.IndexPath | undefined)[];
    };
    move: (node: MenuItem<string>, options: {
        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
        paths: tree_visit.IndexPath[];
        to: tree_visit.IndexPath;
    }) => MenuItem<string>;
    splice: (node: MenuItem<string>, options: {
        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
        path: tree_visit.IndexPath;
        nodes: MenuItem<string>[];
        deleteCount?: number | undefined;
    }) => MenuItem<string>;
    spliceWithPathTracking: (node: MenuItem<string>, options: {
        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
        path: tree_visit.IndexPath;
        nodes: MenuItem<string>[];
        track: tree_visit.IndexPath[];
        deleteCount?: number | undefined;
    }) => {
        node: MenuItem<string>;
        paths: (tree_visit.IndexPath | undefined)[];
    };
    replace: (node: MenuItem<string>, options: {
        create: (node: MenuItem<string>, children: MenuItem<string>[], indexPath: tree_visit.IndexPath) => MenuItem<string>;
        path: tree_visit.IndexPath;
        node: MenuItem<string>;
    }) => MenuItem<string>;
};
type ShortcutMenuItem<T extends string> = SelectableMenuItem<T> & {
    shortcut: string;
};
declare const getSelectableMenuItems: <T extends string>(menuItems: MenuItem<T>[]) => SelectableMenuItem<T>[];
declare const getShortcutMenuItems: <T extends string>(menuItems: MenuItem<T>[]) => ShortcutMenuItem<T>[];

export { AssetManager, AssetStoreIndexedDB, ClientToServerMessage, DrainInputQueueOptions, type EditOptions, type EmbeddedHost, type EmbeddedHostOptions, ExtendedPatch, ExtendedPathKey, ExtractRequestBody, ExtractResponseBody, GIT_BUNDLE_CONTENT_TYPE, HistoryEntries, HistoryEntry, InputQueueItem, type InputQueueStore, type InterpolationSample, LocalAssetStorageAdapter, LocalGitFileEditor, type LocalGitFileEditorOptions, type LocalStorageMigrationOptions, type LocalStorageSyncOptions, MAX_INPUT_QUEUE_LENGTH, MenuItemTree, NoyaManager, ParentFrameSyncOptions, type ParentRpcBridgeOptions, ParentToEmbeddedMessage, type PredictionSample, type ProcessLocalStorageMessageOptions, type RPCError, type RPCFetchOptions, type RPCManagerMessage, type RPCRequest, type RPCResponse, type RPCStreamChunk, type RPCStreamEnd, type RouteEmbeddedMultiplayerOptions, Routes, SerializableRequest, SerializableResponse, ServerScriptManagerOptions, ServerToClientMessage, type ShortcutMenuItem, SimplePatch, StateInterpolator, type StateInterpolatorOptions, StoreAsset, type StoredInputQueueEntry, SyncAdapter, SyncConfig, SyncOptionsBase, SyncURLOption, UploadProgress, WebSocketSyncOptions, addPathPrefixToEditOptions, applyServerMessage, bridgeRpcRequestToLocalAssets, bridgeRpcRequestToNetwork, castValue, checkType, checkTypeSafe, clearConnectionQueue, clientId$, clientImage$, clientName$, createEmbeddedHost, createOrCastValue, createPipelineRunRequest, createSecretRequest, createValue, deleteSecretRequest, diff, diffString, drainInputQueue, enqueueInput, ensureLocalAssetStore, ensureLocalResourceStore, fetchRPC, fetchRPCStream, forwardConnectionEventsToChild, getOfflineStorageKey, getSelectableMenuItems, getShortcutMenuItems, handleAdapterMessage, isEmbeddedApp, jwt, localStorageSync, parentFrameSync, populateLocalStorageSync, processLocalStorageMessage, routeEmbeddedMultiplayerMessage, sendLocalInitializationMessages, setClientId, setClientImage, setClientName, stubSync, webSocketSync };