zeta

type AddOptions struct {
	// All equivalent to `git add -A`, update the index not only where the
	// working tree has a file matching `Path` but also where the index already
	// has an entry. This adds, modifies, and removes index entries to match the
	// working tree.  If no `Path` nor `Glob` is given when `All` option is
	// used, all files in the entire working tree are updated.
	All bool
	// Path is the exact filepath to the file or directory to be added.
	Path string
	// Glob adds all paths, matching pattern, to the index. If pattern matches a
	// directory path, all directory contents are added to the index recursively.
	Glob string
	// SkipStatus adds the path with no status check. This option is relevant only
	// when the `Path` option is specified and does not apply when the `All` option is used.
	// Notice that when passing an ignored path it will be added anyway.
	// When true it can speed up adding files to the worktree in very large repositories.
	SkipStatus bool
	DryRun     bool
}

type BlameResult struct {
	// Path is the path of the File that we're blaming.
	Path string
	// Rev (Revision) is the hash of the specified Commit used to generate this result.
	Rev plumbing.Hash
	// Lines contains every line with its authorship.
	Lines []*Line
}

type BranchEntry struct {
	Name    string        `json:"name"`
	Current bool          `json:"current,omitempty"`
	Hash    plumbing.Hash `json:"hash"`
}

type CatOptions struct {
	Object    string
	Limit     int64 // blob limit size
	Type      bool  // object type
	PrintSize bool
	PrintJSON bool
	Verify    bool
	Textconv  bool
	Direct    bool
	Output    string
	// Image controls inline image rendering for binary blobs.
	// Empty string is treated as "auto" (honour detected terminal capability).
	// See term.ParseImageMode for accepted values.
	Image string
}

type CheckIgnoreOption struct {
	Paths []string
	Stdin bool
	Z     bool
	JSON  bool
}

type CheckoutOptions struct {
	// Hash is the hash of the commit to be checked out. If used, HEAD will be
	// in detached mode. If Create is not used, Branch and Hash are mutually
	// exclusive.
	Hash plumbing.Hash
	// Branch to be checked out, if Branch and Hash are empty is set to `master`.
	Branch plumbing.ReferenceName
	// Create a new branch named Branch and start it at Hash.
	Create bool
	Force  bool
	Merge  bool
	First  bool
	One    bool
	Quiet  bool
}

type CherryPickOptions struct {
	From     string // From commit
	FF       bool
	Abort    bool
	Skip     bool
	Continue bool
}

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

type CleanOptions struct {
	// dry run
	DryRun bool
	// Dir recurses into nested directories.
	Dir bool
	// All removes all changes, even those excluded by gitignore.
	All bool
}

type CommitOptions struct {
	// All automatically stage files that have been modified and deleted, but
	// new files you have not told Git about are not affected.
	All bool
	// AllowEmptyCommits enable empty commits to be created. An empty commit
	// is when no changes to the tree were made, but a new commit message is
	// provided. The default behavior is false, which results in ErrEmptyCommit.
	AllowEmptyCommits bool
	// Author is the author's signature of the commit. If Author is empty the
	// Name and Email is read from the config, and time.Now it's used as When.
	Author object.Signature
	// Committer is the committer's signature of the commit. If Committer is
	// nil the Author signature is used.
	Committer object.Signature
	// Parents are the parents commits for the new commit, by default when
	// len(Parents) is zero, the hash of HEAD reference is used.
	Parents []plumbing.Hash
	// SignKey denotes a key to sign the commit with. A nil value here means the
	// commit will not be signed. The private key must be present and already
	// decrypted.
	SignKey *openpgp.Entity
	// Amend will create a new commit object and replace the commit that HEAD currently
	// points to. Cannot be used with All nor Parents.
	Amend             bool
	AllowEmptyMessage bool
	Message           []string
	File              string
}

type CommitTreeOptions struct {
	Tree plumbing.Hash
	// Author is the author's signature of the commit. If Author is empty the
	// Name and Email is read from the config, and time.Now it's used as When.
	Author object.Signature
	// Committer is the committer's signature of the commit. If Committer is
	// nil the Author signature is used.
	Committer object.Signature
	// Parents are the parents commits for the new commit, by default when
	// len(Parents) is zero, the hash of HEAD reference is used.
	Parents []plumbing.Hash
	// SignKey denotes a key to sign the commit with. A nil value here means the
	// commit will not be signed. The private key must be present and already
	// decrypted.
	SignKey *openpgp.Entity
	// Amend will create a new commit object and replace the commit that HEAD currently
	// points to. Cannot be used with All nor Parents.
	Message string
}

