//#region src/backend.d.ts
type StateEntryType = "file" | "directory" | "symlink";
interface StateCapabilities {
  chmod: boolean;
  utimes: boolean;
  hardLinks: boolean;
}
interface StateDirent {
  name: string;
  type: StateEntryType;
}
interface StateStat {
  type: StateEntryType;
  size: number;
  mtime: Date;
  mode?: number;
}
interface StateMkdirOptions {
  recursive?: boolean;
}
interface StateRmOptions {
  recursive?: boolean;
  force?: boolean;
}
interface StateCopyOptions {
  recursive?: boolean;
}
interface StateMoveOptions {
  recursive?: boolean;
}
interface StateJsonWriteOptions {
  spaces?: number;
}
interface StateSearchOptions {
  caseSensitive?: boolean;
  regex?: boolean;
  wholeWord?: boolean;
  contextBefore?: number;
  contextAfter?: number;
  maxMatches?: number;
}
interface StateTextMatch {
  line: number;
  column: number;
  match: string;
  lineText: string;
  beforeLines?: string[];
  afterLines?: string[];
}
interface StateFindOptions {
  name?: string;
  pathPattern?: string;
  type?: StateEntryType | StateEntryType[];
  minDepth?: number;
  maxDepth?: number;
  empty?: boolean;
  sizeMin?: number;
  sizeMax?: number;
  mtimeAfter?: string | Date;
  mtimeBefore?: string | Date;
}
interface StateFindEntry {
  path: string;
  name: string;
  type: StateEntryType;
  depth: number;
  size: number;
  mtime: Date;
}
type StateJsonUpdateOperation =
  | {
      op: "set";
      path: string;
      value: unknown;
    }
  | {
      op: "delete";
      path: string;
    };
interface StateJsonUpdateResult {
  value: unknown;
  content: string;
  diff: string;
  operationsApplied: number;
}
interface StateArchiveEntry {
  path: string;
  type: "file" | "directory";
  size: number;
}
interface StateArchiveCreateResult {
  path: string;
  entries: StateArchiveEntry[];
  bytesWritten: number;
}
interface StateArchiveExtractResult {
  destination: string;
  entries: StateArchiveEntry[];
}
interface StateCompressionResult {
  path: string;
  destination: string;
  bytesWritten: number;
}
interface StateTreeOptions {
  maxDepth?: number;
}
interface StateTreeNode {
  path: string;
  name: string;
  type: StateEntryType;
  size: number;
  children?: StateTreeNode[];
}
interface StateTreeSummary {
  files: number;
  directories: number;
  symlinks: number;
  totalBytes: number;
  maxDepth: number;
}
interface StateFileDetection {
  mime: string;
  description: string;
  extension?: string;
  binary: boolean;
}
interface StateHashOptions {
  algorithm?: "md5" | "sha1" | "sha256";
}
interface StateReplaceResult {
  replaced: number;
  content: string;
}
interface StateFileSearchResult {
  path: string;
  matches: StateTextMatch[];
}
interface StateReplaceInFilesOptions extends StateSearchOptions {
  dryRun?: boolean;
  rollbackOnError?: boolean;
}
interface StateFileReplaceResult {
  path: string;
  replaced: number;
  content: string;
  diff: string;
}
interface StateReplaceInFilesResult {
  dryRun: boolean;
  files: StateFileReplaceResult[];
  totalFiles: number;
  totalReplacements: number;
}
interface StateEdit {
  path: string;
  content: string;
}
interface StateWriteEditInstruction {
  kind: "write";
  path: string;
  content: string;
}
interface StateReplaceEditInstruction {
  kind: "replace";
  path: string;
  search: string;
  replacement: string;
  options?: StateSearchOptions;
}
interface StateWriteJsonEditInstruction {
  kind: "writeJson";
  path: string;
  value: unknown;
  options?: StateJsonWriteOptions;
}
type StateEditInstruction =
  | StateWriteEditInstruction
  | StateReplaceEditInstruction
  | StateWriteJsonEditInstruction;
interface StateApplyEditsOptions {
  dryRun?: boolean;
  rollbackOnError?: boolean;
}
interface StateAppliedEditResult {
  path: string;
  changed: boolean;
  content: string;
  diff: string;
}
interface StateApplyEditsResult {
  dryRun: boolean;
  edits: StateAppliedEditResult[];
  totalChanged: number;
}
interface StatePlannedEdit {
  instruction: StateEditInstruction;
  path: string;
  changed: boolean;
  content: string;
  diff: string;
}
interface StateEditPlan {
  edits: StatePlannedEdit[];
  totalChanged: number;
  totalInstructions: number;
}
declare class StateBatchOperationError extends Error {
  readonly operation: "replaceInFiles" | "applyEdits";
  readonly rolledBack: boolean;
  readonly rollbackError?: string;
  constructor(options: {
    operation: "replaceInFiles" | "applyEdits";
    message: string;
    rolledBack: boolean;
    rollbackError?: string;
  });
}
interface StateBackend {
  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<StateTextMatch[]>;
  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>;
}
declare const STATE_METHOD_NAMES: readonly [
  "getCapabilities",
  "readFile",
  "readFileBytes",
  "writeFile",
  "writeFileBytes",
  "appendFile",
  "readJson",
  "writeJson",
  "queryJson",
  "updateJson",
  "exists",
  "stat",
  "lstat",
  "mkdir",
  "readdir",
  "readdirWithFileTypes",
  "find",
  "walkTree",
  "summarizeTree",
  "searchText",
  "searchFiles",
  "replaceInFile",
  "replaceInFiles",
  "rm",
  "cp",
  "mv",
  "symlink",
  "readlink",
  "realpath",
  "resolvePath",
  "glob",
  "diff",
  "diffContent",
  "createArchive",
  "listArchive",
  "extractArchive",
  "compressFile",
  "decompressFile",
  "hashFile",
  "detectFile",
  "removeTree",
  "copyTree",
  "moveTree",
  "planEdits",
  "applyEditPlan",
  "applyEdits"
];
type StateMethodName = (typeof STATE_METHOD_NAMES)[number];
//#endregion
export {
  StateSearchOptions as A,
  StateMethodName as C,
  StateReplaceInFilesResult as D,
  StateReplaceInFilesOptions as E,
  StateTreeSummary as F,
  StateTextMatch as M,
  StateTreeNode as N,
  StateReplaceResult as O,
  StateTreeOptions as P,
  StateJsonWriteOptions as S,
  StateMoveOptions as T,
  StateFindEntry as _,
  StateArchiveExtractResult as a,
  StateJsonUpdateOperation as b,
  StateCapabilities as c,
  StateDirent as d,
  StateEdit as f,
  StateFileSearchResult as g,
  StateFileDetection as h,
  StateArchiveEntry as i,
  StateStat as j,
  StateRmOptions as k,
  StateCompressionResult as l,
  StateEditPlan as m,
  StateApplyEditsResult as n,
  StateBackend as o,
  StateEditInstruction as p,
  StateArchiveCreateResult as r,
  StateBatchOperationError as s,
  StateApplyEditsOptions as t,
  StateCopyOptions as u,
  StateFindOptions as v,
  StateMkdirOptions as w,
  StateJsonUpdateResult as x,
  StateHashOptions as y
};
//# sourceMappingURL=backend-CFf0snjM.d.ts.map