cmd

type AllLoadersFailed struct {
	LastErr error
}

type Args struct {
	Source string
	Step   string
	Debug  bool
}

type BatchRenamer struct {
	Out     Out           `json:"out" toml:"out" mapstructure:"out"`
	Formats Formats       `json:"formats" toml:"formats" mapstructure:"formats"`
	Pattern spath.Pattern `json:"pattern" toml:"pattern" mapstructure:"pattern"`
	// contains filtered or unexported fields
}

type BatchRunConfig struct {
	Template string `json:"template" toml:"template" mapstructure:"template"`
	Files    Files
}

type BinaryLoad struct{}

type BundleConfig struct {
	Infile  string `json:"infile" toml:"infile" mapstructure:"infile"`
	Outfile string `json:"outfile" toml:"outfile" mapstructure:"outfile"`
}

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

type CliConfig struct {
	Executor ExecutorConfig
	Log      LogConfig
	BatchRun BatchRunConfig
}

type Closers []io.Closer

type ColNames map[string]string

type Cols map[string][]string

type Columns struct {
	CellName []string
	FileID   []string
}

type CommandsConfig struct {
	SubCommands SubCommands
	// contains filtered or unexported fields
}

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

type Configured struct {
	Engine template.MutEngine
	Paths  template.Paths
}

type Context struct {
	Streams stream.Streams

	OsFs fs.FS

	Coder payload.MultiCoder
	Log   zerolog.Logger
	// contains filtered or unexported fields
}

type CsvConfig struct {
	FilePaths path.PatternMap `json:"filepaths" toml:"filepaths" mapstructure:"filepaths"`
	OutFile   string          `json:"outfile" toml:"outfile" mapstructure:"outfile"`
}

type Data struct {
	Date   time.Time
	Header string
}

type DefaultExcelOpener struct{}

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

type Dep struct {
	Url  string   `json:"url" toml:"url" mapstructure:"url"`
	Path []string `json:"path" toml:"path" mapstructure:"path"`
}

type DepMap map[string]Dep

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

type Directories struct {
	In  string `json:"in" toml:"in"`
	Out string `json:"out" toml:"out"`
}

type Downloader interface {
	Download(url string, w io.Writer) (err error)
}

type Excel struct {
	File     string   `json:"file" toml:"file"`
	Sheet    string   `json:"sheet" toml:"sheet"`
	Ignore   Ignore   `json:"ignore" toml:"ignore"`
	ColNames ColNames `json:"column_names" toml:"column_names"`
	// contains filtered or unexported fields
}

type ExcelOpener interface {
	OpenExcel(path string) (*excelize.File, error)
}

type ExcelReaderPayload struct {
	ExcelOpener
}

type ExecutionMode int

type ExecutorConfig struct {
	Formatter *FormatterConfig `json:"formatter" toml:"formatter" mapstructure:"formatter"`
	DryRun    bool             `json:"dry_run" toml:"dry_run" mapstructure:"dry_run"`
}

type ExecutorMode int

type Files file.GroupSetups

type Format string

type Formats map[string]string

type Formatter interface {
	OutName(wr io.Writer, tpl Templates, t time.Time) (err error)
	InName(wr io.Writer, tpl Templates, iiFile int) (err error)
	Date(wr io.Writer, tpl Templates, parts Parts) (err error)
	OutNameParts(wr io.Writer, tpl Templates, parts Parts) (err error)
}

type FormatterConfig struct {
	Template   *string       `json:"template" toml:"template" mapstructure:"template"`
	OutStreams []string      `json:"out_streams" toml:"out_streams" mapstructure:"out_streams"`
	Mode       FormatterMode `json:"mode" toml:"mode" mapstructure:"mode"`
}

type FormatterMode int

type FuzzSelector interface {
	FuzzSelect(in []string) (string, error)
}

type FzFConfig struct {
	BinName string   `json:"bin" toml:"bin" mapstructure:"bin"`
	Flags   []string `json:"flags" toml:"flags" mapstructure:"flags"`
}

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

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

type HeaderMismatch struct {
	Expected, Got string
}

type Ignore struct {
	LineStart string   `json:"line_start" toml:"line_start"`
	FileIDs   []string `json:"file_ids" toml:"file_ids"`
}

