@scolladon/tsgit 1.0.0 → 1.2.0

package/dist/types/chunks/write-tree-BXCDChvv.d.ts

@@ -0,0 +1,154 @@
+import { O as ObjectId, d as FilePath, b as Context, R as RefName, h as HookName } from './context-BORy7yXb.js';
+import { F as FileMode, a as CatFileBatchOptions, C as CatFileBatchEntry, c as CreateCommitInput, D as DiffTreesInput, d as DiffTreesOptions, s as TreeDiff, R as ReadObjectOptions, B as Blob, G as GitObject, T as Tree, r as ResolveRefOptions, U as UpdateRefOptions, W as WalkCommitsOptions, b as Commit, v as WalkSubmodulesOptions, S as SubmoduleEntry, x as WalkTreeOptions, w as WalkTreeEntry, z as WalkWorkingTreeOptions, y as WalkWorkingTreeEntry, t as TreeEntry } from './reflog-entry-D9P2hCgv.js';
+
+interface IndexEntryFlags {
+    readonly assumeValid: boolean;
+    readonly stage: 0 | 1 | 2 | 3;
+    /** Index v3 extended flag — the path is intentionally absent from the working tree. */
+    readonly skipWorktree: boolean;
+    /** Index v3 extended flag — `git add -N` placeholder. Modelled for faithful round-tripping. */
+    readonly intentToAdd: boolean;
+}
+interface IndexEntry {
+    readonly ctimeSeconds: number;
+    readonly ctimeNanoseconds: number;
+    readonly mtimeSeconds: number;
+    readonly mtimeNanoseconds: number;
+    readonly dev: number;
+    readonly ino: number;
+    readonly mode: FileMode;
+    readonly uid: number;
+    readonly gid: number;
+    readonly fileSize: number;
+    readonly id: ObjectId;
+    readonly flags: IndexEntryFlags;
+    readonly path: FilePath;
+}
+interface IndexExtension {
+    readonly signature: string;
+    readonly data: Uint8Array;
+}
+interface GitIndex {
+    readonly version: 2 | 3;
+    readonly entries: ReadonlyArray<IndexEntry>;
+    readonly extensions: ReadonlyArray<IndexExtension>;
+}
+
+declare function catFileBatch(ctx: Context, ids: AsyncIterable<ObjectId> | Iterable<ObjectId>, options?: CatFileBatchOptions): AsyncIterable<CatFileBatchEntry>;
+
+declare function createCommit(ctx: Context, input: CreateCommitInput): Promise<ObjectId>;
+
+declare function diffTrees(ctx: Context, a: DiffTreesInput, b: DiffTreesInput, options?: DiffTreesOptions): Promise<TreeDiff>;
+
+/**
+ * Compute a merge base — the first commit reachable from BOTH `a` and `b`.
+ *
+ * Algorithm: bidirectional BFS with two visited sets. After each layer
+ * advance, check the intersection. When non-empty, return the
+ * lexicographically smallest oid (deterministic tie-breaker).
+ *
+ * Returns `undefined` for unrelated histories. Documented limitation: cherry-picks
+ * and criss-cross merges may yield non-optimal bases — `recursive`-strategy
+ * multi-base resolution is v2.
+ */
+declare const mergeBase: (ctx: Context, a: ObjectId, b: ObjectId) => Promise<ObjectId | undefined>;
+
+/**
+ * Pure path helpers composing `ctx.layout.gitDir` with known sub-paths.
+ * No I/O. No port access. Primitive step 3.
+ */
+
+/**
+ * Repository working-tree root. Returns the workDir from the current context;
+ * facade-tier code is responsible for discovery / realpath pinning
+ * at construction time. Primitives consume the already-resolved path.
+ */
+declare const getRepoRoot: (ctx: Context) => FilePath;
+declare const sparseCheckoutPath: (gitDir: string) => string;
+
+declare function readBlob(ctx: Context, id: ObjectId, options?: ReadObjectOptions): Promise<Blob>;
+
+declare function readIndex(ctx: Context): Promise<GitIndex>;
+
+declare function readObject(ctx: Context, id: ObjectId, options?: ReadObjectOptions): Promise<GitObject>;
+
+declare function readTree(ctx: Context, ref: RefName | ObjectId): Promise<Tree>;
+
+/**
+ * The single reflog *writer*. Self-contained: reads config, applies the gate,
+ * resolves identity, sanitises the message, and appends one entry. Callers
+ * supply only a human-readable message.
+ */
+
+/**
+ * Append a reflog entry for `ref` if logging applies. A no-op when the gate is
+ * closed for `ref` — once a reflog file exists every update appends to it,
+ * otherwise the `core.logAllRefUpdates` prefix rule decides.
+ */
+declare function recordRefUpdate(ctx: Context, ref: RefName, oldId: ObjectId, newId: ObjectId, message: string): Promise<void>;
+
+declare function resolveRef(ctx: Context, name: RefName | 'HEAD', options?: ResolveRefOptions): Promise<ObjectId>;
+
+/** Optional arguments and stdin a caller threads into a hook invocation. */
+interface HookInput {
+    readonly args?: ReadonlyArray<string>;
+    readonly stdin?: string;
+}
+/**
+ * Run a named git hook through `ctx.hooks`. A no-op when no `HookRunner` is
+ * wired (browser, or opted out), when the hook file is absent / not executable
+ * (`skipped`), or when the hook exits 0. Throws `HOOK_FAILED` on a non-zero
+ * exit.
+ */
+declare const runHook: (ctx: Context, name: HookName, input?: HookInput) => Promise<void>;
+
+declare function updateRef(ctx: Context, name: RefName, newId: ObjectId, options: UpdateRefOptions): Promise<void>;
+
+declare function walkCommits(ctx: Context, options: WalkCommitsOptions): AsyncIterable<Commit>;
+
+/**
+ * Yield every gitlink reachable in `ref`'s tree, joined with its `.gitmodules`
+ * metadata. With `recursive: true`, descend into each nested submodule whose
+ * absorbed gitdir (`${gitDir}/modules/<name>`) is locally available; nested
+ * yields carry `depth >= 1` and a `parent` path. Uninitialised / missing /
+ * cyclic nested submodules contribute their own entry but no children — the
+ * absence of further yields is the signal, matching `git submodule status
+ * --recursive`.
+ */
+declare function walkSubmodules(ctx: Context, options?: WalkSubmodulesOptions): AsyncIterable<SubmoduleEntry>;
+
+declare function walkTree(ctx: Context, treeIdOrObject: ObjectId | Tree, options?: WalkTreeOptions): AsyncIterable<WalkTreeEntry>;
+
+/**
+ * Depth-first walk of the working tree starting at `ctx.layout.workDir`.
+ *
+ * Yields leaf entries (files and symlinks) as `{ path, stat }`. Directories
+ * are descended into, not yielded. `.git` at any level is skipped
+ * (case-insensitive, NTFS-trimmed). Embedded repositories (directories
+ * containing a `.git` child) are skipped entirely — yields nothing under
+ * them. Symlinks are surfaced via `lstat` (no follow); a symlink to a
+ * directory is yielded as a leaf, not descended into.
+ *
+ * The host repository's own `.git` is NOT treated as an embedded-repo
+ * marker — at the workDir root we only skip the `.git` entry itself, not
+ * the workDir.
+ */
+declare function walkWorkingTree(ctx: Context, options?: WalkWorkingTreeOptions): AsyncIterable<WalkWorkingTreeEntry>;
+
+declare function writeObject(ctx: Context, object: GitObject): Promise<ObjectId>;
+
+/**
+ * Write a symbolic ref atomically. Used for HEAD updates that point at a
+ * branch, branch renames affecting the current HEAD, and `clone`/`init`
+ * to set the initial HEAD.
+ *
+ * Single-level only in v1: target MUST be a direct ref name (no chained
+ * symrefs). Validation runs through `validateRefName` for both `name` and
+ * `target` — invalid inputs throw INVALID_REF before any I/O.
+ */
+declare const writeSymbolicRef: (ctx: Context, name: RefName, target: RefName) => Promise<void>;
+
+declare function writeTree(ctx: Context, entries: ReadonlyArray<TreeEntry>): Promise<ObjectId>;
+
+export { createCommit as a, readIndex as b, catFileBatch as c, diffTrees as d, readObject as e, readTree as f, getRepoRoot as g, recordRefUpdate as h, resolveRef as i, runHook as j, walkSubmodules as k, walkTree as l, mergeBase as m, walkWorkingTree as n, writeObject as o, writeSymbolicRef as p, writeTree as q, readBlob as r, sparseCheckoutPath as s, updateRef as u, walkCommits as w };
+export type { GitIndex as G, HookInput as H, IndexEntry as I };

