model

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

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

type ArtifactType int

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

	// ExcludeSource skips the COPY . /src step in the generated Dockerfile.
	// Used by `cog serve` to produce an image identical to `cog build` minus
	// the source copy — the source directory is volume-mounted at runtime.
	// All other layers (wheel installs, apt, etc.) are shared with `cog build`
	// via Docker layer caching.
	ExcludeSource bool

	// SkipSchemaValidation skips OpenAPI schema generation and validation.
	// Used by `cog run` which executes arbitrary commands and may not have
	// a predictor or trainer defined in cog.yaml.
	SkipSchemaValidation bool

	// SkipLabels skips adding Cog metadata labels to the built image.
	// Used by `cog run`, `cog predict`, `cog serve`, and `cog train` where
	// the image is for local use only and not being distributed.
	SkipLabels 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.
	// For dev mode (cog serve), set ExcludeSource=true in BuildOptions to skip
	// COPY . /src — the source directory is volume-mounted at runtime instead.
	Build(ctx context.Context, src *Source, opts BuildOptions) (*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 ImagePushOption func(*imagePushOptions)

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

	// ImageProgressFn is an optional callback for reporting per-layer upload progress
	// during OCI chunked image push. Each call includes the layer digest, bytes
	// completed, and total bytes.
	ImageProgressFn func(PushProgress)

	// OnFallback is called when OCI push fails and the push is about to fall
	// back to Docker push. This allows the caller to clean up any OCI-specific
	// progress display before Docker push starts its own output.
	OnFallback func()
}

type PushProgress struct {
	// LayerDigest identifies which layer this progress is for.
	// Empty for single-layer pushes (e.g., weight uploads).
	LayerDigest string
	// Complete is the number of bytes uploaded so far.
	Complete int64
	// Total is the total number of bytes to upload.
	Total int64
}

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(PushProgress)
	// RetryFn is an optional callback for reporting retry attempts.
	// Return false to abort the retry.
	RetryFn func(WeightRetryEvent) bool
}

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"`
}