es-git 0.5.0-next.170 → 0.5.0-next.172

package/index.d.ts

@@ -2374,6 +2374,201 @@ export declare class Reference {
   rename(newName: string, options?: RenameReferenceOptions | undefined | null): Reference
 }
 
+/** A class to represent a git reflog. */
+export declare class Reflog {
+  /**
+   * Append a new entry to the reflog.
+   *
+   * @category Reflog/Methods
+   *
+   * @signature
+   * ```ts
+   * class Reflog {
+   *   append(newOid: string, committer: Signature, msg?: string | null | undefined): void;
+   * }
+   * ```
+   *
+   * @param {string} newOid - New object ID (SHA1) for this reflog entry.
+   * @param {Signature} committer - Committer signature for this reflog entry.
+   * @param {string} [msg] - Optional message for this reflog entry.
+   * @throws Throws error if the OID is invalid or if appending fails.
+   */
+  append(newOid: string, committer: Signature, msg?: string | undefined | null): void
+  /**
+   * Remove an entry from the reflog.
+   *
+   * @category Reflog/Methods
+   *
+   * @signature
+   * ```ts
+   * class Reflog {
+   *   remove(i: number, rewritePreviousEntry?: boolean): void;
+   * }
+   * ```
+   *
+   * @param {number} i - Index of the entry to remove.
+   * @param {boolean} [rewritePreviousEntry] - Whether to rewrite the previous entry. Defaults to `false`.
+   * @throws Throws error if the index is invalid or if removal fails.
+   */
+  remove(i: number, rewritePreviousEntry?: boolean | undefined | null): void
+  /**
+   * Get a reflog entry by index.
+   *
+   * @category Reflog/Methods
+   *
+   * @signature
+   * ```ts
+   * class Reflog {
+   *   get(i: number): ReflogEntry | null;
+   * }
+   * ```
+   *
+   * @param {number} i - Index of the entry to get.
+   * @returns Reflog entry at the given index. Returns `null` if the index is out of bounds.
+   */
+  get(i: number): ReflogEntry | null
+  /**
+   * Get the number of entries in the reflog.
+   *
+   * @category Reflog/Methods
+   *
+   * @signature
+   * ```ts
+   * class Reflog {
+   *   len(): number;
+   * }
+   * ```
+   *
+   * @returns Number of entries in the reflog.
+   */
+  len(): number
+  /**
+   * Check if the reflog is empty.
+   *
+   * @category Reflog/Methods
+   *
+   * @signature
+   * ```ts
+   * class Reflog {
+   *   isEmpty(): boolean;
+   * }
+   * ```
+   *
+   * @returns `true` if the reflog is empty, `false` otherwise.
+   */
+  isEmpty(): boolean
+  /**
+   * Create an iterator over the entries in the reflog.
+   *
+   * @category Reflog/Methods
+   *
+   * @signature
+   * ```ts
+   * class Reflog {
+   *   iter(): ReflogIter;
+   * }
+   * ```
+   *
+   * @returns Iterator over the reflog entries.
+   * @throws Throws error if the reflog cannot be accessed.
+   */
+  iter(): ReflogIter
+  /**
+   * Write the reflog to disk.
+   *
+   * @category Reflog/Methods
+   *
+   * @signature
+   * ```ts
+   * class Reflog {
+   *   write(): void;
+   * }
+   * ```
+   *
+   * @throws Throws error if writing fails.
+   */
+  write(): void
+}
+
+/** A class to represent a git reflog entry. */
+export declare class ReflogEntry {
+  /**
+   * Get the committer of this reflog entry.
+   *
+   * @category ReflogEntry/Methods
+   *
+   * @signature
+   * ```ts
+   * class ReflogEntry {
+   *   committer(): Signature;
+   * }
+   * ```
+   *
+   * @returns Committer signature of this reflog entry.
+   */
+  committer(): Signature
+  /**
+   * Get the new object ID (SHA1) of this reflog entry.
+   *
+   * @category ReflogEntry/Methods
+   *
+   * @signature
+   * ```ts
+   * class ReflogEntry {
+   *   idNew(): string;
+   * }
+   * ```
+   *
+   * @returns New object ID (SHA1) of this reflog entry.
+   */
+  idNew(): string
+  /**
+   * Get the old object ID (SHA1) of this reflog entry.
+   *
+   * @category ReflogEntry/Methods
+   *
+   * @signature
+   * ```ts
+   * class ReflogEntry {
+   *   idOld(): string;
+   * }
+   * ```
+   *
+   * @returns Old object ID (SHA1) of this reflog entry.
+   */
+  idOld(): string
+  /**
+   * Get the message of this reflog entry.
+   *
+   * @category ReflogEntry/Methods
+   *
+   * @signature
+   * ```ts
+   * class ReflogEntry {
+   *   message(): string;
+   * }
+   * ```
+   *
+   * @returns Message of this reflog entry. Returns `null` if no message is present.
+   * @throws Throws error if the message is not valid utf-8.
+   */
+  message(): string | null
+}
+
+/**
+ * An iterator over the entries in a reflog.
+ *
+ * This type extends JavaScript's `Iterator`, and so has the iterator helper
+ * methods. It may extend the upcoming TypeScript `Iterator` class in the future.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator#iterator_helper_methods
+ * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-6.html#iterator-helper-methods
+ */
+export declare class ReflogIter extends Iterator<ReflogEntry, void, void> {
+
+  next(value?: void): IteratorResult<ReflogEntry, void>
+}
+
 /**
  * A class representing a [remote][1] of a git repository.
  *
@@ -3785,6 +3980,56 @@ export declare class Repository {
    * ```
    */
   getReference(name: string): Reference
