import {
  a as FileSystemDirent,
  c as MkdirOptions,
  d as WriteFileOptions,
  i as FileSystem,
  l as ReadFileOptions,
  n as CpOptions,
  o as FsStat,
  r as FileContent,
  s as InitialFiles,
  t as BufferEncoding,
  u as RmOptions
} from "./interface-CjgTx0Yc.js";
import {
  a as SqlParam,
  c as WorkspaceChangeEvent,
  d as WorkspaceOptions,
  i as SqlBackend,
  l as WorkspaceChangeType,
  n as FileInfo,
  o as SqlSource,
  r as FileStat,
  s as Workspace,
  t as EntryType,
  u as WorkspaceFsLike
} from "./filesystem-BKxpZmkl.js";
import {
  A as StateStat,
  C as StateMkdirOptions,
  D as StateReplaceResult,
  E as StateReplaceInFilesResult,
  M as StateTreeNode,
  N as StateTreeOptions,
  O as StateRmOptions,
  P as StateTreeSummary,
  S as StateJsonWriteOptions,
  T as StateReplaceInFilesOptions,
  _ as StateFindEntry,
  a as StateArchiveExtractResult,
  b as StateJsonUpdateOperation,
  c as StateCapabilities,
  d as StateDirent,
  f as StateEdit,
  g as StateFileSearchResult,
  h as StateFileDetection,
  i as StateArchiveEntry,
  j as StateTextMatch,
  k as StateSearchOptions,
  l as StateCompressionResult,
  m as StateEditPlan,
  n as StateApplyEditsResult,
  o as StateBackend,
  p as StateEditInstruction,
  r as StateArchiveCreateResult,
  s as StateBatchOperationError,
  t as StateApplyEditsOptions,
  u as StateCopyOptions,
  v as StateFindOptions,
  w as StateMoveOptions,
  x as StateJsonUpdateResult,
  y as StateHashOptions
} from "./backend-CuDV4ny1.js";