type Content struct {
	Text     string
	Hash     string
	Mode     filemode.FileMode
	IsBinary bool
}

type DiffOptions struct {
	Nav        bool
	NameOnly   bool
	NameStatus bool // name status
	Numstat    bool
	Stat       bool
	Shortstat  bool
	Staged     bool
	JSON       bool
	NewLine    byte
	NewOutput  func(context.Context) (Printer, error) // new writer func
	NoRename   bool
	// index value
	MergeBase string
	From      string
	To        string
	PathSpec  []string
	Textconv  bool
	UseColor  bool
	ThreeWay  bool
	Algorithm diferenco.Algorithm
}

type DoFetchOptions struct {
	Name        string
	Unshallow   bool
	Limit       int64
	Tag         bool
	Force       bool
	FetchAlways bool
	SkipLarges  bool
}

type ErrExitCode struct {
	ExitCode int
	Message  string
}

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

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

type FetchOptions struct {
	Target     plumbing.Hash
	DeepenFrom plumbing.Hash
	Have       plumbing.Hash
	Deepen     int
	Depth      int
	SizeLimit  int64
	SkipLarges bool
}

type FetchResult struct {
	*transport.Reference
	FETCH_HEAD plumbing.Hash
}

type FileStatus struct {
	// Staging is the status of a file in the staging area
	Staging StatusCode
	// Worktree is the status of a file in the worktree
	Worktree StatusCode
	// Extra contains extra information, such as the previous name in a rename
	Extra string
}

type FileStatusJSON struct {
	Path     string     `json:"path"`
	Staging  StatusCode `json:"staging,omitempty"`
	Worktree StatusCode `json:"worktree,omitempty"`
	Extra    string     `json:"extra,omitempty"`
}

type ForEachReferenceOptions struct {
	FormatJSON bool
	Order      string
	Pattern    []string
}

type GcOptions struct {
	Prune time.Duration
}

type GetConfigOptions struct {
	System bool
	Global bool
	Local  bool
	ALL    bool
	Z      bool
	JSON   bool
	Keys   []string
	CWD    string
	Values []string
}

type GrepOptions struct {
	// Patterns are compiled Regexp objects to be matched.
	Patterns []*regexp.Regexp
	// InvertMatch selects non-matching lines.
	InvertMatch bool
	// CommitHash is the hash of the commit from which worktree should be derived.
	CommitHash plumbing.Hash
	// ReferenceName is the branch or tag name from which worktree should be derived.
	ReferenceName plumbing.ReferenceName
	// PathSpecs are compiled Regexp objects of pathspec to use in the matching.
	PathSpecs []*regexp.Regexp
	// Size Limit
	Limit int64
}

type GrepResult struct {
	// FileName is the name of file which contains match.
	FileName string
	// LineNumber is the line number of a file at which a match was found.
	LineNumber int
	// Content is the content of the file at the matching line.
	Content string
	// TreeName is the name of the tree (reference name/commit hash) at
	// which the match was performed.
	TreeName string
}

type InitOptions struct {
	Branch    string
	Worktree  string
	MustEmpty bool
	Quiet     bool
	Verbose   bool
	Values    []string
}

type JsonTreeEntry struct {
	Name string            `json:"name"`
	Size int64             `json:"size"`
	Mode filemode.FileMode `json:"mode"`
	Hash plumbing.Hash     `json:"hash"`
}

type Line struct {
	// Author is the email address of the last author that modified the line.
	Author string
	// AuthorName is the name of the last author that modified the line.
	AuthorName string
	// Text is the original text of the line.
	Text string
	// Date is when the original text of the line was introduced
	Date time.Time
	// Hash is the commit hash that introduced the original line
	Hash plumbing.Hash
}

type ListBranchOptions struct {
	JSON    bool
	Pattern []string
}

type ListConfigOptions struct {
	System bool
	Global bool
	Local  bool
	Z      bool
	JSON   bool
	CWD    string
	Values []string
}

type ListFilesMode int

type ListTagOptions struct {
	JSON    bool
	Pattern []string
}

type LogCommandOptions struct {
	Revision             string
	Order                LogOrder
	OrderByCommitterDate bool
	OrderByAuthorDate    bool
	Reverse              bool
	FormatJSON           bool
	JSONLimit            int
	Paths                []string
}