+  /**
+   * Lookup a reflog by its name.
+   *
+   * @category Repository/Methods
+   *
+   * @signature
+   * ```ts
+   * class Repository {
+   *   reflog(name: string): Reflog;
+   * }
+   * ```
+   *
+   * @param {string} name - Name of the reference whose reflog to lookup (e.g., "HEAD", "refs/heads/main").
+   * @returns Reflog instance for the given reference name.
+   * @throws Throws error if the reflog does not exist or cannot be opened.
+   */
+  reflog(name: string): Reflog
+  /**
+   * Rename a reflog.
+   *
+   * @category Repository/Methods
+   *
+   * @signature
+   * ```ts
+   * class Repository {
+   *   reflogRename(oldName: string, newName: string): void;
+   * }
+   * ```
+   *
+   * @param {string} oldName - Old name of the reference.
+   * @param {string} newName - New name of the reference.
+   * @throws Throws error if renaming fails.
+   */
+  reflogRename(oldName: string, newName: string): void
+  /**
+   * Delete a reflog.
+   *
+   * @category Repository/Methods
+   *
+   * @signature
+   * ```ts
+   * class Repository {
+   *   reflogDelete(name: string): void;
+   * }
+   * ```
+   *
+   * @param {string} name - Name of the reference whose reflog to delete.
+   * @throws Throws error if deletion fails.
+   */
+  reflogDelete(name: string): void
   /**
    * List all remotes for a given repository
    *
@@ -4521,6 +4766,179 @@ export declare class Repository {
    * @returns A container for a list of status information about a repository.
    */
   statuses(): Statuses