//#region src/fs/in-memory-fs.d.ts
declare class InMemoryFs implements FileSystem {
  private tree;
  constructor(initialFiles?: InitialFiles);
  writeFileSync(
    path: string,
    content: FileContent,
    options?: WriteFileOptions | BufferEncoding,
    metadata?: {
      mode?: number;
      mtime?: Date;
    }
  ): void;
  writeFileLazy(
    path: string,
    lazy: () => string | Uint8Array | Promise<string | Uint8Array>,
    metadata?: {
      mode?: number;
      mtime?: Date;
    }
  ): void;
  mkdirSync(path: string, options?: MkdirOptions): void;
  readFile(
    path: string,
    options?: ReadFileOptions | BufferEncoding
  ): Promise<string>;
  readFileBytes(path: string): Promise<Uint8Array>;
  writeFile(
    path: string,
    content: string,
    options?: WriteFileOptions | BufferEncoding
  ): Promise<void>;
  writeFileBytes(path: string, content: Uint8Array): Promise<void>;
  appendFile(path: string, content: string | Uint8Array): Promise<void>;
  exists(path: string): Promise<boolean>;
  stat(path: string): Promise<FsStat>;
  lstat(path: string): Promise<FsStat>;
  mkdir(path: string, options?: MkdirOptions): Promise<void>;
  readdir(path: string): Promise<string[]>;
  readdirWithFileTypes(path: string): Promise<FileSystemDirent[]>;
  rm(path: string, options?: RmOptions): Promise<void>;
  cp(src: string, dest: string, options?: CpOptions): Promise<void>;
  mv(src: string, dest: string): Promise<void>;
  symlink(target: string, linkPath: string): Promise<void>;
  link(existingPath: string, newPath: string): Promise<void>;
  readlink(path: string): Promise<string>;
  realpath(path: string): Promise<string>;
  resolvePath(base: string, path: string): string;
  glob(pattern: string): Promise<string[]>;
  chmod(path: string, mode: number): Promise<void>;
  utimes(path: string, _atime: Date, mtime: Date): Promise<void>;
  private resolveNode;
  private locate;
  private canonicalize;
  private insertContent;
  private insertLazy;
  private forceLazy;
  private scaffold;
  private placeNode;
  private deepClone;
  private gather;
  private missing;
}
//#endregion
//#region src/helpers.d.ts
declare function searchTextContent(
  content: string,
  query: string,
  options?: StateSearchOptions
): StateTextMatch[];
//#endregion
//#region src/memory.d.ts
interface FileSystemStateBackendOptions {
  files?: InitialFiles;
  fs?: FileSystem;
}
declare class FileSystemStateBackend implements StateBackend {
  readonly fs: FileSystem;
  constructor(fsOrOptions?: FileSystem | FileSystemStateBackendOptions);
  getCapabilities(): Promise<StateCapabilities>;
  readFile(path: string): Promise<string>;
  readFileBytes(path: string): Promise<Uint8Array>;
  writeFile(path: string, content: string): Promise<void>;
  writeFileBytes(path: string, content: Uint8Array): Promise<void>;
  appendFile(path: string, content: string | Uint8Array): Promise<void>;
  readJson(path: string): Promise<unknown>;
  writeJson(
    path: string,
    value: unknown,
    options?: StateJsonWriteOptions
  ): Promise<void>;
  queryJson(path: string, query: string): Promise<unknown>;
  updateJson(
    path: string,
    operations: StateJsonUpdateOperation[]
  ): Promise<StateJsonUpdateResult>;
  exists(path: string): Promise<boolean>;
  stat(path: string): Promise<StateStat | null>;
  lstat(path: string): Promise<StateStat | null>;
  mkdir(path: string, options?: StateMkdirOptions): Promise<void>;
  readdir(path: string): Promise<string[]>;
  readdirWithFileTypes(path: string): Promise<StateDirent[]>;
  find(path: string, options?: StateFindOptions): Promise<StateFindEntry[]>;
  walkTree(path: string, options?: StateTreeOptions): Promise<StateTreeNode>;
  summarizeTree(
    path: string,
    options?: StateTreeOptions
  ): Promise<StateTreeSummary>;
  searchText(
    path: string,
    query: string,
    options?: StateSearchOptions
  ): Promise<ReturnType<typeof searchTextContent>>;
  searchFiles(
    pattern: string,
    query: string,
    options?: StateSearchOptions
  ): Promise<StateFileSearchResult[]>;
  replaceInFile(
    path: string,
    search: string,
    replacement: string,
    options?: StateSearchOptions
  ): Promise<StateReplaceResult>;
  replaceInFiles(
    pattern: string,
    search: string,
    replacement: string,
    options?: StateReplaceInFilesOptions
  ): Promise<StateReplaceInFilesResult>;
  rm(path: string, options?: StateRmOptions): Promise<void>;
  cp(src: string, dest: string, options?: StateCopyOptions): Promise<void>;
  mv(src: string, dest: string, options?: StateMoveOptions): Promise<void>;
  symlink(target: string, linkPath: string): Promise<void>;
  readlink(path: string): Promise<string>;
  realpath(path: string): Promise<string>;
  resolvePath(base: string, path: string): Promise<string>;
  glob(pattern: string): Promise<string[]>;
  diff(pathA: string, pathB: string): Promise<string>;
  diffContent(path: string, newContent: string): Promise<string>;
  createArchive(
    path: string,
    sources: string[]
  ): Promise<StateArchiveCreateResult>;
  listArchive(path: string): Promise<StateArchiveEntry[]>;
  extractArchive(
    path: string,
    destination: string
  ): Promise<StateArchiveExtractResult>;
  compressFile(
    path: string,
    destination?: string
  ): Promise<StateCompressionResult>;
  decompressFile(
    path: string,
    destination?: string
  ): Promise<StateCompressionResult>;
  hashFile(path: string, options?: StateHashOptions): Promise<string>;
  detectFile(path: string): Promise<StateFileDetection>;
  removeTree(path: string): Promise<void>;
  copyTree(src: string, dest: string): Promise<void>;
  moveTree(src: string, dest: string): Promise<void>;
  planEdits(instructions: StateEditInstruction[]): Promise<StateEditPlan>;
  applyEditPlan(
    plan: StateEditPlan,
    options?: StateApplyEditsOptions
  ): Promise<StateApplyEditsResult>;
  applyEdits(
    edits: StateEdit[],
    options?: StateApplyEditsOptions
  ): Promise<StateApplyEditsResult>;
  private tryStat;
  private getFilePaths;
  private deleteFile;
  private createTreeOps;
  private collectArchiveEntries;
}
declare function createMemoryStateBackend(
  options?: FileSystemStateBackendOptions
): FileSystemStateBackend;
//#endregion
//#region src/workspace.d.ts
declare class WorkspaceFileSystem implements FileSystem {
  private readonly ws;
  constructor(ws: WorkspaceFsLike);
  readFile(path: string): Promise<string>;
  readFileBytes(path: string): Promise<Uint8Array>;
  writeFile(path: string, content: string): Promise<void>;
  writeFileBytes(path: string, content: Uint8Array): Promise<void>;
  appendFile(path: string, content: string | Uint8Array): Promise<void>;
  exists(path: string): Promise<boolean>;
  stat(path: string): Promise<FsStat>;
  lstat(path: string): Promise<FsStat>;
  mkdir(
    path: string,
    options?: {
      recursive?: boolean;
    }
  ): Promise<void>;
  readdir(path: string): Promise<string[]>;
  readdirWithFileTypes(path: string): Promise<FileSystemDirent[]>;
  rm(
    path: string,
    options?: {
      recursive?: boolean;
      force?: boolean;
    }
  ): Promise<void>;
  cp(
    src: string,
    dest: string,
    options?: {
      recursive?: boolean;
    }
  ): Promise<void>;
  mv(src: string, dest: string): Promise<void>;
  symlink(target: string, linkPath: string): Promise<void>;
  readlink(path: string): Promise<string>;
  realpath(path: string, _depth?: number): Promise<string>;
  resolvePath(base: string, path: string): string;
  glob(pattern: string): Promise<string[]>;
}
/**
 * Wrap a `Workspace` (or any `WorkspaceFsLike` — e.g. a cross-DO proxy
 * forwarding each call to a parent agent's workspace over RPC) in a
 * `FileSystemStateBackend` suitable for codemode's `state.*` sandbox
 * API. The backend reuses `WorkspaceFileSystem` as its adapter, so
 * every caller gets identical ENOENT and stat-normalization semantics.
 */