type Imports map[string]string

type InOutIndices map[int]int

type KeyContext struct {
	Realm    string
	Password string
	Config   PasswordConfig
	KeyType  gokey.KeyType
}

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

type LoadRawFn func(r io.Reader) (data RawData, err error)

type LogConfig struct {
	File  *string `json:"file" toml:"file"`
	Level string  `json:"level" toml:"level"`
}

type Logger zerolog.Logger

type MapOther map[string]any

type Mode int

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

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

type Out struct {
	File      string `json:"file" toml:"file"`
	Directory string `json:"directory" toml:"directory"`
}

type Params map[string]interface{}

type Parsers struct {
	TimeZone parser.TimeZone
	Time     parser.Time
}

type Part int

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

type PartsSeparator interface {
	SeparateParts(dateStr string) (p Parts, err error)
}

type PasswordConfig struct {
	Spec    gokey.PasswordSpec `json:"spec" toml:"spec" mapstructure:"spec"`
	KeyType string             `json:"key_type" toml:"key_type" mapstructure:"key_type"`
	Realms  []Realm            `json:"realms" toml:"realms" mapstructure:"realms"`
}

type Paths struct {
	Data    data.NamedFieldsRef
	Fields  data.InOutFields
	Indices InOutIndices
	IRows   []int
	Encoded bool
}

type RawData struct {
	Header [37]byte
	Pad    [88]byte
	Date   [59]byte
}

type RawLoadFn func(r io.Reader) (data RawData, err error)

type RawLoader interface {
	LoadRaw(r io.ReadSeeker) (data RawData, err error)
}

type RawParser interface {
	ParseRawData(raw RawData) (d Data, err error)
}

type ReadFn func(r io.Reader) (err error)

type Realm struct {
	Name string `json:"name" toml:"name" mapstructure:"name"`
	Seed string `json:"seed" toml:"seed" mapstructure:"seed"`
}

type Renames struct {
	InFiles  []string `json:"infiles"`
	Dates    []string `json:"dates"`
	OutFiles []string `json:"outfiles"`
}

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

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

type SeparateFn func(dateStr string) (p Parts, err error)

type Setup struct {
	TemplateConfig  TemplateConfig  `json:"templates" toml:"templates" mapstructure:"templates"`
	ThirdPartySetup ThirdPartySetup `json:"third_party" toml:"third_party" mapstructure:"third_party"`
	Bundle          BundleConfig    `json:"bundle" toml:"bundle" mapstructure:"bundle"`
	Logging         LogConfig       `json:"logging" toml:"logging" mapstructure:"logging"`
	Csv             CsvConfig       `json:"csv" toml:"csv" mapstructure:"csv"`
	BatchRenamer    BatchRenamer    `json:"batch_rename" toml:"batch_rename" mapstructure:"batch_rename"`
}

type SubCommand func(s *adaptors.Sandbox) (err error)

type SubCommandInit interface {
	SubCommands(zerolog.Logger) (sc SubCommands, err error)
}

type SubCommandInits map[string]SubCommandInit

type SubCommands map[string]SubCommand

type TemplateConfig struct {
	OutDir   *string         `json:"outdir" toml:"outdir" mapstructure:"outdir"`
	OutFiles template.Paths  `json:"outfiles" toml:"outfiles" mapstructure:"outfiles"`
	Env      template.Values `json:"config" toml:"config" mapstructure:"env"`
	Imports  Imports         `json:"imports" toml:"imports" mapstructure:"imports"`
	Sources  path.PatternMap `json:"sources" toml:"sources" mapstructure:"sources"`
}

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

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

type ThirdPartySetup struct {
	Deps DepMap    `json:"resources" toml:"resources" mapstructure:"deps"`
	Root *[]string `json:"root_dir" toml:"root_dir" mapstructure:"root"`
}

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

type TimeStampIO struct {
	Loader    geochem.RawLoader
	Separator PartsSeparator
	Log       zerolog.Logger
}

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

type TimeStampReader interface {
	ReadTimeStamp(r io.Reader) (t time.Time, err error)
}

type UseReader func(r io.Reader) (err error)

type UseWriter func(w io.Writer) (err error)