package/dist/types/commands/index.d.cts

@@ -1,5 +1,5 @@
-import { d as FilePath, b as Context, R as RefName, O as ObjectId } from '../chunks/context-d36639-i.cjs';
-import { A as AuthorIdentity, T as TreeDiff } from '../chunks/diff-change-B09vxnxy.cjs';
+import { d as FilePath, b as Context, R as RefName, O as ObjectId, m as PromisorRemote } from '../chunks/context-CMrHCVwK.cjs';
+import { C as CatFileBatchEntry, A as AuthorIdentity, s as TreeDiff, q as ReflogEntry, S as SubmoduleEntry } from '../chunks/reflog-entry-BIf-zt__.cjs';
 import '../chunks/http-transport-DirKfK2S.cjs';
 
 interface AddOptions {
@@ -13,14 +13,17 @@ interface AddResult {
     readonly removed: ReadonlyArray<FilePath>;
 }
 /**
- * Add the given pathspecs to the index. Performs:
- * 1. Repo + bare + pending-op preflight checks.
- * 2. Path validation for every input (no I/O on rejection).
- * 3. Read working-tree contents → write blob → produce IndexEntry.
- * 4. Atomically replace `.git/index` under the index lock.
+ * Stage paths in the index. Two modes:
  *
- * Bulk mode (`all: true`) is not yet implemented — this is the literal-paths
- * happy path used by `init`/`commit` integration tests.
+ * - **Literal-path mode** (`paths` non-empty, `all` falsy): every path is
+ *  validated, read, hashed, and staged. Missing paths reject the whole call.
+ * - **Bulk mode** (`paths` empty, `all === true`): walk the working tree,
+ *  stage every modified/new tracked file plus every untracked, non-ignored
+ *  file. Files missing from disk but present in the prior index land in
+ *  `removed`. `.git` and embedded repositories are skipped.
+ *
+ * Both modes acquire `.git/index.lock` once, read the existing index under
+ * the lock, and commit a single replacement — no partial writes.
  */
 declare const add: (ctx: Context, paths: ReadonlyArray<string>, opts?: AddOptions) => Promise<AddResult>;
 
@@ -63,15 +66,45 @@ type BranchResult = {
 };
 declare const branch: (ctx: Context, action: BranchAction) => Promise<BranchResult>;
 
-interface CheckoutOptions {
+type ConflictType = 'content' | 'add-add' | 'modify-delete' | 'type-change' | 'rename-rename' | 'gitlink' | 'binary';
+
+/**
+ * Tier-1 `catFile` command — wraps the streaming `catFileBatch` primitive in
+ * a request/response shape matching the other v2 commands (`submodules`,
+ * `log`, `reflog`). String ids are coerced at the boundary via
+ * `ObjectId.from`, which throws `INVALID_OBJECT_ID` on malformed input
+ * before any read happens.
+ *
+ * For streaming use cases, callers reach for `repo.primitives.catFileBatch`
+ * directly — see `docs/design/cat-file-batch.md` §2.
+ */
+
+interface CatFileInput {
+    readonly ids: ReadonlyArray<ObjectId | string>;
+    /** Per-object byte cap; forwarded to the underlying `readObject` call. */
+    readonly maxBytes?: number;
+}
+interface CatFileResult {
+    readonly kind: 'batch';
+    readonly entries: ReadonlyArray<CatFileBatchEntry>;
+}
+declare const catFile: (ctx: Context, opts: CatFileInput) => Promise<CatFileResult>;
+
+interface CheckoutSwitchOptions {
     readonly target: string;
     readonly detach?: boolean;
     readonly force?: boolean;
 }
+interface CheckoutPathsOptions {
+    readonly paths: ReadonlyArray<string>;
+    readonly source?: 'index' | 'HEAD' | ObjectId;
+}
+type CheckoutOptions = CheckoutSwitchOptions | CheckoutPathsOptions;
 interface CheckoutResult {
     readonly branch: RefName | undefined;
     readonly id: ObjectId;
     readonly detached: boolean;
+    readonly changedPaths: number;
 }
 declare const checkout: (ctx: Context, opts: CheckoutOptions) => Promise<CheckoutResult>;
 
@@ -82,11 +115,21 @@ interface CloneOptions {
     readonly url: string;
     readonly bare?: boolean;
     readonly initialBranch?: string;
+    /**
+     * Shallow clone depth. When set, sends `deepen N` and persists the
+     * resulting shallow boundaries to `.git/shallow`.
+     */
     readonly depth?: number;
     /** DNS resolver injected by the caller; required to enforce SSRF guards. */
     readonly resolver?: DnsResolver;
     readonly allowInsecure?: boolean;
     readonly allowPrivateNetworks?: boolean;
+    /**
+     * Partial-clone object filter (`blob:none`, `blob:limit=<n>`, `tree:<n>`).
+     * When set, the server omits the filtered objects, a promisor remote is
+     * recorded in `.git/config`, and omitted objects are lazy-fetched on read.
+     */
+    readonly filter?: string;
 }
 interface CloneResult {
     readonly path: FilePath;
@@ -104,6 +147,8 @@ interface CommitOptions {
     readonly committer?: AuthorIdentity;
     readonly allowEmpty?: boolean;
     readonly allowEmptyMessage?: boolean;
+    /** Skip the `pre-commit` and `commit-msg` hooks (git's `--no-verify`). */
+    readonly noVerify?: boolean;
 }
 interface CommitResult {
     readonly id: ObjectId;
@@ -139,18 +184,51 @@ interface FetchOptions {
     readonly remote?: string;
     readonly refspecs?: ReadonlyArray<string>;
     readonly prune?: boolean;
+    /** Shallow clone depth. Delegates to fetchPack's deepen path. */
+    readonly depth?: number;
+}
+interface FetchUpdate {
+    readonly name: RefName;
+    readonly oldId: ObjectId | undefined;
+    readonly newId: ObjectId;
 }
 interface FetchResult {
     readonly remote: string;
     readonly url: string;
-    readonly updatedRefs: ReadonlyArray<{
-        readonly name: RefName;
-        readonly oldId: ObjectId | undefined;
-        readonly newId: ObjectId;
-    }>;
+    readonly updatedRefs: ReadonlyArray<FetchUpdate>;
+    /** Refs deleted because the server no longer advertises them (prune semantics). */
+    readonly prunedRefs: ReadonlyArray<RefName>;
+    /** New shallow boundaries written to `.git/shallow` during this fetch. */
+    readonly shallow: ReadonlyArray<ObjectId>;
+    /** Commits that crossed the shallow → non-shallow boundary during this fetch. */
+    readonly unshallow: ReadonlyArray<ObjectId>;
 }
 declare const fetch: (ctx: Context, opts?: FetchOptions) => Promise<FetchResult>;
 
+interface FetchMissingOptions {
+    /** Object ids to fetch. Ones already present locally are skipped. */
+    readonly oids: ReadonlyArray<ObjectId>;
+}
+interface FetchMissingResult {
+    /** The promisor remote the objects were fetched from. */
+    readonly remote: string;
+    /** Objects the caller asked for. */
+    readonly requested: number;
+    /** Objects that were missing locally and got fetched. */
+    readonly fetched: number;
+}
+/**
+ * Fetch the named objects from the repository's promisor remote. Throws
+ * `NO_PROMISOR_REMOTE` when the repository is not a partial clone.
+ */
+declare const fetchMissing: (ctx: Context, opts: FetchMissingOptions) => Promise<FetchMissingResult>;
+/**
+ * `PromisorRemote` port implementation — the seam `readObject` calls on a
+ * miss. A non-partial repository yields `attempted: false` (rather than
+ * throwing) so `readObject` falls through to its normal `OBJECT_NOT_FOUND`.
+ */
+declare const createPromisorRemote: (ctx: Context) => PromisorRemote;
+
 interface InitOptions {
     readonly initialBranch?: string;
     readonly bare?: boolean;
@@ -167,7 +245,7 @@ interface InitResult {
  *
  * For non-bare repos, the gitDir is `<workDir>/.git`. For bare, gitDir IS the
  * working dir — callers must construct a Context with `bare: true` for that
- * shape (Phase 10 facade will derive this automatically).
+ * shape.
  */
 declare const init: (ctx: Context, opts?: InitOptions) => Promise<InitResult>;
 
@@ -200,6 +278,10 @@ interface MergeOptions {
     readonly author?: AuthorIdentity;
     readonly committer?: AuthorIdentity;
 }
+interface MergeConflictDescriptor {
+    readonly path: FilePath;
+    readonly type: ConflictType;
+}
 type MergeResult = {
     readonly kind: 'up-to-date';
     readonly id: ObjectId;
@@ -212,14 +294,24 @@ type MergeResult = {
     readonly id: ObjectId;
     readonly branch: RefName;
     readonly parents: ReadonlyArray<ObjectId>;
+} | {
+    readonly kind: 'conflict';
+    readonly conflicts: ReadonlyArray<MergeConflictDescriptor>;
+    readonly mergeHead: ObjectId;
+    readonly origHead: ObjectId;
 };
 /**
- * Merge `target` into the current HEAD branch. v1 supports:
- * - Up-to-date detection (target is ancestor of HEAD).
- * - Fast-forward (HEAD is ancestor of target → branch advances).
- * - True merge for diverged histories: writes a merge commit using HEAD's tree
- *   (callers must run `add` to incorporate target's content). Conflict
- *   resolution and three-way tree merge land in Phase 11.
+ * Merge `target` into the current HEAD branch.
+ *
+ * - Up-to-date: target is ancestor of HEAD → no-op.
+ * - Fast-forward: HEAD is ancestor of target → branch advances.
+ * - True merge for diverged histories:.4a wired the three-way
+ *  tree merge (`mergeTrees` + `mergeContent`) so a CLEAN merge commits
+ *  the merged tree directly.4b persists conflict state on
+ *  disk (marker files, stage-1/2/3 index entries, MERGE_HEAD /
+ *  MERGE_MSG / ORIG_HEAD) and returns `{ kind: 'conflict',... }`.
+ *  Resolution path: edit the marker files, `repo.add(paths)`,
+ *  `repo.commit({ message })` — the resulting commit has two parents.
  */
 declare const merge: (ctx: Context, opts: MergeOptions) => Promise<MergeResult>;
 
@@ -228,18 +320,64 @@ interface PushOptions {
     readonly refspecs?: ReadonlyArray<string>;
     readonly force?: boolean;
     readonly forceWithLease?: ObjectId | 'auto';
+    /** Skip the `pre-push` hook (git's `--no-verify`). */
+    readonly noVerify?: boolean;
+}
+interface PushedRef {
+    readonly name: RefName;
+    readonly oldId: ObjectId;
+    readonly newId: ObjectId;
+    readonly status: 'ok' | 'rejected';
+    readonly reason?: string;
 }
 interface PushResult {
     readonly remote: string;
     readonly url: string;
-    readonly pushedRefs: ReadonlyArray<{
-        readonly name: RefName;
-        readonly newId: ObjectId;
-        readonly status: 'ok' | 'rejected';
-    }>;
+    readonly pushedRefs: ReadonlyArray<PushedRef>;
 }
 declare const push: (ctx: Context, opts?: PushOptions) => Promise<PushResult>;
 
+type ReflogAction = {
+    readonly action?: 'show';
+    readonly ref?: string;
+} | {
+    readonly action: 'exists';
+    readonly ref: string;
+} | {
+    readonly action: 'delete';
+    readonly ref: string;
+    readonly index: number;
+    readonly rewrite?: boolean;
+} | {
+    readonly action: 'expire';
+    readonly ref?: string;
+    readonly all?: boolean;
+    readonly expire?: string;
+    readonly expireUnreachable?: string;
+};
+/** One reflog entry as `show` presents it: newest-first, with a selector. */
+interface ReflogShowEntry {
+    readonly index: number;
+    readonly selector: string;
+    readonly entry: ReflogEntry;
+}
+type ReflogResult = {
+    readonly kind: 'show';
+    readonly ref: RefName;
+    readonly entries: ReadonlyArray<ReflogShowEntry>;
+} | {
+    readonly kind: 'exists';
+    readonly exists: boolean;
+} | {
+    readonly kind: 'expire';
+    readonly removed: number;
+    readonly kept: number;
+} | {
+    readonly kind: 'delete';
+    readonly removed: ReflogEntry;
+};
+declare const reflog: (ctx: Context, opts?: ReflogAction) => Promise<ReflogResult>;
+
 type ResetMode = 'soft' | 'mixed' | 'hard';
 interface ResetOptions {
     readonly mode: ResetMode;
@@ -253,13 +391,18 @@ interface ResetResult {
 /**
  * Reset HEAD (and optionally index/working tree) to `target`.
  *
- * - `soft`:  HEAD only.
- * - `mixed`: HEAD + clears the index (Phase 9 stub: index cleared via lock release).
- * - `hard`:  HEAD + index + working tree (working-tree mutation deferred to Phase 11).
+ * - `soft`: HEAD only.
+ * - `mixed`: HEAD + rebuild the index from the target commit's tree
+ *  (stat-cache donor strategy preserves cache for unchanged paths —
+ * ). Working tree is NOT touched.
+ * - `hard`: HEAD + index + working tree — materialise the target tree onto
+ *  the working tree with `force: true`, then commit the post-write
+ *  index entries. Bare repos are rejected upfront.
  *
- * v1 implements the HEAD-update path; index/working-tree side effects beyond
- * the HEAD move land in subsequent passes once `materializeFile`/`removeFile`
- * orchestration is in place.
+ * Ordering: working tree → index → HEAD. The index lock wraps both the
+ * working-tree write AND the index commit, matching tightened
+ * pattern. A crash between the index commit and HEAD update leaves the index
+ * ahead of HEAD — same recoverable hazard as canonical git.
  */
 declare const reset: (ctx: Context, opts: ResetOptions) => Promise<ResetResult>;
 
@@ -278,6 +421,37 @@ interface RmResult {
  */
 declare const rm: (ctx: Context, paths: ReadonlyArray<string>, opts?: RmOptions) => Promise<RmResult>;
 
+type SparseCheckoutAction = {
+    readonly action: 'list';
+} | {
+    readonly action: 'set';
+    readonly patterns: ReadonlyArray<string>;
+    readonly cone?: boolean;
+    readonly force?: boolean;
+} | {
+    readonly action: 'add';
+    readonly patterns: ReadonlyArray<string>;
+    readonly force?: boolean;
+} | {
+    readonly action: 'reapply';
+    readonly force?: boolean;
+} | {
+    readonly action: 'disable';
+    readonly force?: boolean;
+};
+type SparseCheckoutResult = {
+    readonly kind: 'list';
+    readonly cone: boolean;
+    readonly patterns: ReadonlyArray<string>;
+} | {
+    readonly kind: 'applied';
+    readonly cone: boolean;
+    readonly materialized: number;
+    readonly removed: number;
+    readonly retained: ReadonlyArray<FilePath>;
+};
+declare const sparseCheckout: (ctx: Context, opts: SparseCheckoutAction) => Promise<SparseCheckoutResult>;
+
 type ChangeKind = 'modified' | 'added' | 'deleted' | 'untracked';
 interface ChangeEntry {
     readonly kind: ChangeKind;
@@ -293,10 +467,10 @@ interface StatusResult {
 /**
  * Summarize the state of the working tree relative to the index, and the
  * branch HEAD points at. Working-tree-vs-HEAD diff (Git's "staged" column)
- * is approximated via index-vs-working-tree comparisons until Phase 11
+ * is approximated via index-vs-working-tree comparisons until
  * adds the stat-cache fast path.
  *
- * Progress reporting (Phase 10 §6.2): emits `status:scan` start before the
+ * Progress reporting: emits `status:scan` start before the
  * fan-out, updates at every 100 lstat completions, and end in a finally
  * block so the consumer always pairs start with end. `total` is undefined
  * — design choice that prevents revealing repository size to non-trusted
@@ -304,6 +478,24 @@ interface StatusResult {
  */
 declare const status: (ctx: Context) => Promise<StatusResult>;
 
+type SubmodulesAction = {
+    readonly action?: 'list';
+    /** Tree-ish to walk. Default: `'HEAD'`. */
+    readonly ref?: string;
+    /** Descend into nested submodules' own `.gitmodules`. Default: `false`. */
+    readonly recursive?: boolean;
+    /**
+     * Cap on recursion depth. Default: `MAX_SUBMODULE_DEPTH`. Entries at exactly
+     * this depth are yielded but not recursed into.
+     */
+    readonly maxDepth?: number;
+};
+type SubmodulesResult = {
+    readonly kind: 'list';
+    readonly entries: ReadonlyArray<SubmoduleEntry>;
+};
+declare const submodules: (ctx: Context, opts?: SubmodulesAction) => Promise<SubmodulesResult>;
+
 type TagAction = {
     readonly kind: 'list';
 } | {
@@ -332,5 +524,5 @@ type TagResult = {
 };
 declare const tag: (ctx: Context, action: TagAction) => Promise<TagResult>;
 
-export { add, branch, checkout, clone, commit, diff, fetch, init, log, merge, push, reset, revParse, rm, status, tag };
-export type { AddOptions, AddResult, BranchAction, BranchInfo, BranchResult, ChangeEntry, ChangeKind, CheckoutOptions, CheckoutResult, CloneOptions, CloneResult, CommitOptions, CommitResult, DiffOptions, FetchOptions, FetchResult, InitOptions, InitResult, LogEntry, LogOptions, MergeOptions, MergeResult, PushOptions, PushResult, ResetMode, ResetOptions, ResetResult, RmOptions, RmResult, StatusResult, TagAction, TagInfo, TagResult };
+export { CatFileBatchEntry, SubmoduleEntry, add, branch, catFile, checkout, clone, commit, createPromisorRemote, diff, fetch, fetchMissing, init, log, merge, push, reflog, reset, revParse, rm, sparseCheckout, status, submodules, tag };
+export type { AddOptions, AddResult, BranchAction, BranchInfo, BranchResult, CatFileInput, CatFileResult, ChangeEntry, ChangeKind, CheckoutOptions, CheckoutResult, CloneOptions, CloneResult, CommitOptions, CommitResult, DiffOptions, FetchMissingOptions, FetchMissingResult, FetchOptions, FetchResult, InitOptions, InitResult, LogEntry, LogOptions, MergeOptions, MergeResult, PushOptions, PushResult, ReflogAction, ReflogResult, ReflogShowEntry, ResetMode, ResetOptions, ResetResult, RmOptions, RmResult, SparseCheckoutAction, SparseCheckoutResult, StatusResult, SubmodulesAction, SubmodulesResult, TagAction, TagInfo, TagResult };