declare function createWorkspaceStateBackend(
  workspace: WorkspaceFsLike
): FileSystemStateBackend;
//#endregion
//#region src/prompt.d.ts
/**
 * TypeScript declaration for the `state` object injected into every isolate
 * execution. Export this string in prompts so the LLM knows the exact API it
 * can call.
 *
 * Usage:
 *   import { STATE_TYPES, STATE_SYSTEM_PROMPT } from "@cloudflare/shell";
 *
 *   system: STATE_SYSTEM_PROMPT.replace("{{types}}", STATE_TYPES)
 */
declare const STATE_TYPES: string;
/**
 * System-prompt template for using the `state` runtime.
 * Replace `{{types}}` with `STATE_TYPES` before passing to the model.
 *
 * Example:
 *   import { STATE_TYPES, STATE_SYSTEM_PROMPT } from "@cloudflare/shell";
 *   const system = STATE_SYSTEM_PROMPT.replace("{{types}}", STATE_TYPES);
 */
declare const STATE_SYSTEM_PROMPT: string;
//#endregion
export {
  type EntryType,
  type FileInfo,
  type FileStat,
  type FileSystem,
  FileSystemStateBackend,
  type FileSystemStateBackendOptions,
  type FsStat,
  InMemoryFs,
  type InitialFiles,
  STATE_SYSTEM_PROMPT,
  STATE_TYPES,
  type SqlBackend,
  type SqlParam,
  type SqlSource,
  type StateBackend,
  StateBatchOperationError,
  Workspace,
  type WorkspaceChangeEvent,
  type WorkspaceChangeType,
  WorkspaceFileSystem,
  type WorkspaceFsLike,
  type WorkspaceOptions,
  createMemoryStateBackend,
  createWorkspaceStateBackend
};
//# sourceMappingURL=index.d.ts.map