core

type BUFConfig struct {
	Version  string   `yaml:"version"`
	Deps     []string `yaml:"deps"`
	Build    Build    `yaml:"build"`
	Lint     Lint     `yaml:"lint"`
	Breaking Breaking `yaml:"breaking"`
}

type Breaking struct {
	Use                    []string            `yaml:"use"`
	Except                 []string            `yaml:"except"`
	Ignore                 []string            `yaml:"ignore"`
	IgnoreOnly             map[string][]string `yaml:"ignore_only"`
	IgnoreUnstablePackages bool                `yaml:"ignore_unstable_packages"`
}

type BreakingCheckConfig struct {
	// branch name to compare with
	AgainstGitRef string
	// dirs should be ignored
	IgnoreDirs []string
}

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

type Build struct {
	Excludes []string `yaml:"excludes"`
}

type Collection struct {
	Imports  map[ImportPath]Import
	Services map[string]Service
	// key message path - for supporting nested messages:
	// message MainMessage {
	// 		message NestedMessage{};
	// };
	// will be: MainMessage.NestedMessage
	Messages map[string]Message
	OneOfs   map[string]OneOf
	Enums    map[string]Enum
}

type Config struct {
	Deps    []string
	Plugins []Plugin
	Inputs  Inputs
}

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

type CurrentProjectGitWalker interface {
	GetDirWalker(workingDir, gitRef, path string) (DirWalker, error)
}

type DirWalker interface {
	FS
	WalkDir(callback func(path string, err error) error) error
}

type Enum struct {
	EnumPath      string
	ProtoFilePath string
	PackageName   PackageName
	*unordered.Enum
}

type FS interface {
	Open(name string) (io.ReadCloser, error)
	Create(name string) (io.WriteCloser, error)
}

type FieldOptionHandler struct {
	// Option is the option type identifier.
	Option FieldOptionType
	// HasDefault indicates if this option has a default value when managed mode is enabled.
	HasDefault bool
	// Default returns the default value for this option (if HasDefault is true).
	Default func() any
	// AppliesToType checks if this option applies to the given field type.
	AppliesToType func(t descriptorpb.FieldDescriptorProto_Type) bool
	// Apply applies the option value to the field.
	Apply func(field *descriptorpb.FieldDescriptorProto, value any)
}

type FieldOptionType string

type FileOptionHandler struct {
	// Option is the option type identifier.
	Option FileOptionType
	// HasDefault indicates if this option has a default value when managed mode is enabled.
	// Only options listed in buf documentation as having defaults should have this set to true.
	HasDefault bool
	// Apply applies the option value to the file descriptor.
	// filePath is the path to the proto file (e.g., "internal/cms/as.proto").
	Apply func(fd *descriptorpb.FileDescriptorProto, value any, pkg, filePath string)
	// Default returns the default value for this option (if HasDefault is true).
	// This is called only when HasDefault is true and no override is specified.
	Default func(fd *descriptorpb.FileDescriptorProto, pkg string) any
	// AffectsOption specifies which base option this handler affects.
	// For example, go_package_prefix affects go_package.
	AffectsOption FileOptionType
}

type FileOptionType string

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

type GitRefNotFoundError struct {
	GitRef string
}

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

type Import struct {
	ProtoFilePath string
	PackageName   PackageName
	*parser.Import
}

type ImportPath string

type InputFilesDir struct {
	Path string
	Root string
}

type InputGitRepo struct {
	URL          string
	SubDirectory string
	Out          string
	Root         string
}

type Inputs struct {
	InputFilesDir []InputFilesDir
	InputGitRepos []InputGitRepo
}

type InstructionInfo struct {
	PkgName     PackageName
	Instruction string
}

type InstructionParser struct {
	SourcePkgName PackageName
}

type Issue struct {
	Position   meta.Position
	SourceName string
	Message    string
	RuleName   string
}

type IssueInfo struct {
	Issue
	Path string
}

type JSType string

type Lint struct {
	Use                                  []string            `yaml:"use"`
	Except                               []string            `yaml:"except"`
	Ignore                               []string            `yaml:"ignore"`
	IgnoreOnly                           map[string][]string `yaml:"ignore_only"`
	AllowCommentIgnores                  bool                `yaml:"allow_comment_ignores"`
	EnumZeroValueSuffix                  string              `yaml:"enum_zero_value_suffix"`
	RPCAllowSameRequestResponse          bool                `yaml:"rpc_allow_same_request_response"`
	RPCAllowGoogleProtobufEmptyRequests  bool                `yaml:"rpc_allow_google_protobuf_empty_requests"`
	RPCAllowGoogleProtobufEmptyResponses bool                `yaml:"rpc_allow_google_protobuf_empty_responses"`
	ServiceSuffix                        string              `yaml:"service_suffix"`
}

