git

type Batch struct {
	// Paths are touched paths relative to the worktree root, sorted,
	// deduplicated, never ignored. A removed directory appears as its own path
	// and its children may be absent: treat a vanished path as a prefix. Files a
	// .gitignore change un-ignores are listed only in newly watched
	// directories: treat a touched .gitignore as "everything may have changed".
	Paths    []string
	Git      bool // HEAD, the index, packed-refs or a ref outside refs/aim changed
	Overflow bool // events were lost; treat everything as changed
}

type BranchSource struct{ Worktree, Base string }

type Commit struct{ OID, Subject, Body string }

type Created struct {
	Worktree Worktree
	Excluded bool   // this call added /.worktrees/ to info/exclude
	Tools    []Tool // tools that need their own ignore entry (RootInside only)
}

type Engine struct {
	// contains filtered or unexported fields
}

type EngineOptions struct {
	Limits     Limits // zero fields take the defaults
	TempDir    string // where working-tree snapshots keep their temporary index
	IndexCache string // keeps a refreshed index copy per worktree; empty = none
}

type FileDiff struct {
	Path, OldPath                string
	Status                       Status
	OldOID, NewOID               string // full ids; "" on the side a file does not exist
	OldMode, NewMode             string
	Binary, Untracked, Truncated bool
	Added, Removed               int
	Hunks                        []Hunk
}

type HeadInfo struct {
	Branch   string // without refs/heads/
	Detached bool
	OID      string // full commit id
}

type Hunk struct {
	OldStart, OldLines, NewStart, NewLines int
	Section                                string
	Lines                                  []Line
}

type Limits struct{ Files, Bytes, Lines int }

type Line struct {
	Kind      LineKind
	Old, New  int // line numbers; 0 on the side the line is not on
	Text      string
	NoNewline bool
}

type LineKind byte

type NewWorktree struct {
	Branch string
	Base   string // "" = the default branch; ignored when Branch already exists
	Root   RootStyle
}

type OpenTurn struct {
	Root string // from the start's Worktree trailer
	N    int
}

type PRRefs struct{ Head, Base string }

type PRSource struct {
	Worktree string
	Number   int
}

type Place struct {
	Root   string // the worktree's top level
	Common string // the repository's common dir, shared by its worktrees
	Repo   string // the repository's name, Repo.Name
}

type PlaceCache struct {
	// contains filtered or unexported fields
}

type PushResult struct {
	Remote, Branch string
	Dst            string // the remote ref pushed to
	Created        bool   // the remote branch is new
	UpToDate       bool
	SetUpstream    bool
}

type Repo struct {
	Root      string // the worktree's top level, absolute
	GitDir    string // this worktree's git dir, absolute
	CommonDir string // the repository's common dir, absolute
}

type Result struct {
	Old, New  string // tree ids
	Live      bool   // New is the working tree
	Turn      int    // turn sources: the position shown in the worktree's list
	Turns     int    // turn sources: how many turns the worktree's list held
	Head      string // PR sources: the head commit shown; a merge passes it
	Files     []FileDiff
	Truncated bool
}

type RootBatch struct {
	Root  string
	Batch Batch
	Err   error
}

type RootStyle int

type SnapshotOptions struct {
	TempDir      string // where the temporary index is created
	IndexCache   string // keeps a refreshed index copy per worktree; empty = none
	MaxUntracked int64  // bytes; 0 = 50 MiB, negative = no cap
	Unchanged    bool   // reuse the worktree's latest tree in the session without staging
	Turn         int    // the turn's number; 0 takes one more than the session's highest in the repository
	Ends         int    // a turn of this worktree to end with the same tree when it is open; 0 for none
}

type Source interface {
	// contains filtered or unexported methods
}

type Stats struct{ Files, Added, Removed int }

type Status string

type Tool struct {
	Name string
	Path string // the file or directory that triggered it, relative to the root
	Hint string // what to add
}

type TreeOptions struct {
	TempDir      string // where the temporary index is created
	IndexCache   string // keeps a refreshed index copy per worktree; empty = none
	MaxUntracked int64  // bytes; 0 = 50 MiB, negative = no cap
}

type Turn struct {
	N          int
	Commit     string // the start
	Tree       string
	Missing    bool   // the start is a "no snapshot" marker
	EndCommit  string // "" while the turn is open
	EndTree    string
	EndMissing bool // the end is a marker
	Current    bool // N is the session's highest turn number in the repository
	Skipped    []string
	Time       time.Time // the start's committer time
}

type TurnList struct {
	Turns []Turn
	Live  bool // the last is the open current turn and differs from the working tree
}

type TurnSource struct {
	Worktree, Session string
	Turn              int
}

type WatchOptions struct {
	Debounce time.Duration // quiet time before a batch goes out; 100 ms when zero
	MaxDelay time.Duration // longest an unsent change waits while events keep coming; 1 s when zero
	SeqBase  uint64        // Seq's starting value, so a restarted watcher never repeats one
	// contains filtered or unexported fields
}

type WatchSet struct {
	// contains filtered or unexported fields
}

type Watcher struct {
	// contains filtered or unexported fields
}

type WorkTree struct {
	Tree      string   // tree id of the working tree as git would stage it
	Untracked []string // untracked paths that entered the tree
	Skipped   []string // untracked paths over the size cap, left out
}

type Worktree struct {
	Path, Head, Branch      string // Branch is without refs/heads/; "" when detached or bare
	Main, Bare, Detached    bool
	Locked, Prunable        bool
	LockReason, PruneReason string
}