model

type Artifact interface {
	Type() ArtifactType
	Name() string
	Descriptor() v1.Descriptor
}

type ArtifactSpec interface {
	Type() ArtifactType
	Name() string
}

type ArtifactType int

type BuildBaseOptions struct {
	// UseCudaBaseImage controls CUDA base image usage: "auto", "true", or "false".
	UseCudaBaseImage string

	// UseCogBaseImage controls cog base image usage. nil means auto-detect.
	UseCogBaseImage *bool

	// ProgressOutput controls build output format: "auto", "plain", or "tty".
	ProgressOutput string

	// RequiresCog indicates whether the build requires cog to be installed.
	RequiresCog bool
}

type BuildOptions struct {
	// ImageName is the output image name (required).
	ImageName string

	// NoCache disables build cache.
	NoCache bool

	// SeparateWeights builds weights as a separate layer.
	SeparateWeights bool

	// Strip removes debug symbols from binaries.
	Strip bool

	// Precompile precompiles Python bytecode.
	Precompile bool

	// UseCudaBaseImage controls CUDA base image usage: "auto", "true", or "false".
	UseCudaBaseImage string

	// UseCogBaseImage controls cog base image usage. nil means auto-detect.
	UseCogBaseImage *bool

	// Secrets are build-time secrets to pass to the build.
	Secrets []string

	// ProgressOutput controls build output format: "auto", "plain", or "tty".
	ProgressOutput string

	// Annotations are extra labels to add to the image.
	Annotations map[string]string

	// SchemaFile is a custom OpenAPI schema file path.
	SchemaFile string

	// DockerfileFile is a custom Dockerfile path.
	DockerfileFile string

	// WeightsLockPath is the path to weights.lock file.
	// Default: weights.lock in project directory.
	WeightsLockPath string

	// TODO(md): OCIIndex is a temporary gate. When true, builds produce weight
	// artifacts and pushes create an OCI Image Index. Set via COG_OCI_INDEX=1.
	// Remove this field once index pushes are validated with all registries.
	OCIIndex bool
}

type BuildRef struct {
	Source  *Source
	Options BuildOptions
}

type Builder interface {
	Build(ctx context.Context, spec ArtifactSpec) (Artifact, error)
}

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

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

type Factory interface {
	// Build creates a Docker image from source and returns ImageArtifact metadata.
	Build(ctx context.Context, src *Source, opts BuildOptions) (*ImageArtifact, error)

	// BuildBase creates a base image for dev mode (without /src copied).
	// The source directory is expected to be mounted as a volume at runtime.
	BuildBase(ctx context.Context, src *Source, opts BuildBaseOptions) (*ImageArtifact, error)

	// Name returns the factory name for logging/debugging.
	Name() string
}

type ImageArtifact struct {

	// Image metadata
	Reference string            // Full image reference (e.g., "r8.im/user/model:latest")
	Digest    string            // Content-addressable digest (sha256:...)
	Labels    map[string]string // Docker/OCI image labels
	Platform  *Platform         // OS/architecture
	Source    ImageSource       // Where loaded from (local/remote/build)
	// contains filtered or unexported fields
}

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

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

type ImageSource string

type ImageSpec struct {
	ImageName string
	Secrets   []string
	NoCache   bool
	// contains filtered or unexported fields
}

type ImageSpecOption func(*ImageSpec)

type Index struct {
	// Digest is the index digest (sha256:...).
	Digest string
	// Reference is the full image reference.
	Reference string
	// MediaType is typically application/vnd.oci.image.index.v1+json.
	MediaType string
	// Manifests are the child manifests in this index.
	Manifests []IndexManifest
}

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

type IndexManifest struct {
	// Digest is the manifest digest.
	Digest string
	// MediaType is the manifest media type.
	MediaType string
	// Size is the manifest size in bytes.
	Size int64
	// Platform is the target platform (nil for artifacts).
	Platform *Platform
	// Annotations are OCI annotations on this manifest.
	Annotations map[string]string
	// Type is derived from platform/annotations (image or weights).
	Type ManifestType
}

type LocalRef struct {
	Parsed *ParsedRef
}

type ManifestType string

type Model struct {
	Image      *ImageArtifact // Underlying OCI image
	Config     *config.Config // Parsed cog.yaml
	Schema     *openapi3.T    // OpenAPI schema
	CogVersion string         // Version of cog used to build

	// Index is the OCI Image Index (populated when inspecting a pushed model).
	Index *Index

	// TODO(md): OCIIndex is a temporary gate. When true, Push() creates an OCI
	// Image Index with weight artifacts. When false, Push() does a plain docker push.
	// Remove this field once index pushes are validated with all registries.
	OCIIndex bool

	// Artifacts is the collection of all artifacts produced by building this model.
	// Populated by Resolver.Build(). Contains ImageArtifact and WeightArtifact instances.
	Artifacts []Artifact
}