+  /**
+   * Set up a new git submodule for checkout.
+   *
+   * This does "git submodule add" up to the fetch and checkout of the
+   * submodule contents. It preps a new submodule, creates an entry in
+   * `.gitmodules` and creates an empty initialized repository either at the
+   * given path in the working directory or in `.git/modules` with a gitlink
+   * from the working directory to the new repo.
+   *
+   * To fully emulate "git submodule add" call this function, then `open()`
+   * the submodule repo and perform the clone step as needed. Lastly, call
+   * `addFinalize()` to wrap up adding the new submodule and `.gitmodules`
+   * to the index to be ready to commit.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   submodule(
+   *     url: string,
+   *     path: string,
+   *     useGitlink?: boolean | null | undefined,
+   *   ): Submodule;
+   * }
+   * ```
+   *
+   * @param {string} url - URL for the submodule's remote.
+   * @param {string} path - Path at which the submodule should be created.
+   * @param {boolean} [useGitlink] - Should workdir contain a gitlink to the repo in
+   * `.git/modules` vs. repo directly in workdir.
+   *
+   * @returns The submodule.
+   */
+  submodule(url: string, path: string, useGitlink?: boolean | undefined | null): Submodule
+  submodules(): Array<Submodule>
+  /**
+   * Lookup submodule information by name or path.
+   *
+   * Given either the submodule name or path (they are usually the same),
+   * this returns a structure describing the submodule.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   getSubmodule(name: string): Submodule;
+   * }
+   * ```
+   *
+   * @param {string} name - The name of or path to the submodule; trailing slashes okay.
+   * @returns The submodule.
+   * @throws If the submodule not found.
+   */
+  getSubmodule(name: string): Submodule
+  /**
+   * Lookup submodule information by name or path.
+   *
+   * Given either the submodule name or path (they are usually the same),
+   * this returns a structure describing the submodule.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   findSubmodule(name: string): Submodule | null;
+   * }
+   * ```
+   *
+   * @param {string} name - The name of or path to the submodule; trailing slashes okay.
+   * @returns The submodule. Returns `null` if the submodule is not found.
+   */
+  findSubmodule(name: string): Submodule | null
+  /**
+   * Get the status for a submodule.
+   *
+   * This looks at a submodule and tries to determine the status.  It
+   * will return a combination of the `SubmoduleStatus` values.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   submoduleStatus(name: string, ignore: SubmoduleIgnore): number;
+   * }
+   * ```
+   *
+   * @param {string} name - The name of the submodule.
+   * @param {SubmoduleIgnore} ignore - The ignore rules to follow.
+   * @returns The combination of the `SubmoduleStatus` values.
+   *
+   * @example
+   * ```ts
+   * import { openRepository, submoduleStatusContains, SubmoduleStatus } from 'es-git';
+   *
+   * const repo = await openRepository('...');
+   * const status = repo.submoduleStatus('mysubmodule', 'None');
+   *
+   * console.log(
+   *   submoduleStatusContains(status, SubmoduleStatus.InHead | SubmoduleStatus.InIndex)
+   * ); // true
+   * ```
+   */
+  submoduleStatus(name: string, ignore: SubmoduleIgnore): number
+  /**
+   * Set the ignore rule for the submodule in the configuration
+   *
+   * This does not affect any currently-loaded instances.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   submoduleSetIgnore(name: string, ignore: SubmoduleIgnore): void;
+   * }
+   * ```
+   *
+   * @param {string} name - The name of the submodule.
+   * @param {SubmoduleIgnore} ignore - The new value for the ignore rule.
+   */
+  submoduleSetIgnore(name: string, ignore: SubmoduleIgnore): void
+  /**
+   * Set the update rule for the submodule in the configuration
+   *
+   * This setting won't affect any existing instances.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   submoduleSetUpdate(name: string, update: SubmoduleUpdate): void;
+   * }
+   * ```
+   *
+   * @param {string} name - The name of the submodule.
+   * @param {SubmoduleUpdate} update - The new value to use.
+   */
+  submoduleSetUpdate(name: string, update: SubmoduleUpdate): void
+  /**
+   * Set the URL for the submodule in the configuration
+   *
+   * After calling this, you may wish to call `Submodule#sync()` to write
+   * the changes to the checked out submodule repository.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   submoduleSetUrl(name: string, url: string): void;
+   * }
+   * ```
+   *
+   * @param {string} name - The name of the submodule to configure.
+   * @param {string} url - URL that should be used for the submodule.
+   */
+  submoduleSetUrl(name: string, url: string): void
+  /**
+   * Set the branch for the submodule in the configuration
+   *
+   * After calling this, you may wish to call `Submodule#sync()` to write
+   * the changes to the checked out submodule repository.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   submoduleSetBranch(name: string, branchName: string): void;
+   * }
+   * ```
+   *
+   * @param {string} name - The name of the submodule to configure.
+   * @param {string} branchName - Branch that should be used for the submodule
+   */
+  submoduleSetBranch(name: string, branchName: string): void
   /**
    * Lookup a tag object by prefix hash from the repository.
    *
@@ -5321,6 +5739,325 @@ export declare class StatusesIter extends Iterator<StatusEntry, void, void> {
   next(value?: void): IteratorResult<StatusEntry, void>
 }
 
+export declare class Submodule {
+  /**
+   * Get the name for the submodule.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   name(): string;
+   * }
+   * ```
+   */
+  name(): string
+  /**
+   *  Get the submodule's branch.
+   * ule/Methods
+   *  @signature
+   *  ```ts
+   *  class Submodule {
+   *    branch(): string | null;
+   *  }
+   *  ```
+   *  @returns The branch name of the submodule. Returns `null` if the branch if the branch is
+   *  not yet available.
+   */
+  branch(): string | null
+  /**
+   * Get the submodule's URL.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   url(): string | null;
+   * }
+   * ```
+   *
+   * @returns The URL of the submodule. Returns `null` if the URL isn't present.
+   */
+  url(): string | null
+  /**
+   * Get the path for the submodule.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   path(): string;
+   * }
+   * ```
+   *
+   * @returns The path for the submodule.
+   */
+  path(): string
+  /**
+   * Get the OID for the submodule in the current `HEAD` tree.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   headId(): string | null;
+   * }
+   * ```
+   *
+   * @returns The OID for the submodule in the current `HEAD` tree.
+   */
+  headId(): string | null
+  /**
+   * Get the OID for the submodule in the index.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   indexId(): string | null;
+   * }
+   * ```
+   *
+   * @returns The OID for the submodule in the index.
+   */
+  indexId(): string | null
+  /**
+   * Get the OID for the submodule in the current working directory.
+   *
+   * This returns the OID that corresponds to looking up `HEAD` in the
+   * checked out submodule. If there are pending changes in the index or
+   * anything else, this won't notice that.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   workdirId(): string | null;
+   * }
+   * ```
+   *
+   * @returns The OID for the submodule in the current working directory.
+   */
+  workdirId(): string | null
+  /**
+   * Get the ignore rule that will be used for the submodule.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   ignoreRule(): SubmoduleIgnore;
+   * }
+   * ```
+   *
+   * @returns The ignore rule that will be used for the submodule.
+   */
+  ignoreRule(): SubmoduleIgnore
+  /**
+   * Get the update rule that will be used for the submodule.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   updateStrategy(): SubmoduleUpdate;
+   * }
+   * ```
+   *
+   * @returns The update rule that will be used for the submodule.
+   */
+  updateStrategy(): SubmoduleUpdate
+  /**
+   * Copy submodule info into ".git/config" file.
+   *
+   * Just like "git submodule init", this copies information about the
+   * submodule into ".git/config". You can use the accessor functions above
+   * to alter the in-memory git_submodule object and control what is written
+   * to the config, overriding what is in .gitmodules.
+   *
+   * By default, existing entries will not be overwritten, but passing `true`
+   * for `overwrite` forces them to be updated.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   init(
+   *     overwrite?: boolean | null | undefined,
+   *     signal?: AbortSignal | null | undefined,
+   *   ): Promise<void>;
+   * }
+   * ```
+   *
+   * @param {boolean} [overwrite] - By default, existing entries will not be overwritten, but
+   * setting this to true forces them to be updated.
+   * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the operation.
+   */
+  init(overwrite?: boolean | undefined | null, signal?: AbortSignal | undefined | null): Promise<void>
+  /**
+   * Set up the subrepository for a submodule in preparation for clone.
+   *
+   * This function can be called to init and set up a submodule repository
+   * from a submodule in preparation to clone it from its remote.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   repoInit(
+   *     useGitlink?: boolean | null | undefined,
+   *     signal?: AbortSignal | null | undefined,
+   *   ): Promise<Repository>;
+   * }
+   * ```
+   *
+   * @param {boolean} [useGitlink] - Should the workdir contain a gitlink to the repo in
+   * `.git/modules` vs. repo directly in workdir.
+   * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the operation.
+   *
+   * @returns The repository.
+   */
+  repoInit(useGitlink?: boolean | undefined | null, signal?: AbortSignal | undefined | null): Promise<Repository>
+  /**
+   * Open the repository for a submodule.
+   *
+   * This will only work if the submodule is checked out into the working
+   * directory.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   open(signal?: AbortSignal | null | undefined): Promise<Repository>;
+   * }
+   * ```
+   *
+   * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the operation.
+   * @returns The repository.
+   */
+  open(signal?: AbortSignal | undefined | null): Promise<Repository>
+  /**
+   * Reread submodule info from config, index, and `HEAD`.
+   *
+   * Call this to reread cached submodule information for this submodule if
+   * you have reason to believe that it has changed.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   reload(
+   *     force?: boolean | null | undefined,
+   *     signal?: AbortSignal | null | undefined,
+   *   ): Promise<void>;
+   * }
+   * ```
+   *
+   * @param {boolean} [force] - If this is `true`, then data will be reloaded even if it
+   * doesn't seem out of date.
+   * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the operation.
+   */
+  reload(force?: boolean | undefined | null, signal?: AbortSignal | undefined | null): Promise<void>
+  /**
+   * Copy submodule remote info into submodule repo.
+   *
+   * This copies the information about the submodules URL into the checked
+   * out submodule config, acting like "git submodule sync". This is useful
+   * if you have altered the URL for the submodule (or it has been altered
+   * by a fetch of upstream changes) and you need to update your local repo.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   sync(signal?: AbortSignal | null | undefined): Promise<void>;
+   * }
+   * ```
+   *
+   * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the operation.
+   */
+  sync(signal?: AbortSignal | undefined | null): Promise<void>
+  /**
+   * Add current submodule HEAD commit to index of superproject.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   addToIndex(writeIndex?: boolean | null | undefined): void;
+   * }
+   * ```
+   *
+   * @param {boolean} [writeIndex] - If is true, then the index file will be immediately written.
+   * Otherwise, you must explicitly call `write()` on an `Index` later on.
+   */
+  addToIndex(writeIndex?: boolean | undefined | null): void
+  /**
+   * Resolve the setup of a new git submodule.
+   *
+   * This should be called on a submodule once you have called add setup and
+   * done the clone of the submodule. This adds the `.gitmodules` file and the
+   * newly cloned submodule to the index to be ready to be committed (but
+   * doesn't actually do the commit).
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   addFinalize(): void;
+   * }
+   * ```
+   */
+  addFinalize(): void
+  /**
+   * Update submodule.
+   *
+   * This will clone a missing submodule and check out the subrepository to
+   * the commit specified in the index of the containing repository. If
+   * the submodule repository doesn't contain the target commit, then the
+   * submodule is fetched using the fetch options supplied in options.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   update(
+   *     init?: boolean | null | undefined,
+   *     options?: SubmoduleUpdateOptions | null | undefined,
+   *     signal?: AbortSignal | null | undefined,
+   *   ): Promise<void>;
+   * }
+   * ```
+   *
+   * @param {boolean} [init] - Indicates if the submodule should be initialized first if it has
+   * not been initialized yet.
+   * @param {SubmoduleUpdateOptions} [options] - Configuration options for the update.
+   * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the operation.
+   */
+  update(init?: boolean | undefined | null, options?: SubmoduleUpdateOptions | undefined | null, signal?: AbortSignal | undefined | null): Promise<void>
+  /**
+   * Perform the clone step for a newly created submodule.
+   *
+   * This performs the necessary `git clone` to setup a newly-created submodule.
+   *
+   * @category Submodule/Methods
+   * @signature
+   * ```ts
+   * class Submodule {
+   *   clone(
+   *     options?: SubmoduleUpdateOptions | null | undefined,
+   *     signal?: AbortSignal | null | undefined,
+   *   ): Promise<Repository>;
+   * }
+   * ```
+   *
+   * @param {SubmoduleUpdateOptions} [options] - The options to use.
+   * @param {AbortSignal} [signal] - Optional AbortSignal to cancel the operation.
+   * @returns The newly created repository object.
+   */
+  clone(options?: SubmoduleUpdateOptions | undefined | null, signal?: AbortSignal | undefined | null): Promise<Repository>
+}
+
 /**
  * A class to represent a git [tag][1].
  *
@@ -8060,6 +8797,145 @@ export type StatusShow =  'Index'|
 'Workdir'|
 'IndexAndWorkdir';
 
+/**
+ * Submodule ignore values
+ *
+ * These values represent settings for the `submodule.$name.ignore`
+ * configuration value which says how deeply to look at the working
+ * directory when getting the submodule status.
+ */
+export type SubmoduleIgnore = /** Use the submodule's configuration */
+'Unspecified'|
+/** Any change or untracked file is considered dirty */
+'None'|
+/** Only dirty if tracked files have changed */
+'Untracked'|
+/** Only dirty if HEAD has moved */
+'Dirty'|
+/** Never dirty */
+'All';
+
+/**
+ * Return codes for submodule status.
+ *
+ * A combination of these flags will be returned to describe the status of a
+ * submodule.  Depending on the "ignore" property of the submodule, some of
+ * the flags may never be returned because they indicate changes that are
+ * supposed to be ignored.
+ *
+ * Submodule info is contained in 4 places: the HEAD tree, the index, config
+ * files (both .git/config and .gitmodules), and the working directory.  Any
+ * or all of those places might be missing information about the submodule
+ * depending on what state the repo is in.  We consider all four places to
+ * build the combination of status flags.
+ *
+ * There are four values that are not really status, but give basic info
+ * about what sources of submodule data are available.  These will be
+ * returned even if ignore is set to "ALL".
+ *
+ * * IN_HEAD   - superproject head contains submodule
+ * * IN_INDEX  - superproject index contains submodule
+ * * IN_CONFIG - superproject gitmodules has submodule
+ * * IN_WD     - superproject workdir has submodule
+ *
+ * The following values will be returned so long as ignore is not "ALL".
+ *
+ * * INDEX_ADDED       - in index, not in head
+ * * INDEX_DELETED     - in head, not in index
+ * * INDEX_MODIFIED    - index and head don't match
+ * * WD_UNINITIALIZED  - workdir contains empty directory
+ * * WD_ADDED          - in workdir, not index
+ * * WD_DELETED        - in index, not workdir
+ * * WD_MODIFIED       - index and workdir head don't match
+ *
+ * The following can only be returned if ignore is "NONE" or "UNTRACKED".
+ *
+ * * WD_INDEX_MODIFIED - submodule workdir index is dirty
+ * * WD_WD_MODIFIED    - submodule workdir has modified files
+ *
+ * Lastly, the following will only be returned for ignore "NONE".
+ *
+ * * WD_UNTRACKED      - workdir contains untracked files
+ */
+export declare enum SubmoduleStatus {
+  InHead = 1,
+  InIndex = 2,
+  InConfig = 4,
+  InWD = 8,
+  IndexAdded = 16,
+  IndexDeleted = 32,
+  IndexModified = 64,
+  WDUninitialized = 128,
+  WDAdded = 256,
+  WDDeleted = 512,
+  WDModified = 1024,
+  WDIndexModified = 2048,
+  WDWDModified = 4096,
+  WDUntracked = 8192
+}
+
+/**
+ * Check submodule status contains given value.
+ *
+ * @category Submodule
+ * @signature
+ * ```ts
+ * function submoduleStatusContains(source: number, target: number): boolean;
+ * ```
+ *
+ * @param {number} source - Source status.
+ * @param {number} target - Target status.
+ * @returns Returns `true` is source status contains target status.
+ */
+export declare function submoduleStatusContains(source: number, target: number): boolean
+
+/**
+ * Submodule update values
+ *
+ * These values represent settings for the `submodule.$name.update`
+ * configuration value which says how to handle `git submodule update`
+ * for this submodule. The value is usually set in the ".gitmodules"
+ * file and copied to ".git/config" when the submodule is initialized.
+ */
+export type SubmoduleUpdate = /**
+ * The default; when a submodule is updated| checkout the new detached
+ * HEAD to the submodule directory.
+ */
+'Checkout'|
+/**
+ * Update by rebasing the current checked out branch onto the commit from
+ * the superproject.
+ */
+'Rebase'|
+/**
+ * Update by merging the commit in the superproject into the current
+ * checkout out branch of the submodule.
+ */
+'Merge'|
+/**
+ * Do not update this submodule even when the commit in the superproject
+ * is updated.
+ */
+'None'|
+/**
+ * Not used except as static initializer when we don't want any particular
+ * update rule to be specified.
+ */
+'Default';
+
+/** Options to update a submodule. */
+export interface SubmoduleUpdateOptions {
+  /** These options are passed to the checkout step. */
+  checkout?: CheckoutOptions
+  /** Options which control the fetch, including callbacks. */
+  fetch?: FetchOptions
+  /**
+   * Allow fetching from the submodule's default remote if the target commit isn't found.
+   * Default: `true`.
+   */
+  allowFetch?: boolean
+}
+
 /**
  * Clear the global subscriber
  *

package/index.js

@@ -596,6 +596,9 @@ module.exports.Note = nativeBinding.Note
 module.exports.Notes = nativeBinding.Notes
 module.exports.Rebase = nativeBinding.Rebase
 module.exports.Reference = nativeBinding.Reference
+module.exports.Reflog = nativeBinding.Reflog
+module.exports.ReflogEntry = nativeBinding.ReflogEntry
+module.exports.ReflogIter = nativeBinding.ReflogIter
 module.exports.Remote = nativeBinding.Remote
 module.exports.Repository = nativeBinding.Repository
 module.exports.Revwalk = nativeBinding.Revwalk
@@ -605,6 +608,7 @@ module.exports.StashListIter = nativeBinding.StashListIter
 module.exports.StatusEntry = nativeBinding.StatusEntry
 module.exports.Statuses = nativeBinding.Statuses
 module.exports.StatusesIter = nativeBinding.StatusesIter
+module.exports.Submodule = nativeBinding.Submodule
 module.exports.Tag = nativeBinding.Tag
 module.exports.Tree = nativeBinding.Tree
 module.exports.TreeEntry = nativeBinding.TreeEntry
@@ -656,6 +660,10 @@ module.exports.RevparseMode = nativeBinding.RevparseMode
 module.exports.revparseModeContains = nativeBinding.revparseModeContains
 module.exports.RevwalkSort = nativeBinding.RevwalkSort
 module.exports.StatusShow = nativeBinding.StatusShow
+module.exports.SubmoduleIgnore = nativeBinding.SubmoduleIgnore
+module.exports.SubmoduleStatus = nativeBinding.SubmoduleStatus
+module.exports.submoduleStatusContains = nativeBinding.submoduleStatusContains
+module.exports.SubmoduleUpdate = nativeBinding.SubmoduleUpdate
 module.exports.traceClear = nativeBinding.traceClear
 module.exports.TraceLevel = nativeBinding.TraceLevel
 module.exports.traceSet = nativeBinding.traceSet

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-git",
-  "version": "0.5.0-next.170+131625d",
+  "version": "0.5.0-next.172+1b12e25",
   "main": "index.js",
   "types": "index.d.ts",
   "files": [
@@ -54,15 +54,15 @@
     "vitest": "^3.0.5"
   },
   "optionalDependencies": {
-    "es-git-darwin-x64": "0.5.0-next.170+131625d",
-    "es-git-darwin-arm64": "0.5.0-next.170+131625d",
-    "es-git-win32-x64-msvc": "0.5.0-next.170+131625d",
-    "es-git-win32-arm64-msvc": "0.5.0-next.170+131625d",
-    "es-git-linux-x64-gnu": "0.5.0-next.170+131625d",
-    "es-git-linux-x64-musl": "0.5.0-next.170+131625d",
-    "es-git-android-arm64": "0.5.0-next.170+131625d",
-    "es-git-linux-arm64-gnu": "0.5.0-next.170+131625d",
-    "es-git-linux-arm64-musl": "0.5.0-next.170+131625d",
-    "es-git-android-arm-eabi": "0.5.0-next.170+131625d"
+    "es-git-darwin-x64": "0.5.0-next.172+1b12e25",
+    "es-git-darwin-arm64": "0.5.0-next.172+1b12e25",
+    "es-git-win32-x64-msvc": "0.5.0-next.172+1b12e25",
+    "es-git-win32-arm64-msvc": "0.5.0-next.172+1b12e25",
+    "es-git-linux-x64-gnu": "0.5.0-next.172+1b12e25",
+    "es-git-linux-x64-musl": "0.5.0-next.172+1b12e25",
+    "es-git-android-arm64": "0.5.0-next.172+1b12e25",
+    "es-git-linux-arm64-gnu": "0.5.0-next.172+1b12e25",
+    "es-git-linux-arm64-musl": "0.5.0-next.172+1b12e25",
+    "es-git-android-arm-eabi": "0.5.0-next.172+1b12e25"
   }
 }