import { s as Workspace } from "./filesystem-DfI9_9aL.js";
import { C as StateMethodName, o as StateBackend } from "./backend-CFf0snjM.js";
import {
  CodemodeConnector,
  ConnectorTools,
  ToolProvider
} from "@cloudflare/codemode";

//#region src/connector.d.ts
declare class StateConnector extends CodemodeConnector {
  #private;
  constructor(
    ctx: DurableObjectState | ExecutionContext,
    backend: StateBackend
  );
  name(): string;
  protected instructions(): string;
  protected tools(): ConnectorTools;
  getTypeScriptTypes(): Promise<string>;
}
/**
 * Create a `StateConnector` for `createCodemodeRuntime`.
 *
 * ```ts
 * import { stateConnector, createWorkspaceStateBackend } from "@cloudflare/shell";
 *
 * const runtime = createCodemodeRuntime({
 *   ctx: this.ctx,
 *   executor,
 *   connectors: [
 *     stateConnector(this.ctx, createWorkspaceStateBackend(this.workspace))
 *   ]
 * });
 * ```
 */
declare function stateConnector(
  ctx: DurableObjectState | ExecutionContext,
  backend: StateBackend
): StateConnector;
//#endregion
//#region src/state-methods.d.ts
interface StateMethodSpec {
  /**
   * Positional parameter names, in backend-call order. A trailing `?` marks
   * an optional parameter (all optionals are trailing in `StateBackend`).
   */
  params: readonly string[];
  /** Reads are replayed by re-execution; writes are logged durably. */
  kind: "read" | "write";
  description: string;
}
declare const STATE_METHODS: Record<StateMethodName, StateMethodSpec>;
/**
 * Map a single object argument (`{ path, content }`) to the backend's
 * positional parameter order. Throws when a required parameter is missing,
 * naming the method and the parameter so the sandbox error is actionable.
 */
declare function objectArgsToPositional(
  method: StateMethodName,
  args: unknown
): unknown[];
/**
 * Invoke a `StateBackend` method with a sandbox-style object argument.
 */
declare function callStateMethod(
  backend: StateBackend,
  method: StateMethodName,
  args: unknown
): Promise<unknown>;
//#endregion
//#region src/workers.d.ts
/**
 * Creates a `ToolProvider` that exposes `state.*` inside any
 * codemode sandbox execution.
 *
 * ```ts
 * import { stateTools } from "@cloudflare/shell/workers";
 *
 * createCodeTool({
 *   tools: [
 *     { tools: myTools },
 *     stateTools(workspace),
 *   ],
 *   executor,
 * });
 * // sandbox: codemode.myTool({ query: "test" }) AND state.readFile("/path")
 * ```
 */
declare function stateTools(workspace: Workspace): ToolProvider;
/**
 * Creates a `ToolProvider` from a raw `StateBackend`.
 * Use `stateTools(workspace)` for the common case.
 */
declare function stateToolsFromBackend(backend: StateBackend): ToolProvider;
//#endregion
export {
  STATE_METHODS,
  type StateBackend,
  StateConnector,
  type StateMethodSpec,
  type ToolProvider,
  callStateMethod,
  objectArgsToPositional,
  stateConnector,
  stateTools,
  stateToolsFromBackend
};
//# sourceMappingURL=workers.d.ts.map