import { G as DevToolsMessageHandle, J as DevToolsMessagesHost$1, T as DevToolsViewIframe, U as DevToolsMessageEntryInput, V as DevToolsMessageEntry, a as CreateKitContextOptions, b as DevToolsDockHost$1, c as DevToolsChildProcessExecuteOptions, d as DevToolsTerminalSession, f as DevToolsTerminalSessionBase, g as DevToolsDockEntry, l as DevToolsChildProcessTerminalSession, m as ClientScriptEntry, o as KitNodeContext, s as createKitContext, t as PluginWithDevTools, u as DevToolsTerminalHost$1, x as DevToolsDockUserEntry } from "../vite-augment-B0rA_vwL.js";
import { a as DevToolsCommandHandle, c as DevToolsCommandsHost$1, d as DevToolsServerCommandInput, t as DevToolsDocksUserSettings, u as DevToolsServerCommandEntry } from "../settings-DfhMlk_9.js";
import { SharedState } from "devframe/utils/shared-state";
import { DevToolsCapabilities, DevToolsHost, DevtoolDefinition } from "devframe/types";
import { ResolvedConfig, ViteDevServer } from "vite";

//#region src/node/create-plugin-from-devframe.d.ts
interface CreatePluginFromDevframeOptions {
  /**
   * Vite plugin name override. Defaults to `devframe:${d.id}`.
   */
  name?: string;
  /**
   * Mount path override. Defaults to `d.basePath` or `/__${d.id}/`.
   */
  base?: string;
  /**
   * Overrides for the auto-synthesized iframe dock entry. Use this to
   * customize the entry's `category`, override the icon, hide it via
   * `when`, etc. Cannot change `id`, `type`, or `url` — those are
   * derived from the devtool definition.
   */
  dock?: Partial<Omit<DevToolsViewIframe, 'id' | 'type' | 'url'>>;
  /**
   * Capability flags forwarded onto the kit plugin's `devtools` slot.
   * Defaults to `d.capabilities`.
   */
  capabilities?: DevToolsCapabilities | {
    dev?: DevToolsCapabilities | boolean;
    build?: DevToolsCapabilities | boolean;
  };
  /**
   * Additional kit-only setup hook. Runs after the devframe-level
   * `d.setup(ctx)` and after the auto-derived dock entry has been
   * registered. Use this for kit-specific behavior that should not
   * bleed into the portable {@link DevtoolDefinition} — e.g.
   * registering terminals/commands/messages, or enriching the
   * synthesized dock entry.
   */
  setup?: (ctx: KitNodeContext) => void | Promise<void>;
}
/**
 * Wrap a {@link DevtoolDefinition} as a Vite plugin that mounts inside
 * `@vitejs/devtools` (Vite DevTools). The kit takes care of mounting
 * the SPA at the resolved base path, synthesizing an iframe dock entry
 * from the definition's metadata, and threading the kit-augmented
 * context into both the devframe-level `d.setup` and the optional
 * `options.setup` hook.
 *
 * For richer kit-specific behavior (registering terminals/commands,
 * adding additional dock entries), use `options.setup`.
 */