type LogOptions struct {
	// When the From option is set the log will only contain commits
	// reachable from it. If this option is not set, HEAD will be used as
	// the default From.
	From plumbing.Hash

	// The default traversal algorithm is Depth-first search
	// set Order=LogOrderCommitterTime for ordering by committer time (more compatible with `git log`)
	// set Order=LogOrderBFS for Breadth-first search
	Order LogOrder

	// Show only those commits in which the specified file was inserted/updated.
	// It is equivalent to running `zeta log -- <file-name>`.
	// this field is kept for compatibility, it can be replaced with PathFilter
	FileName *string

	// Filter commits based on the path of files that are updated
	// takes file path as argument and should return true if the file is desired
	// It can be used to implement `zeta log -- <path>`
	// either <path> is a file path, or directory path, or a regexp of file/directory path
	PathFilter func(string) bool

	// Pretend as if all the refs in refs/, along with HEAD, are listed on the command line as <commit>.
	// It is equivalent to running `zeta log --all`.
	// If set on true, the From option will be ignored.
	All bool

	// Show commits more recent than a specific date.
	// It is equivalent to running `zeta log --since <date>` or `zeta log --after <date>`.
	Since *time.Time

	// Show commits older than a specific date.
	// It is equivalent to running `zeta log --until <date>` or `zeta log --before <date>`.
	Until *time.Time

	//
	Reverse bool
}

type LogOrder int8

type LsFilesOptions struct {
	Mode  ListFilesMode
	Z     bool
	JSON  bool
	Paths []string
}

type LsTreeOptions struct {
	OnlyTrees bool
	Recurse   bool
	Tree      bool
	NewLine   byte
	Long      bool
	NameOnly  bool
	Abbrev    int
	Revision  string
	Paths     []string
	JSON      bool
}

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

type MergeFileOptions struct {
	O, A, B                string
	LabelO, LabelA, LabelB string
	Style                  int
	DiffAlgorithm          string
	Stdout                 bool
	Textconv               bool
}

type MergeOptions struct {
	From string // From branch
	// Requires a merge to be fast forward only. If this is true, then a merge will
	// throw an error if ff is not possible.
	FFOnly                            bool
	FF                                bool
	Squash                            bool
	Signoff                           bool
	AllowUnrelatedHistories, Textconv bool
	Abort                             bool
	Continue                          bool
	Message                           []string
	File                              string
}

type MergeTreeOptions struct {
	Branch1, Branch2, MergeBase                          string
	AllowUnrelatedHistories, Z, NameOnly, Textconv, JSON bool
}

type NewOptions struct {
	Remote      string
	Branch      string
	TagName     string
	Commit      string
	Refname     string
	Destination string
	Depth       int
	SparseDirs  []string
	Snapshot    bool
	SizeLimit   int64
	Values      []string
	One         bool
	Quiet       bool
	Verbose     bool
}

type NewTagOptions struct {
	Name     string
	Target   string
	Message  []string
	File     string
	Annotate bool
	Force    bool
}

type NopWriteCloser struct {
	io.Writer
}

type OpenOptions struct {
	Worktree string
	Quiet    bool
	Verbose  bool
	Values   []string
}

type Printer interface {
	io.WriteCloser
	ColorMode() term.Level
	EnableColor() bool
}

type ProgressBar interface {
	Add(int)
}

type PullOptions struct {
	FF, FFOnly, Rebase, Squash, Unshallow, One bool
	Limit                                      int64
}

type PushOptions struct {
	// Refspece: eg:
	//
	//  zeta push dev      // update branch or tag
	//  zeta push :dev     // delete branch or tag
	//  zeta push rev:dev  // update reference to rev
	//  zeta push          // update current branch
	Refspec     string
	PushOptions []string
	Tag         bool
	Force       bool
}

type RebaseMD struct {
	REBASE_HEAD plumbing.Hash          `toml:"REBASE_HEAD"` // REBASE_HEAD
	ONTO        plumbing.Hash          `toml:"ONTO"`        // ONTO Hash
	STOPPED     plumbing.Hash          `toml:"STOPPED"`     // STOPPED Hash
	LAST        plumbing.Hash          `toml:"LAST"`        // LAST
	MERGE_TREE  plumbing.Hash          `toml:"MERGE_TREE"`  // MERGE_TREE
	HEAD        plumbing.ReferenceName `toml:"HEAD"`        // HEAD aka CURRENT
}

type RebaseOptions struct {
	Branch   string
	Upstream string
	Onto     string
	Abort    bool
	Continue bool
}