type Option func(*options)

type ParseOption func(*parseOptions)

type ParsedRef struct {
	// Original is the input string before parsing.
	Original string

	// Ref is the underlying parsed reference from go-containerregistry.
	Ref name.Reference
}

type Platform struct {
	OS           string
	Architecture string
	Variant      string
}

type PushOptions struct {
	// ProjectDir is the base directory for resolving weight file paths.
	//
	// Deprecated: Artifacts carry their own file paths.
	ProjectDir string

	// FilePaths maps weight name identifiers to their file paths.
	//
	// Deprecated: Use Model.Artifacts instead — WeightArtifact carries FilePath.
	FilePaths map[string]string

	// Platform specifies the target platform for bundle indexes.
	// Default: linux/amd64
	Platform *Platform
}

type Pusher interface {
	Push(ctx context.Context, m *Model, opts PushOptions) error
}

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

type RemoteRef struct {
	Parsed *ParsedRef
}

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

type Source struct {
	Config         *config.Config
	ProjectDir     string
	ConfigFilename string // Base filename like "cog.yaml" or "my-config.yaml"
	Warnings       []config.DeprecationWarning
}

type TagRef struct {
	Parsed *ParsedRef
}

type WeightArtifact struct {

	// FilePath is the local file path to the weight data (for pushing layers).
	FilePath string
	// Target is the container mount path for this weight.
	Target string
	// Config is the weight metadata for the config blob.
	Config WeightConfig
	// contains filtered or unexported fields
}

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

type WeightConfig struct {
	SchemaVersion string    `json:"schemaVersion"`
	CogVersion    string    `json:"cogVersion"`
	Name          string    `json:"name"`
	Target        string    `json:"target"`
	Created       time.Time `json:"created"` // RFC 3339 format when serialized to JSON
}

type WeightFile struct {
	// Name is the identifier/handle for this weight (e.g., "personaplex-7b-v1", "model-v42.5").
	// This is a logical name that maps to deployment blob metadata, not a file path.
	Name string `json:"name"`
	// Dest is the mount path in the container (e.g., /cache/model.safetensors).
	Dest string `json:"dest"`
	// DigestOriginal is the SHA256 of the uncompressed file (canonical ID).
	DigestOriginal string `json:"digestOriginal"`
	// Digest is the SHA256 of the compressed blob (OCI layer ID).
	Digest string `json:"digest"`
	// Size is the compressed size in bytes.
	Size int64 `json:"size"`
	// SizeUncompressed is the original size in bytes.
	SizeUncompressed int64 `json:"sizeUncompressed"`
	// MediaType is the OCI layer media type (e.g., application/vnd.cog.weight.layer.v1+gzip).
	MediaType string `json:"mediaType"`
	// ContentType is the file's MIME type (e.g., application/octet-stream).
	ContentType string `json:"contentType,omitempty"`
}

type WeightPushOptions struct {
	// ProgressFn is an optional callback for reporting upload progress.
	ProgressFn func(WeightPushProgress)
	// RetryFn is an optional callback for reporting retry attempts.
	// Return false to abort the retry.
	RetryFn func(WeightRetryEvent) bool
}

type WeightPushProgress struct {
	// Complete is the number of bytes uploaded so far.
	Complete int64
	// Total is the total number of bytes to upload.
	Total int64
}

type WeightPushResult struct {
	// Ref is the full image reference for the pushed weight manifest (e.g., "registry/repo:weights-name-abc123").
	Ref string
	// Descriptor is the OCI descriptor for the pushed weight manifest.
	Descriptor v1.Descriptor
}

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

type WeightRetryEvent struct {
	// Name identifies which file is being retried.
	Name string
	// Attempt is the current retry attempt number (1-indexed).
	Attempt int
	// MaxAttempts is the maximum number of retry attempts.
	MaxAttempts int
	// Err is the error that caused the retry.
	Err error
	// NextRetryIn is the duration until the next retry attempt.
	NextRetryIn time.Duration
}

type WeightSpec struct {

	// Source is the local file path to the weight file.
	Source string
	// Target is the container mount path for this weight.
	Target string
	// contains filtered or unexported fields
}

type WeightsLock struct {
	// Version is the lockfile format version.
	Version string `json:"version"`
	// Created is when the lockfile was generated.
	Created time.Time `json:"created"`
	// Files are the weight file entries.
	Files []WeightFile `json:"files"`
}