declare function createPluginFromDevframe(d: DevtoolDefinition, options?: CreatePluginFromDevframeOptions): PluginWithDevTools;
//#endregion
//#region src/node/host-commands.d.ts
declare class DevToolsCommandsHost implements DevToolsCommandsHost$1 {
  readonly context: KitNodeContext;
  readonly commands: DevToolsCommandsHost$1['commands'];
  readonly events: DevToolsCommandsHost$1['events'];
  constructor(context: KitNodeContext);
  register(command: DevToolsServerCommandInput): DevToolsCommandHandle;
  unregister(id: string): boolean;
  execute(id: string, ...args: any[]): Promise<unknown>;
  list(): DevToolsServerCommandEntry[];
  private findCommand;
  private toSerializable;
}
//#endregion
//#region src/node/host-docks.d.ts
declare class DevToolsDockHost implements DevToolsDockHost$1 {
  readonly context: KitNodeContext;
  readonly views: DevToolsDockHost$1['views'];
  readonly events: DevToolsDockHost$1['events'];
  userSettings: SharedState<DevToolsDocksUserSettings>;
  /** Dock-id → allocated remote token + resolved options. */
  private readonly remoteDocks;
  constructor(context: KitNodeContext);
  init(): Promise<void>;
  values({
    includeBuiltin
  }?: {
    includeBuiltin?: boolean;
  }): DevToolsDockEntry[];
  private projectView;
  private resolveDevServerOrigin;
  register<T extends DevToolsDockUserEntry>(view: T, force?: boolean): {
    update: (patch: Partial<T>) => void;
  };
  update(view: DevToolsDockUserEntry): void;
  private prepareRemoteRegistration;
}
//#endregion
//#region src/node/host-messages.d.ts
declare class DevToolsMessagesHost implements DevToolsMessagesHost$1 {
  readonly context: KitNodeContext;
  readonly entries: DevToolsMessagesHost$1['entries'];
  readonly events: DevToolsMessagesHost$1['events'];
  /** Tracks when each entry was last added or updated (monotonic) */
  readonly lastModified: Map<string, number>;
  /** Tracks recently removed entry IDs with their removal time */
  readonly removals: Array<{
    id: string;
    time: number;
  }>;
  private _autoDeleteTimers;
  private _clock;
  private _tick;
  constructor(context: KitNodeContext);
  add(input: DevToolsMessageEntryInput): Promise<DevToolsMessageHandle>;
  update(id: string, patch: Partial<DevToolsMessageEntryInput>): Promise<DevToolsMessageEntry | undefined>;
  remove(id: string): Promise<void>;
  clear(): Promise<void>;
  private _createHandle;
}
//#endregion
//#region src/node/host-terminals.d.ts
type PartialWithoutId<T extends {
  id: string;
}> = Partial<T> & {
  id: string;
};
declare class DevToolsTerminalHost implements DevToolsTerminalHost$1 {
  readonly context: KitNodeContext;
  readonly sessions: DevToolsTerminalHost$1['sessions'];
  readonly events: DevToolsTerminalHost$1['events'];
  private _boundStreams;
  private _channel?;
  constructor(context: KitNodeContext);
  /**
   * Lazily acquire the streaming channel — `context.rpc` isn't assigned
   * until after every host is constructed, so we can't grab it in the
   * constructor.
   */
  private getStreamingChannel;
  register(session: DevToolsTerminalSession): DevToolsTerminalSession;
  update(patch: PartialWithoutId<DevToolsTerminalSession>): void;
  remove(session: DevToolsTerminalSession): void;
  private bindStream;
  startChildProcess(executeOptions: DevToolsChildProcessExecuteOptions, terminal: Omit<DevToolsTerminalSessionBase, 'status'>): Promise<DevToolsChildProcessTerminalSession>;
}
//#endregion
//#region src/node/utils.d.ts
/**
 * Create a quick `ClientScriptEntry` from an inline function or
 * stringified code. Useful for prototyping `action` / `renderer`
 * dock entries without setting up a separate importable module.
 *
 * @experimental Prefer a proper importable module for production use.
 */
declare function createSimpleClientScript(fn: string | ((ctx: any) => void)): ClientScriptEntry;
//#endregion
//#region src/node/vite-host.d.ts
interface CreateViteDevToolsHostOptions {
  viteConfig: ResolvedConfig;
  viteServer?: ViteDevServer;
  /**
   * Workspace root used as the parent of the per-project storage
   * directory. Threaded in by the consumer (typically resolved via
   * `searchForWorkspaceRoot`). Defaults to `viteConfig.root`.
   */
  workspaceRoot?: string;
}
declare function createViteDevToolsHost(options: CreateViteDevToolsHostOptions): DevToolsHost;
//#endregion
export { CreateKitContextOptions, CreatePluginFromDevframeOptions, CreateViteDevToolsHostOptions, DevToolsCommandsHost, DevToolsDockHost, DevToolsMessagesHost, DevToolsTerminalHost, KitNodeContext, createKitContext, createPluginFromDevframe, createSimpleClientScript, createViteDevToolsHost };