type Reference struct {
	Name      plumbing.ReferenceName `json:"refname"`
	ShortName string                 `json:"refname_short"`
	Hash      plumbing.Hash          `json:"objectname"` // object name : commit/tag object ...
	Size      int                    `json:"objectsize"`
	Type      string                 `json:"objecttype"`
	Target    *object.Commit         `json:"commit,omitempty"`
	Tag       *object.Tag            `json:"tag,omitempty"`
	IsCurrent bool                   `json:"head,omitempty"`
}

type ReferenceLite struct {
	Name      plumbing.ReferenceName
	ShortName plumbing.ReferenceName
	Target    plumbing.ReferenceName
}

type References []*Reference

type ReferencesEx struct {
	*refs.DB
	M map[plumbing.Hash][]*ReferenceLite
}

type RemoteInfo struct {
	Remote string `json:"remote"`
}

type RemoveOptions struct {
	DryRun  bool
	Cached  bool
	Force   bool
	Recurse bool
}

type RenameOptions struct {
	DryRun bool
	Force  bool
}

type ReplayMD struct {
	BASE       plumbing.Hash          `toml:"BASE"`
	LAST       plumbing.Hash          `toml:"LAST"`       // LAST
	MERGE_TREE plumbing.Hash          `toml:"MERGE_TREE"` // MERGE_TREE
	HEAD       plumbing.ReferenceName `toml:"HEAD"`       // HEAD aka CURRENT --> branch
}

type Repository struct {
	*config.Config
	refs.Backend
	// contains filtered or unexported fields
}

type ResetMode int8

type ResetOptions struct {
	// Commit, if commit is present set the current branch head (HEAD) to it.
	Commit plumbing.Hash
	// Mode, form resets the current branch head to Commit and possibly updates
	// the index (resetting it to the tree of Commit) and the working tree
	// depending on Mode. If empty MixedReset is used.
	Mode ResetMode

	// Fetch missing objects
	Fetch bool
	// One by one checkout files
	One bool

	Quiet bool
}

type RestoreOptions struct {
	Source   string
	Staged   bool
	Worktree bool
	Paths    []string
}

type RevertOptions struct {
	From     string // From commit
	FF       bool
	Abort    bool
	Skip     bool
	Continue bool
}

type SafeTensorsFile struct {
	HeaderSize int64         // Size of the 8-byte length prefix + JSON header.
	Entries    []TensorEntry // Tensor entries sorted by absolute file offset.
}

type ShowOptions struct {
	Nav       bool
	Objects   []string
	Textconv  bool
	Algorithm diferenco.Algorithm
	Limit     int64
}

type ShowRemoteOptions struct {
	JSON bool
}

type Span struct {
	Offset int64
	Size   int64
}

type StageItem struct {
	Name  string            `json:"name"`
	Mode  filemode.FileMode `json:"mode"`
	Hash  plumbing.Hash     `json:"hash"`
	Stage index.Stage       `json:"stage"`
}

type StashEntry struct {
	Index     int              `json:"index"`
	Hash      plumbing.Hash    `json:"hash"`
	Committer object.Signature `json:"committer"`
	Message   string           `json:"message"`
}

type StashListOptions struct {
	JSON bool
}

type StashPushOptions struct {
	U bool
}

type Status map[string]*FileStatus

type StatusCode byte

type StatusJSON struct {
	Staging   []FileStatusJSON `json:"staged,omitempty"`
	Unstaging []FileStatusJSON `json:"unstaged,omitempty"`
	Untracked []FileStatusJSON `json:"untracked,omitempty"`
}

type StringArray []string

type SwitchOptions struct {
	Force       bool // aka discardChanges
	Merge       bool
	ForceCreate bool
	Remote      bool
	Limit       int64
	// contains filtered or unexported fields
}

type TagEntry struct {
	Name string        `json:"name"`
	Hash plumbing.Hash `json:"hash"`
}

type TensorEntry struct {
	Name   string
	Dtype  string
	Shape  []int64
	Offset int64 // Absolute start offset in the file (header size + data start).
	Size   int64 // Tensor payload size in bytes.
}

type UnsetConfigOptions struct {
	System bool
	Global bool
	Keys   []string
	CWD    string
}

type UpdateConfigOptions struct {
	System        bool
	Global        bool
	Add           bool
	NameAndValues []string
	Type          string
	CWD           string
}

type Worktree struct {
	// External excludes not found in the repository .gitignore/.zetaignore
	Excludes []ignore.Pattern

	*Repository
	// contains filtered or unexported fields
}

type WrapPrinter struct {
	io.WriteCloser
}