@makaio/framework 1.0.0-dev-1779051654000 → 1.0.0-dev-1781023871421

package/dist/services/git/schemas.d.mts

@@ -0,0 +1,932 @@
+import { z } from "zod";
+
+//#region services/core/src/git/schemas/query.d.ts
+/**
+ * Base request schema with optional repoPath.
+ * Defaults to process.cwd() if not specified.
+ */
+declare const BaseRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const GitRepoRootRequestSchema: z.ZodObject<{
+  path: z.ZodString;
+}, z.core.$strip>;
+type GitRepoRootRequest = z.infer<typeof GitRepoRootRequestSchema>;
+declare const GitRepoRootResponseSchema: z.ZodObject<{
+  root: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type GitRepoRootResponse = z.infer<typeof GitRepoRootResponseSchema>;
+declare const GitBranchRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitBranchRequest = z.infer<typeof GitBranchRequestSchema>;
+declare const GitBranchResponseSchema: z.ZodObject<{
+  current: z.ZodString;
+  isDetached: z.ZodBoolean;
+}, z.core.$strip>;
+type GitBranchResponse = z.infer<typeof GitBranchResponseSchema>;
+declare const GitCommitRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  ref: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitCommitRequest = z.infer<typeof GitCommitRequestSchema>;
+declare const GitCommitResponseSchema: z.ZodObject<{
+  hash: z.ZodString;
+  message: z.ZodString;
+  author: z.ZodString;
+  email: z.ZodString;
+  date: z.ZodString;
+}, z.core.$strip>;
+type GitCommitResponse = z.infer<typeof GitCommitResponseSchema>;
+declare const GitCommitDetailsRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  hash: z.ZodString;
+}, z.core.$strip>;
+type GitCommitDetailsRequest = z.infer<typeof GitCommitDetailsRequestSchema>;
+declare const GitFileChangeSchema: z.ZodObject<{
+  path: z.ZodString;
+  oldPath: z.ZodOptional<z.ZodString>;
+  status: z.ZodString;
+  additions: z.ZodNumber;
+  deletions: z.ZodNumber;
+}, z.core.$strip>;
+type GitFileChange = z.infer<typeof GitFileChangeSchema>;
+declare const GitChangeStatsSchema: z.ZodObject<{
+  totalAdditions: z.ZodNumber;
+  totalDeletions: z.ZodNumber;
+  changedFiles: z.ZodNumber;
+}, z.core.$strip>;
+type GitChangeStats = z.infer<typeof GitChangeStatsSchema>;
+declare const GitCommitDetailsResponseSchema: z.ZodObject<{
+  files: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    oldPath: z.ZodOptional<z.ZodString>;
+    status: z.ZodString;
+    additions: z.ZodNumber;
+    deletions: z.ZodNumber;
+  }, z.core.$strip>>;
+  stats: z.ZodObject<{
+    totalAdditions: z.ZodNumber;
+    totalDeletions: z.ZodNumber;
+    changedFiles: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type GitCommitDetailsResponse = z.infer<typeof GitCommitDetailsResponseSchema>;
+declare const GitWorkingTreeDetailsRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitWorkingTreeDetailsRequest = z.infer<typeof GitWorkingTreeDetailsRequestSchema>;
+declare const GitWorkingTreeFileChangeSchema: z.ZodObject<{
+  path: z.ZodString;
+  oldPath: z.ZodOptional<z.ZodString>;
+  additions: z.ZodNumber;
+  deletions: z.ZodNumber;
+}, z.core.$strip>;
+type GitWorkingTreeFileChange = z.infer<typeof GitWorkingTreeFileChangeSchema>;
+declare const GitWorkingTreeDetailsResponseSchema: z.ZodObject<{
+  staged: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    oldPath: z.ZodOptional<z.ZodString>;
+    additions: z.ZodNumber;
+    deletions: z.ZodNumber;
+  }, z.core.$strip>>;
+  unstaged: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    oldPath: z.ZodOptional<z.ZodString>;
+    additions: z.ZodNumber;
+    deletions: z.ZodNumber;
+  }, z.core.$strip>>;
+  untracked: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    oldPath: z.ZodOptional<z.ZodString>;
+    additions: z.ZodNumber;
+    deletions: z.ZodNumber;
+  }, z.core.$strip>>;
+  conflicted: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    oldPath: z.ZodOptional<z.ZodString>;
+    additions: z.ZodNumber;
+    deletions: z.ZodNumber;
+  }, z.core.$strip>>;
+  stats: z.ZodObject<{
+    totalAdditions: z.ZodNumber;
+    totalDeletions: z.ZodNumber;
+    changedFiles: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type GitWorkingTreeDetailsResponse = z.infer<typeof GitWorkingTreeDetailsResponseSchema>;
+declare const GitStatusRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitStatusRequest = z.infer<typeof GitStatusRequestSchema>;
+declare const GitStatusResponseSchema: z.ZodObject<{
+  staged: z.ZodArray<z.ZodString>;
+  modified: z.ZodArray<z.ZodString>;
+  untracked: z.ZodArray<z.ZodString>;
+  conflicted: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type GitStatusResponse = z.infer<typeof GitStatusResponseSchema>;
+declare const GitWorktreesRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitWorktreesRequest = z.infer<typeof GitWorktreesRequestSchema>;
+declare const GitWorktreeInfoSchema: z.ZodObject<{
+  path: z.ZodString;
+  branch: z.ZodString;
+  commit: z.ZodString;
+  isMain: z.ZodBoolean;
+}, z.core.$strip>;
+type GitWorktreeInfo = z.infer<typeof GitWorktreeInfoSchema>;
+declare const GitWorktreesResponseSchema: z.ZodObject<{
+  worktrees: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    branch: z.ZodString;
+    commit: z.ZodString;
+    isMain: z.ZodBoolean;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type GitWorktreesResponse = z.infer<typeof GitWorktreesResponseSchema>;
+declare const GitRemotesRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitRemotesRequest = z.infer<typeof GitRemotesRequestSchema>;
+declare const GitRemoteSchema: z.ZodObject<{
+  name: z.ZodString;
+  fetchUrl: z.ZodString;
+  pushUrl: z.ZodString;
+}, z.core.$strip>;
+type GitRemote = z.infer<typeof GitRemoteSchema>;
+declare const GitRemotesResponseSchema: z.ZodObject<{
+  remotes: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    fetchUrl: z.ZodString;
+    pushUrl: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type GitRemotesResponse = z.infer<typeof GitRemotesResponseSchema>;
+declare const GitDefaultBranchRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitDefaultBranchRequest = z.infer<typeof GitDefaultBranchRequestSchema>;
+declare const GitDefaultBranchResponseSchema: z.ZodObject<{
+  branch: z.ZodString;
+}, z.core.$strip>;
+type GitDefaultBranchResponse = z.infer<typeof GitDefaultBranchResponseSchema>;
+declare const GitLogFiltersSchema: z.ZodObject<{
+  branches: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  branchMode: z.ZodOptional<z.ZodEnum<{
+    all: "all";
+    specific: "specific";
+  }>>;
+  baseBranch: z.ZodOptional<z.ZodString>;
+  paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  author: z.ZodOptional<z.ZodString>;
+  since: z.ZodOptional<z.ZodString>;
+  until: z.ZodOptional<z.ZodString>;
+  searchQuery: z.ZodOptional<z.ZodString>;
+  selectedWorktree: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitLogFilters = z.infer<typeof GitLogFiltersSchema>;
+declare const GitLogRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  limit: z.ZodOptional<z.ZodNumber>;
+  ref: z.ZodOptional<z.ZodString>;
+  filters: z.ZodOptional<z.ZodObject<{
+    branches: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    branchMode: z.ZodOptional<z.ZodEnum<{
+      all: "all";
+      specific: "specific";
+    }>>;
+    baseBranch: z.ZodOptional<z.ZodString>;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    author: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    searchQuery: z.ZodOptional<z.ZodString>;
+    selectedWorktree: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type GitLogRequest = z.infer<typeof GitLogRequestSchema>;
+declare const GitLogCommitSchema: z.ZodObject<{
+  hash: z.ZodString;
+  shortHash: z.ZodString;
+  message: z.ZodString;
+  author: z.ZodString;
+  email: z.ZodString;
+  date: z.ZodString;
+  parents: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type GitLogCommit = z.infer<typeof GitLogCommitSchema>;
+declare const GitRefsSchema: z.ZodObject<{
+  branches: z.ZodRecord<z.ZodString, z.ZodString>;
+  remoteBranches: z.ZodRecord<z.ZodString, z.ZodString>;
+  tags: z.ZodRecord<z.ZodString, z.ZodString>;
+  HEAD: z.ZodString;
+}, z.core.$strip>;
+type GitRefs = z.infer<typeof GitRefsSchema>;
+declare const GitLogResponseSchema: z.ZodObject<{
+  commits: z.ZodArray<z.ZodObject<{
+    hash: z.ZodString;
+    shortHash: z.ZodString;
+    message: z.ZodString;
+    author: z.ZodString;
+    email: z.ZodString;
+    date: z.ZodString;
+    parents: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+  refs: z.ZodObject<{
+    branches: z.ZodRecord<z.ZodString, z.ZodString>;
+    remoteBranches: z.ZodRecord<z.ZodString, z.ZodString>;
+    tags: z.ZodRecord<z.ZodString, z.ZodString>;
+    HEAD: z.ZodString;
+  }, z.core.$strip>;
+  truncated: z.ZodBoolean;
+}, z.core.$strip>;
+type GitLogResponse = z.infer<typeof GitLogResponseSchema>;
+declare const GitFileAtRevisionRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  path: z.ZodString;
+  ref: z.ZodString;
+}, z.core.$strip>;
+type GitFileAtRevisionRequest = z.infer<typeof GitFileAtRevisionRequestSchema>;
+declare const GitFileAtRevisionResponseSchema: z.ZodObject<{
+  content: z.ZodString;
+  isBinary: z.ZodBoolean;
+}, z.core.$strip>;
+type GitFileAtRevisionResponse = z.infer<typeof GitFileAtRevisionResponseSchema>;
+declare const GitDiffRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  ref: z.ZodOptional<z.ZodString>;
+  staged: z.ZodOptional<z.ZodBoolean>;
+  unified: z.ZodOptional<z.ZodNumber>;
+  paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type GitDiffRequest = z.infer<typeof GitDiffRequestSchema>;
+declare const GitDiffResponseSchema: z.ZodObject<{
+  diff: z.ZodString;
+}, z.core.$strip>;
+type GitDiffResponse = z.infer<typeof GitDiffResponseSchema>;
+declare const GetBranchCommitsRequestSchema: z.ZodObject<{
+  branchName: z.ZodString;
+  repoPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GetBranchCommitsRequest = z.infer<typeof GetBranchCommitsRequestSchema>;
+declare const GetBranchCommitsResponseSchema: z.ZodObject<{
+  commitHashes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type GetBranchCommitsResponse = z.infer<typeof GetBranchCommitsResponseSchema>;
+declare const GitSwitchWorktreeRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  worktreePath: z.ZodString;
+}, z.core.$strip>;
+type GitSwitchWorktreeRequest = z.infer<typeof GitSwitchWorktreeRequestSchema>;
+declare const GitSwitchWorktreeResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitSwitchWorktreeResponse = z.infer<typeof GitSwitchWorktreeResponseSchema>;
+/** Request to get blame annotations. */
+declare const GitBlameRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  path: z.ZodString;
+  ref: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitBlameRequest = z.infer<typeof GitBlameRequestSchema>;
+/** A single blame annotation for a contiguous line range. */
+declare const GitBlameLineSchema: z.ZodObject<{
+  startLine: z.ZodNumber;
+  endLine: z.ZodNumber;
+  shortHash: z.ZodString;
+  hash: z.ZodString;
+  author: z.ZodString;
+  date: z.ZodString;
+  message: z.ZodString;
+}, z.core.$strip>;
+type GitBlameLine = z.infer<typeof GitBlameLineSchema>;
+/** Response from blame query. */
+declare const GitBlameResponseSchema: z.ZodObject<{
+  content: z.ZodString;
+  lines: z.ZodArray<z.ZodObject<{
+    startLine: z.ZodNumber;
+    endLine: z.ZodNumber;
+    shortHash: z.ZodString;
+    hash: z.ZodString;
+    author: z.ZodString;
+    date: z.ZodString;
+    message: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type GitBlameResponse = z.infer<typeof GitBlameResponseSchema>;
+declare const GitFileAtCommitRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  filePath: z.ZodString;
+  commitHash: z.ZodString;
+}, z.core.$strip>;
+type GitFileAtCommitRequest = z.infer<typeof GitFileAtCommitRequestSchema>;
+declare const GitFileAtCommitResponseSchema: z.ZodObject<{
+  content: z.ZodNullable<z.ZodString>;
+  isBinary: z.ZodBoolean;
+}, z.core.$strip>;
+type GitFileAtCommitResponse = z.infer<typeof GitFileAtCommitResponseSchema>;
+declare const GitBlobHashAtCommitRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  filePath: z.ZodString;
+  commitHash: z.ZodString;
+}, z.core.$strip>;
+type GitBlobHashAtCommitRequest = z.infer<typeof GitBlobHashAtCommitRequestSchema>;
+declare const GitBlobHashAtCommitResponseSchema: z.ZodObject<{
+  blobHash: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type GitBlobHashAtCommitResponse = z.infer<typeof GitBlobHashAtCommitResponseSchema>;
+/** Request to compute a content-aware fingerprint of repository state. */
+declare const GitFingerprintRequestSchema: z.ZodObject<{
+  repoPath: z.ZodString;
+  include: z.ZodArray<z.ZodString>;
+  exclude: z.ZodArray<z.ZodString>;
+  worktree: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitFingerprintRequest = z.infer<typeof GitFingerprintRequestSchema>;
+/** Response containing the computed fingerprint and metadata. */
+declare const GitFingerprintResponseSchema: z.ZodObject<{
+  hash: z.ZodString;
+  commitSha: z.ZodString;
+  changedPaths: z.ZodArray<z.ZodString>;
+  timestamp: z.ZodString;
+}, z.core.$strip>;
+type GitFingerprintResponse = z.infer<typeof GitFingerprintResponseSchema>;
+//#endregion
+//#region services/core/src/git/schemas/event.d.ts
+/**
+ * Git event schemas.
+ * Emitted by GitService when git operations are detected via file watching.
+ */
+declare const GitCommitEventSchema: z.ZodObject<{
+  repoPath: z.ZodString;
+  hash: z.ZodString;
+  message: z.ZodString;
+  author: z.ZodString;
+  email: z.ZodString;
+  branch: z.ZodString;
+  timestamp: z.ZodString;
+  worktree: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitCommitEvent = z.infer<typeof GitCommitEventSchema>;
+declare const GitCheckoutEventSchema: z.ZodObject<{
+  repoPath: z.ZodString;
+  previousBranch: z.ZodOptional<z.ZodString>;
+  currentBranch: z.ZodString;
+  timestamp: z.ZodString;
+  worktree: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitCheckoutEvent = z.infer<typeof GitCheckoutEventSchema>;
+declare const GitStagingEventSchema: z.ZodObject<{
+  repoPath: z.ZodString;
+  staged: z.ZodArray<z.ZodString>;
+  timestamp: z.ZodString;
+  worktree: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitStagingEvent = z.infer<typeof GitStagingEventSchema>;
+declare const GitMergeEventSchema: z.ZodObject<{
+  repoPath: z.ZodString;
+  sourceBranch: z.ZodString;
+  targetBranch: z.ZodString;
+  mergeCommit: z.ZodString;
+  timestamp: z.ZodString;
+  worktree: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitMergeEvent = z.infer<typeof GitMergeEventSchema>;
+declare const GitRebaseStatusSchema: z.ZodEnum<{
+  completed: "completed";
+  started: "started";
+  aborted: "aborted";
+}>;
+type GitRebaseStatus = z.infer<typeof GitRebaseStatusSchema>;
+declare const GitRebaseEventSchema: z.ZodObject<{
+  repoPath: z.ZodString;
+  branch: z.ZodString;
+  onto: z.ZodString;
+  status: z.ZodEnum<{
+    completed: "completed";
+    started: "started";
+    aborted: "aborted";
+  }>;
+  timestamp: z.ZodString;
+  worktree: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitRebaseEvent = z.infer<typeof GitRebaseEventSchema>;
+declare const GitWorktreeEventSchema: z.ZodObject<{
+  repoPath: z.ZodString;
+  name: z.ZodString;
+  path: z.ZodString;
+  branch: z.ZodString;
+  event: z.ZodEnum<{
+    removed: "removed";
+    added: "added";
+  }>;
+  timestamp: z.ZodString;
+}, z.core.$strip>;
+type GitWorktreeEvent = z.infer<typeof GitWorktreeEventSchema>;
+declare const GitAddRepoRequestSchema: z.ZodObject<{
+  repoPath: z.ZodString;
+}, z.core.$strip>;
+type GitAddRepoRequest = z.infer<typeof GitAddRepoRequestSchema>;
+declare const GitAddRepoResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitAddRepoResponse = z.infer<typeof GitAddRepoResponseSchema>;
+declare const GitRemoveRepoRequestSchema: z.ZodObject<{
+  repoPath: z.ZodString;
+}, z.core.$strip>;
+type GitRemoveRepoRequest = z.infer<typeof GitRemoveRepoRequestSchema>;
+declare const GitRemoveRepoResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+}, z.core.$strip>;
+type GitRemoveRepoResponse = z.infer<typeof GitRemoveRepoResponseSchema>;
+declare const GitInitRepoRequestSchema: z.ZodObject<{
+  path: z.ZodString;
+  defaultBranch: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitInitRepoRequest = z.infer<typeof GitInitRepoRequestSchema>;
+declare const GitInitRepoResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  path: z.ZodString;
+  defaultBranch: z.ZodString;
+}, z.core.$strip>;
+type GitInitRepoResponse = z.infer<typeof GitInitRepoResponseSchema>;
+declare const GitCreateWorktreeRequestSchema: z.ZodObject<{
+  repoPath: z.ZodString;
+  path: z.ZodString;
+  branch: z.ZodString;
+  baseBranch: z.ZodOptional<z.ZodString>;
+  createBranch: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type GitCreateWorktreeRequest = z.infer<typeof GitCreateWorktreeRequestSchema>;
+declare const GitCreateWorktreeResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  path: z.ZodString;
+  branch: z.ZodString;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitCreateWorktreeResponse = z.infer<typeof GitCreateWorktreeResponseSchema>;
+declare const GitRemoveWorktreeRequestSchema: z.ZodObject<{
+  repoPath: z.ZodString;
+  path: z.ZodString;
+  force: z.ZodOptional<z.ZodBoolean>;
+  deleteBranch: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type GitRemoveWorktreeRequest = z.infer<typeof GitRemoveWorktreeRequestSchema>;
+declare const GitRemoveWorktreeResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitRemoveWorktreeResponse = z.infer<typeof GitRemoveWorktreeResponseSchema>;
+/**
+ * Request to stage files for commit
+ */
+declare const GitStageRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  paths: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type GitStageRequest = z.infer<typeof GitStageRequestSchema>;
+/**
+ * Response from stage operation
+ */
+declare const GitStageResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitStageResponse = z.infer<typeof GitStageResponseSchema>;
+/**
+ * Request to unstage files (remove from staging area)
+ */
+declare const GitUnstageRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  paths: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type GitUnstageRequest = z.infer<typeof GitUnstageRequestSchema>;
+/**
+ * Response from unstage operation
+ */
+declare const GitUnstageResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitUnstageResponse = z.infer<typeof GitUnstageResponseSchema>;
+//#endregion
+//#region services/core/src/git/schemas/write.d.ts
+/**
+ * Git write operation schemas.
+ * Request/response schemas for git operations that mutate repository state:
+ * commit, merge, rebase, stash, branch CRUD, checkout, push, pull, fetch, discard.
+ */
+/** Request to create a commit from currently staged changes. */
+declare const GitCreateCommitRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  message: z.ZodString;
+  allowEmpty: z.ZodOptional<z.ZodBoolean>;
+  amend: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type GitCreateCommitRequest = z.infer<typeof GitCreateCommitRequestSchema>;
+/** Response from commit creation. */
+declare const GitCreateCommitResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  hash: z.ZodOptional<z.ZodString>;
+  branch: z.ZodOptional<z.ZodString>;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitCreateCommitResponse = z.infer<typeof GitCreateCommitResponseSchema>;
+/**
+ * Merge approach determines how the merge is performed.
+ * - 'merge': Standard merge commit (default)
+ * - 'squash': Squash all commits into a single commit
+ * - 'fast-forward-only': Only allow fast-forward merges
+ */
+declare const GitMergeApproachSchema: z.ZodEnum<{
+  merge: "merge";
+  squash: "squash";
+  "fast-forward-only": "fast-forward-only";
+}>;
+type GitMergeApproach = z.infer<typeof GitMergeApproachSchema>;
+/** Request to merge a branch into the current branch. */
+declare const GitMergeRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  source: z.ZodString;
+  approach: z.ZodOptional<z.ZodEnum<{
+    merge: "merge";
+    squash: "squash";
+    "fast-forward-only": "fast-forward-only";
+  }>>;
+  message: z.ZodOptional<z.ZodString>;
+  abortOnConflict: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type GitMergeRequest = z.infer<typeof GitMergeRequestSchema>;
+/** Response from merge operation. */
+declare const GitMergeResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  hash: z.ZodOptional<z.ZodString>;
+  fastForward: z.ZodOptional<z.ZodBoolean>;
+  conflicts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitMergeResponse = z.infer<typeof GitMergeResponseSchema>;
+/** Request to abort an in-progress merge. */
+declare const GitAbortMergeRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitAbortMergeRequest = z.infer<typeof GitAbortMergeRequestSchema>;
+/** Response from abort-merge operation. */
+declare const GitAbortMergeResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitAbortMergeResponse = z.infer<typeof GitAbortMergeResponseSchema>;
+/** Request to rebase the current branch onto a target ref. */
+declare const GitRebaseOntoRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  onto: z.ZodString;
+  abort: z.ZodOptional<z.ZodBoolean>;
+  continueRebase: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type GitRebaseOntoRequest = z.infer<typeof GitRebaseOntoRequestSchema>;
+/** Response from rebase operation. */
+declare const GitRebaseOntoResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  hash: z.ZodOptional<z.ZodString>;
+  conflicts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitRebaseOntoResponse = z.infer<typeof GitRebaseOntoResponseSchema>;
+/**
+ * Stash operation type.
+ * - 'push': Stash current changes (default)
+ * - 'pop': Apply and remove the top stash entry
+ * - 'apply': Apply but keep the stash entry
+ * - 'drop': Remove a stash entry without applying
+ * - 'list': List all stash entries
+ */
+declare const GitStashOperationSchema: z.ZodEnum<{
+  apply: "apply";
+  pop: "pop";
+  push: "push";
+  list: "list";
+  drop: "drop";
+}>;
+type GitStashOperation = z.infer<typeof GitStashOperationSchema>;
+/** Request to perform a stash operation. */
+declare const GitStashRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  operation: z.ZodEnum<{
+    apply: "apply";
+    pop: "pop";
+    push: "push";
+    list: "list";
+    drop: "drop";
+  }>;
+  message: z.ZodOptional<z.ZodString>;
+  includeUntracked: z.ZodOptional<z.ZodBoolean>;
+  index: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type GitStashRequest = z.infer<typeof GitStashRequestSchema>;
+/** A single entry in the stash list. */
+declare const GitStashEntrySchema: z.ZodObject<{
+  index: z.ZodNumber;
+  message: z.ZodString;
+  branch: z.ZodString;
+  date: z.ZodString;
+}, z.core.$strip>;
+type GitStashEntry = z.infer<typeof GitStashEntrySchema>;
+/** Response from stash operation. */
+declare const GitStashResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    index: z.ZodNumber;
+    message: z.ZodString;
+    branch: z.ZodString;
+    date: z.ZodString;
+  }, z.core.$strip>>>;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitStashResponse = z.infer<typeof GitStashResponseSchema>;
+/** Request to create a new branch. */
+declare const GitCreateBranchRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  name: z.ZodString;
+  startPoint: z.ZodOptional<z.ZodString>;
+  checkout: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type GitCreateBranchRequest = z.infer<typeof GitCreateBranchRequestSchema>;
+/** Response from branch creation. */
+declare const GitCreateBranchResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  name: z.ZodOptional<z.ZodString>;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitCreateBranchResponse = z.infer<typeof GitCreateBranchResponseSchema>;
+/** Request to delete a branch. */
+declare const GitDeleteBranchRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  name: z.ZodString;
+  force: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type GitDeleteBranchRequest = z.infer<typeof GitDeleteBranchRequestSchema>;
+/** Response from branch deletion. */
+declare const GitDeleteBranchResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitDeleteBranchResponse = z.infer<typeof GitDeleteBranchResponseSchema>;
+/** Request to rename a branch. */
+declare const GitRenameBranchRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  oldName: z.ZodString;
+  newName: z.ZodString;
+}, z.core.$strip>;
+type GitRenameBranchRequest = z.infer<typeof GitRenameBranchRequestSchema>;
+/** Response from branch rename. */
+declare const GitRenameBranchResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitRenameBranchResponse = z.infer<typeof GitRenameBranchResponseSchema>;
+/** Request to checkout a branch, tag, or commit. */
+declare const GitCheckoutRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  ref: z.ZodString;
+  createBranch: z.ZodOptional<z.ZodBoolean>;
+  startPoint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitCheckoutRequest = z.infer<typeof GitCheckoutRequestSchema>;
+/** Response from checkout operation. */
+declare const GitCheckoutResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  ref: z.ZodOptional<z.ZodString>;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitCheckoutResponse = z.infer<typeof GitCheckoutResponseSchema>;
+/** Request to push commits to a remote. */
+declare const GitPushRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  remote: z.ZodOptional<z.ZodString>;
+  branch: z.ZodOptional<z.ZodString>;
+  setUpstream: z.ZodOptional<z.ZodBoolean>;
+  force: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type GitPushRequest = z.infer<typeof GitPushRequestSchema>;
+/** Response from push operation. */
+declare const GitPushResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  remote: z.ZodOptional<z.ZodString>;
+  branch: z.ZodOptional<z.ZodString>;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitPushResponse = z.infer<typeof GitPushResponseSchema>;
+/** Request to pull changes from a remote. */
+declare const GitPullRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  remote: z.ZodOptional<z.ZodString>;
+  branch: z.ZodOptional<z.ZodString>;
+  rebase: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type GitPullRequest = z.infer<typeof GitPullRequestSchema>;
+/** Response from pull operation. */
+declare const GitPullResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  conflicts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitPullResponse = z.infer<typeof GitPullResponseSchema>;
+/** Request to fetch from a remote. */
+declare const GitFetchRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  remote: z.ZodOptional<z.ZodString>;
+  prune: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type GitFetchRequest = z.infer<typeof GitFetchRequestSchema>;
+/** Response from fetch operation. */
+declare const GitFetchResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitFetchResponse = z.infer<typeof GitFetchResponseSchema>;
+/** Request to discard working tree changes. */
+declare const GitDiscardChangesRequestSchema: z.ZodObject<{
+  repoPath: z.ZodOptional<z.ZodString>;
+  paths: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type GitDiscardChangesRequest = z.infer<typeof GitDiscardChangesRequestSchema>;
+/** Response from discard operation. */
+declare const GitDiscardChangesResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GitDiscardChangesResponse = z.infer<typeof GitDiscardChangesResponseSchema>;
+//#endregion
+//#region services/core/src/git/schemas/strategy.d.ts
+/**
+ * Built-in commit message strategy identifiers.
+ *
+ * - 'conventional': Conventional Commits format (type(scope): description)
+ * - 'descriptive': Detailed multi-line description of changes
+ * - 'minimal': Short one-line summary only
+ * - 'custom': User-provided template with variable interpolation
+ */
+declare const CommitMessageStrategyIdSchema: z.ZodEnum<{
+  custom: "custom";
+  conventional: "conventional";
+  descriptive: "descriptive";
+  minimal: "minimal";
+}>;
+type CommitMessageStrategyId = z.infer<typeof CommitMessageStrategyIdSchema>;
+/**
+ * Context provided to commit message strategies for message generation.
+ *
+ * Contains all information a strategy might need to compose a commit message.
+ * The `files` and `stats` fields provide structured change data, while `diff`
+ * provides the raw unified diff for strategies that analyze content.
+ */
+interface CommitMessageContext {
+  /** Files staged for commit */
+  readonly files: readonly GitFileChange[];
+  /** Aggregate change statistics */
+  readonly stats: GitChangeStats;
+  /** Current branch name */
+  readonly branch: string;
+  /** Unified diff of staged changes (optional, for content-analyzing strategies) */
+  readonly diff?: string;
+  /** Repository path */
+  readonly repoPath?: string;
+}
+/**
+ * Result from a commit message strategy.
+ *
+ * Follows git commit message conventions: a subject line (first line)
+ * and an optional body (subsequent lines after a blank separator).
+ */
+interface CommitMessageResult {
+  /** The generated subject line (first line of commit message) */
+  readonly subject: string;
+  /** Optional body (lines after the subject, separated by blank line) */
+  readonly body?: string;
+}
+/**
+ * Strategy interface for generating commit messages.
+ *
+ * Implementations generate commit messages based on the current staged changes
+ * and repository context. Register custom strategies via the bus to extend
+ * the built-in set.
+ *
+ * Strategies may be synchronous (template-based) or asynchronous (AI-powered).
+ *
+ * SEAM: Plugins can register their own strategies (e.g., AI-generated messages,
+ * ticket-based templates, team conventions).
+ * @example
+ * ```typescript
+ * const conventionalStrategy: ICommitMessageStrategy = {
+ *   id: 'conventional',
+ *   name: 'Conventional Commits',
+ *   description: 'Generates messages in type(scope): description format',
+ *   generate: (context) => ({
+ *     subject: `feat(${inferScope(context)}): ${inferDescription(context)}`,
+ *   }),
+ * };
+ * ```
+ */
+interface ICommitMessageStrategy {
+  /** Unique strategy identifier */
+  readonly id: string;
+  /** Human-readable strategy name */
+  readonly name: string;
+  /** Description of what this strategy does */
+  readonly description: string;
+  /**
+   * Generate a commit message from the given context.
+   * @param context - Repository and staging context for message generation
+   * @returns Generated commit message (sync or async)
+   */
+  generate(context: CommitMessageContext): CommitMessageResult | Promise<CommitMessageResult>;
+}
+/**
+ * Built-in merge strategy identifiers.
+ *
+ * - 'merge-commit': Standard merge with merge commit (default)
+ * - 'squash': Squash all commits into one before merging
+ * - 'rebase': Rebase commits onto target instead of merging
+ * - 'fast-forward': Only allow fast-forward merges
+ */
+declare const MergeStrategyIdSchema: z.ZodEnum<{
+  rebase: "rebase";
+  squash: "squash";
+  "merge-commit": "merge-commit";
+  "fast-forward": "fast-forward";
+}>;
+type MergeStrategyId = z.infer<typeof MergeStrategyIdSchema>;
+/**
+ * Context provided to merge strategies.
+ */
+interface MergeContext {
+  /** Source branch or ref being merged */
+  readonly source: string;
+  /** Target branch (current branch) */
+  readonly target: string;
+  /** Repository path */
+  readonly repoPath: string;
+}
+/**
+ * Hook that runs before or after a merge operation.
+ *
+ * Pre-merge hooks can abort the merge by throwing an error.
+ * Post-merge hooks run after successful merge completion.
+ */
+interface IMergeHook {
+  /** Unique hook identifier */
+  readonly id: string;
+  /** Human-readable hook name */
+  readonly name: string;
+  /**
+   * Execute the hook.
+   * @param context - Merge context
+   * @throws Error to abort (pre-merge) or report failure (post-merge)
+   */
+  execute(context: MergeContext): Promise<void>;
+}
+/**
+ * Strategy interface for merge operations.
+ *
+ * Encapsulates how a merge should be performed, including the merge approach
+ * and any pre/post hooks.
+ *
+ * SEAM: Plugins can register custom merge strategies with team-specific
+ * workflows (e.g., auto-stash before merge, run tests after merge).
+ * @example
+ * ```typescript
+ * const squashStrategy: IMergeStrategy = {
+ *   id: 'squash',
+ *   name: 'Squash Merge',
+ *   description: 'Squash all commits into a single commit',
+ *   preHooks: [autoStashHook],
+ *   postHooks: [notifyHook],
+ *   getMergeApproach: () => 'squash',
+ * };
+ * ```
+ */
+interface IMergeStrategy {
+  /** Unique strategy identifier */
+  readonly id: string;
+  /** Human-readable strategy name */
+  readonly name: string;
+  /** Description of what this strategy does */
+  readonly description: string;
+  /** Hooks to run before the merge operation */
+  readonly preHooks: readonly IMergeHook[];
+  /** Hooks to run after successful merge */
+  readonly postHooks: readonly IMergeHook[];
+  /**
+   * Determine the merge approach for the given context.
+   * @param context - Merge context
+   * @returns The merge approach to use
+   */
+  getMergeApproach(context: MergeContext): 'merge' | 'squash' | 'fast-forward-only' | 'rebase';
+}
+//#endregion
+export { BaseRequestSchema, type CommitMessageContext, type CommitMessageResult, type CommitMessageStrategyId, CommitMessageStrategyIdSchema, type GetBranchCommitsRequest, GetBranchCommitsRequestSchema, type GetBranchCommitsResponse, GetBranchCommitsResponseSchema, type GitAbortMergeRequest, GitAbortMergeRequestSchema, type GitAbortMergeResponse, GitAbortMergeResponseSchema, type GitAddRepoRequest, GitAddRepoRequestSchema, type GitAddRepoResponse, GitAddRepoResponseSchema, type GitBlameLine, GitBlameLineSchema, type GitBlameRequest, GitBlameRequestSchema, type GitBlameResponse, GitBlameResponseSchema, type GitBlobHashAtCommitRequest, GitBlobHashAtCommitRequestSchema, type GitBlobHashAtCommitResponse, GitBlobHashAtCommitResponseSchema, type GitBranchRequest, GitBranchRequestSchema, type GitBranchResponse, GitBranchResponseSchema, type GitChangeStats, GitChangeStatsSchema, type GitCheckoutEvent, GitCheckoutEventSchema, type GitCheckoutRequest, GitCheckoutRequestSchema, type GitCheckoutResponse, GitCheckoutResponseSchema, type GitCommitDetailsRequest, GitCommitDetailsRequestSchema, type GitCommitDetailsResponse, GitCommitDetailsResponseSchema, type GitCommitEvent, GitCommitEventSchema, type GitCommitRequest, GitCommitRequestSchema, type GitCommitResponse, GitCommitResponseSchema, type GitCreateBranchRequest, GitCreateBranchRequestSchema, type GitCreateBranchResponse, GitCreateBranchResponseSchema, type GitCreateCommitRequest, GitCreateCommitRequestSchema, type GitCreateCommitResponse, GitCreateCommitResponseSchema, type GitCreateWorktreeRequest, GitCreateWorktreeRequestSchema, type GitCreateWorktreeResponse, GitCreateWorktreeResponseSchema, type GitDefaultBranchRequest, GitDefaultBranchRequestSchema, type GitDefaultBranchResponse, GitDefaultBranchResponseSchema, type GitDeleteBranchRequest, GitDeleteBranchRequestSchema, type GitDeleteBranchResponse, GitDeleteBranchResponseSchema, type GitDiffRequest, GitDiffRequestSchema, type GitDiffResponse, GitDiffResponseSchema, type GitDiscardChangesRequest, GitDiscardChangesRequestSchema, type GitDiscardChangesResponse, GitDiscardChangesResponseSchema, type GitFetchRequest, GitFetchRequestSchema, type GitFetchResponse, GitFetchResponseSchema, type GitFileAtCommitRequest, GitFileAtCommitRequestSchema, type GitFileAtCommitResponse, GitFileAtCommitResponseSchema, type GitFileAtRevisionRequest, GitFileAtRevisionRequestSchema, type GitFileAtRevisionResponse, GitFileAtRevisionResponseSchema, type GitFileChange, GitFileChangeSchema, type GitFingerprintRequest, GitFingerprintRequestSchema, type GitFingerprintResponse, GitFingerprintResponseSchema, type GitInitRepoRequest, GitInitRepoRequestSchema, type GitInitRepoResponse, GitInitRepoResponseSchema, type GitLogCommit, GitLogCommitSchema, type GitLogFilters, GitLogFiltersSchema, type GitLogRequest, GitLogRequestSchema, type GitLogResponse, GitLogResponseSchema, type GitMergeApproach, GitMergeApproachSchema, type GitMergeEvent, GitMergeEventSchema, type GitMergeRequest, GitMergeRequestSchema, type GitMergeResponse, GitMergeResponseSchema, type GitPullRequest, GitPullRequestSchema, type GitPullResponse, GitPullResponseSchema, type GitPushRequest, GitPushRequestSchema, type GitPushResponse, GitPushResponseSchema, type GitRebaseEvent, GitRebaseEventSchema, type GitRebaseOntoRequest, GitRebaseOntoRequestSchema, type GitRebaseOntoResponse, GitRebaseOntoResponseSchema, type GitRebaseStatus, GitRebaseStatusSchema, type GitRefs, GitRefsSchema, type GitRemote, GitRemoteSchema, type GitRemotesRequest, GitRemotesRequestSchema, type GitRemotesResponse, GitRemotesResponseSchema, type GitRemoveRepoRequest, GitRemoveRepoRequestSchema, type GitRemoveRepoResponse, GitRemoveRepoResponseSchema, type GitRemoveWorktreeRequest, GitRemoveWorktreeRequestSchema, type GitRemoveWorktreeResponse, GitRemoveWorktreeResponseSchema, type GitRenameBranchRequest, GitRenameBranchRequestSchema, type GitRenameBranchResponse, GitRenameBranchResponseSchema, type GitRepoRootRequest, GitRepoRootRequestSchema, type GitRepoRootResponse, GitRepoRootResponseSchema, type GitStageRequest, GitStageRequestSchema, type GitStageResponse, GitStageResponseSchema, type GitStagingEvent, GitStagingEventSchema, type GitStashEntry, GitStashEntrySchema, type GitStashOperation, GitStashOperationSchema, type GitStashRequest, GitStashRequestSchema, type GitStashResponse, GitStashResponseSchema, type GitStatusRequest, GitStatusRequestSchema, type GitStatusResponse, GitStatusResponseSchema, type GitSwitchWorktreeRequest, GitSwitchWorktreeRequestSchema, type GitSwitchWorktreeResponse, GitSwitchWorktreeResponseSchema, type GitUnstageRequest, GitUnstageRequestSchema, type GitUnstageResponse, GitUnstageResponseSchema, type GitWorkingTreeDetailsRequest, GitWorkingTreeDetailsRequestSchema, type GitWorkingTreeDetailsResponse, GitWorkingTreeDetailsResponseSchema, type GitWorkingTreeFileChange, GitWorkingTreeFileChangeSchema, type GitWorktreeEvent, GitWorktreeEventSchema, type GitWorktreeInfo, GitWorktreeInfoSchema, type GitWorktreesRequest, GitWorktreesRequestSchema, type GitWorktreesResponse, GitWorktreesResponseSchema, type ICommitMessageStrategy, type IMergeHook, type IMergeStrategy, type MergeContext, type MergeStrategyId, MergeStrategyIdSchema };