type LockFile interface {
	Read(moduleName string) (models.LockFileInfo, error)
	Write(
		moduleName string, revisionVersion string, installedPackageHash models.ModuleHash,
	) error
	IsEmpty() bool
	DepsIter() iter.Seq[models.LockFileInfo]
}

type ManagedDisableRule struct {
	// Module disables managed mode for all files in the specified module.
	Module string
	// Path disables managed mode for files matching the specified path (directory or file).
	Path string
	// FileOption disables a specific file option from being modified.
	FileOption FileOptionType
	// FieldOption disables a specific field option from being modified.
	FieldOption FieldOptionType
	// Field disables a specific field (fully qualified name: package.Message.field).
	Field string
}

type ManagedModeConfig struct {
	// Enabled activates managed mode.
	Enabled bool
	// Disable contains rules to disable managed mode for specific conditions.
	Disable []ManagedDisableRule
	// Override contains rules to override file and field options.
	Override []ManagedOverrideRule
}

type ManagedOverrideRule struct {
	// FileOption specifies which file option to override.
	FileOption FileOptionType
	// FieldOption specifies which field option to override.
	FieldOption FieldOptionType
	// Value is the value to set for the option.
	Value any
	// Module applies this override only to files in the specified module.
	Module string
	// Path applies this override only to files matching the specified path.
	Path string
	// Field applies this override only to the specified field (fully qualified name).
	Field string
}

type Message struct {
	MessagePath   string
	ProtoFilePath string
	PackageName   PackageName
	*unordered.Message
}

type Migrate struct {
	BUF *BUFConfig
}

type ModuleConfig interface {
	ReadFromRepo(ctx context.Context, repo repository.Repo, revision models.Revision) (models.ModuleConfig, error)
}

type OneOf struct {
	OneOfPath     string
	ProtoFilePath string
	PackageName   PackageName
	*parser.Oneof
}

type OpenImportFileError struct {
	FileName string
}

type OptimizeMode string

type PackageName string

type Plugin struct {
	Source      PluginSource
	Out         string
	Options     map[string]string
	WithImports bool
}

type PluginSource struct {
	Name    string
	Remote  string
	Path    string
	Command []string
}

type ProtoData map[PackageName]*Collection

type ProtoInfo struct {
	Path                 string
	Info                 *unordered.Proto
	ProtoFilesFromImport map[ImportPath]*unordered.Proto
}

type Query struct {
	Imports []string
	Plugins []Plugin
	Files   []string
}

type Repo interface {
	// GetFiles returns list of all files in repository
	GetFiles(ctx context.Context, revision models.Revision, dirs ...string) ([]string, error)

	// ReadFile returns file's content from repository
	ReadFile(ctx context.Context, revision models.Revision, fileName string) (string, error)

	// Archive passed storage to archive and return full path to archive
	Archive(
		ctx context.Context, revision models.Revision, cacheDownloadPaths models.CacheDownloadPaths,
	) error

	// ReadRevision reads commit's revision by passed version
	// or return the latest commit if version is empty
	ReadRevision(ctx context.Context, requestedVersion models.RequestedVersion) (models.Revision, error)

	// Fetch from remote repository specified version
	Fetch(ctx context.Context, revision models.Revision) error
}

type Rule interface {
	// Message returns the message of the rule.
	Message() string
	// Validate validates the proto rule.
	Validate(ProtoInfo) ([]Issue, error)
}

type Service struct {
	ProtoFilePath string
	PackageName   PackageName
	*unordered.Service
}

type Storage interface {
	CreateCacheRepositoryDir(name string) (string, error)
	CreateCacheDownloadDir(models.CacheDownloadPaths) error
	GetCacheDownloadPaths(module models.Module, revision models.Revision) models.CacheDownloadPaths
	Install(
		cacheDownloadPaths models.CacheDownloadPaths,
		module models.Module,
		revision models.Revision,
		moduleConfig models.ModuleConfig,
	) (models.ModuleHash, error)
	GetInstalledModuleHash(moduleName string, revisionVersion string) (models.ModuleHash, error)
	IsModuleInstalled(module models.Module) (bool, error)
	GetInstallDir(moduleName string, revisionVersion string) string
}