httpapi

type AcceleratorDriver struct {
	Capability string `json:"capability,omitempty"`
	Vendor     string `json:"vendor,omitempty"`
	Version    string `json:"version,omitempty"`
}

type AcceleratorInventory struct {
	CanonicalModel string `json:"canonical_model,omitempty"`
	Count          int    `json:"count"`
	MemoryBytes    int64  `json:"memory_bytes"`
	Model          string `json:"model"`
	Vendor         string `json:"vendor"`
}

type AcceleratorRequirement struct {
	Count          int      `json:"count"`
	MemoryMinBytes int64    `json:"memory_min_bytes"`
	ModelAnyOf     []string `json:"model_any_of,omitempty"`
	Vendor         string   `json:"vendor"`
}

type AdapterListResponse struct {
	Adapters []AdapterManifest `json:"adapters"`
}

type AdapterManifest = adapter.Manifest

type Admission = domain.AdmissionDeferral

type ArtifactEvidence struct {
	ArtifactId string `json:"artifact_id"`

	// FetchBytes What this host still has to read out of the object store for this version.
	FetchBytes int64 `json:"fetch_bytes,omitempty"`

	// Locality Hot is a checked copy of exactly this version on this host. Cold is no such copy, which includes a copy nobody verified. Unknown is a host that could not enumerate its copies at all, which is uncertainty to price and never infeasibility.
	Locality ArtifactEvidenceLocality `json:"locality"`
}

type ArtifactEvidenceLocality string

type ArtifactInventory struct {
	// Known Whether the holder enumerated its Artifact replicas at all.
	Known      bool              `json:"known"`
	ObservedAt time.Time         `json:"observed_at,omitempty"`
	Replicas   []ArtifactReplica `json:"replicas,omitempty"`
}

type ArtifactReplica struct {
	ArtifactId string `json:"artifact_id"`

	// ContentDigest What this copy claims its bytes hash to.
	ContentDigest string `json:"content_digest"`
	SizeBytes     int64  `json:"size_bytes"`

	// State Verified means these bytes were hashed and matched the catalog entry. Unverified means a copy is present and nobody checked it, which is not evidence that the right bytes are here.
	State ArtifactReplicaState `json:"state"`

	// VerifiedAt When this copy was last checked against the catalog entry's content digest.
	VerifiedAt time.Time `json:"verified_at,omitempty"`
}

type ArtifactReplicaState string

type ArtifactRequirements struct {
	// Consumes Artifact version identities this workload reads. The Run is accepted at once and is not placed until every one of them is durable in the object store, so it waits for a publication and never for a particular machine. A Mercator with no object store configured cannot establish that any of them exists, and refuses the request with ARTIFACT_CATALOG_UNAVAILABLE rather than accepting a Run it could never place.
	Consumes []string `json:"consumes,omitempty"`

	// Produces Artifact version identities this workload publishes. A version is immutable, so a workload may not also consume one it produces.
	Produces []string `json:"produces,omitempty"`
}

type AuthorizeConnection200JSONResponse ConnectionResponse

type AuthorizeConnection400JSONResponse ErrorResponse

type AuthorizeConnection401JSONResponse ErrorResponse

type AuthorizeConnection403JSONResponse ErrorResponse

type AuthorizeConnection500JSONResponse ErrorResponse

type AuthorizeConnection501JSONResponse ErrorResponse

type AuthorizeConnection502JSONResponse ErrorResponse

type AuthorizeConnectionRequestObject struct {
	ConnectionId string `json:"connection_id"`
}

type AuthorizeConnectionResponseObject interface {
	VisitAuthorizeConnectionResponse(w http.ResponseWriter) error
}

type Booking = domain.Booking

type BookingDecision = domain.BookingDecision

type BookingDecisionResponse struct {
	// Decision Temporary v0.6 rollout bridge: the latest entry in decisions for workspace-client-v1 callers.
	// Deprecated: this property has been marked as deprecated upstream, but no `x-deprecated-reason` was set
	Decision  BookingDecision   `json:"decision,omitempty"`
	Decisions []BookingDecision `json:"decisions"`
}

type CPURequirement struct {
	MinMillis int64 `json:"min_millis"`
}

type CacheEvidence struct {
	// HeldCompatibilityKey The generation this host actually holds under the name, when it holds one. It separates the two ways a cache is cold: a machine that has never done this work, and one holding the generation before the one now asked for.
	HeldCompatibilityKey string `json:"held_compatibility_key,omitempty"`

	// Locality Hot is this deployment's cache of this name holding the generation the Run asked for. Cold is anything else, including a neighbour's cache of the same name and the generation the application has since replaced. Unknown is a host that could not enumerate its caches at all.
	Locality CacheEvidenceLocality `json:"locality"`
	Name     string                `json:"name"`
}

type CacheEvidenceLocality string

type CacheInventory struct {
	// Known Whether the holder enumerated its caches at all.
	Known      bool         `json:"known"`
	Mounts     []CacheMount `json:"mounts,omitempty"`
	ObservedAt time.Time    `json:"observed_at,omitempty"`
}

type CacheMount struct {
	// CompatibilityKey The generation of content under this name, as the application stated it when the cache was written.
	CompatibilityKey string `json:"compatibility_key,omitempty"`

	// CreatedAt When this generation of the cache started existing here. It is the freshness a container runtime can state: a holder that makes new storage per compatibility key can say when this one began, and cannot say when anything last read it.
	CreatedAt time.Time `json:"created_at,omitempty"`
	Name      string    `json:"name"`
}

type CacheMountRequirement struct {
	// CompatibilityKey The application's own statement of which generation of content it can use. Mercator compares it and never interprets it: content declared under another generation is worth what no content is worth, and gets storage of its own. It is recorded beside the storage it names on whatever host holds the cache, so it must be a printable label.
	CompatibilityKey string `json:"compatibility_key,omitempty"`

	// Name This cache's identity within its deployment. It also names durable storage on whatever host holds the cache, so it must be a lowercase label.
	Name string `json:"name"`

	// SizeBytes How much room the application expects this cache to take. It is a declaration rather than a measurement.
	SizeBytes int64 `json:"size_bytes,omitempty"`
}

type CancelRun200JSONResponse RunResponse

type CancelRun400JSONResponse ErrorResponse

type CancelRun401JSONResponse ErrorResponse

type CancelRun403JSONResponse ErrorResponse

type CancelRun502JSONResponse ErrorResponse

type CancelRunRequestObject struct {
	RunId string `json:"run_id"`
}

type CancelRunResponseObject interface {
	VisitCancelRunResponse(w http.ResponseWriter) error
}

type CandidateDecision struct {
	AdapterType string `json:"adapter_type,omitempty"`

	// ArtifactEvidence What this candidate was found holding of the immutable content the Run reads, one entry per declared input. It stands beside image_locality rather than folded into it: an image is what the runtime fetches to start a container, an Artifact is what the workload reads once it is running, and one host is routinely warm for one and cold for the other.
	ArtifactEvidence []ArtifactEvidence `json:"artifact_evidence,omitempty"`

	// CacheEvidence What this candidate was found holding of the mutable caches the Run declared, one entry per name. It is recorded rather than scored, and it distinguishes a machine that has never done this work from one holding the named cache.
	CacheEvidence []CacheEvidence `json:"cache_evidence,omitempty"`

	// Candidate What Mercator took a candidate to be, as opposed to what the listing was called. A prediction claiming evidence about this exact candidate has to say which candidate it meant, and every field here is a fact a backend published rather than an identifier Mercator minted. A candidate that publishes nothing outliving its listing states only a provider and a lane, which is how the record says no history about it can ever be read again.
	Candidate CandidateIdentity `json:"candidate,omitempty"`

	// Confidences What each answer this candidate was scored on is worth, one entry per source that stated one. It is the whole input to the score's uncertainty term, recorded so score_usd can be re-derived from this record: a scoring term whose input is not here is a term no reader can check. An answer nobody stated a confidence for is absent rather than zero, because stating no opinion is not the same as stating that an answer is worthless.
	Confidences  []Confidence `json:"confidences,omitempty"`
	ConnectionId string       `json:"connection_id,omitempty"`

	// Disk What one Run asked of one candidate's disk: the room the machine said it had left, the room the Run reserved for its own working state, and the content that still had to land there. It is one question over every kind of content at once because the disk is one resource, and a candidate short of room is refused rather than priced: nothing this Run could give up frees a byte it does not need straight back, and the only content that would make room belongs to somebody else.
	Disk        DiskDemand                   `json:"disk,omitempty"`
	Disposition CandidateDecisionDisposition `json:"disposition"`
	Estimates   CandidateEstimates           `json:"estimates"`
	Feasible    bool                         `json:"feasible"`

	// ImageLocality How much of the Run's image this candidate was found to have. It is the qualitative half of the pull estimate, and only the control plane can state it: the host says what it holds, the manifest says what the image is, and the answer is the subtraction. Unknown means nobody could look, which is uncertainty to price and never infeasibility.
	ImageLocality   CandidateDecisionImageLocality `json:"image_locality,omitempty"`
	NativeRef       string                         `json:"native_ref,omitempty"`
	OfferSnapshotId string                         `json:"offer_snapshot_id"`
	Rejections      []Violation                    `json:"rejections,omitempty"`

	// Reliability The risk history a machine's publisher states about it. Each rate stands on its own measurement, because a publisher measures what it measures, and an unmeasured rate is absent rather than zero. The whole history is absent when a publisher has measured nothing, which is every provider in this tree today, so a reader must treat no history and a history of zeroes as different answers.
	Reliability ReliabilityEvidence `json:"reliability,omitempty"`

	// RentalSchedule One Rental Schedule as a placement decision read it: the version that answered, the Booking holding the Rental, the Bookings already waiting in front of this Run, and the wait that projects from them. A schedule moves, so the wait a Run was priced was read from one version of it at one moment, and a decision that recorded only the seconds leaves nobody able to retrace them.
	RentalSchedule ScheduleEvidence `json:"rental_schedule,omitempty"`

	// ScoreUsd What this candidate is worth to this Run in dollars, lowest first: the cost it would be billed, plus the dollars its service class says it would rather pay than wait, plus the dollars it would rather pay than act on a doubtful answer. Every quantity it multiplies is recorded beside it, at the weights the decision states, so it can be re-derived rather than trusted. An infeasible candidate scores nothing, because it has no price.
	ScoreUsd float64 `json:"score_usd,omitempty"`

	// TransferRates The throughput each transfer stage of this launch was priced at and where that number came from, one entry per stage that had bytes to move. A stage with nothing to move records none, because there was no transfer to price, and nothing else suppresses one: every transfer this fleet prices is bytes over a rate, so a transfer is not a stage the estimator answers out of measured launches. The seconds a candidate is charged are bytes over a rate, the bytes are explained by the locality evidence, and this is the other half: a machine priced at a throughput nothing on it ever reported and a machine priced at Mercator's own assumption produce the same seconds and are different claims.
	TransferRates []TransferRate `json:"transfer_rates,omitempty"`
}

type CandidateDecisionDisposition string

type CandidateDecisionImageLocality string

type CandidateEstimates struct {
	// CommittedInterval One machine's already-owed rent as one placement met it: when the interval ends, when this Run would start spending it, and how many of its seconds this Run would take. Capacity nothing is owed on carries none of it.
	CommittedInterval CommittedInterval `json:"committed_interval,omitempty"`

	// CostTerms What those dollars are made of, one entry per part of the price this candidate was charged for. A machine nobody quoted carries none. The total alone cannot be argued with: a machine charged the shadow price of one Run's seconds and a machine charged the whole hour it is committed to are the same claim to a reader who sees only dollars, and the difference is which term they are in.
	CostTerms               []CostTerm `json:"cost_terms,omitempty"`
	CostUsd                 Estimate   `json:"cost_usd"`
	EstablishedStartSeconds Estimate   `json:"established_start_seconds"`
	QueueSeconds            Estimate   `json:"queue_seconds"`

	// Stages What this candidate is predicted to spend on each stage of a launch. There are eight of them, and they are eight rather than four because each is answered by a different authority, fails for a different reason, and has an actual of its own.
	Stages       LaunchStageEstimates `json:"stages"`
	StartSeconds Estimate             `json:"start_seconds"`
}

type CandidateIdentity struct {
	// Accelerator How many cards of each accelerator product this capacity holds, canonicalized and counted per product so an inventory grouped two ways is one answer.
	Accelerator string `json:"accelerator,omitempty"`

	// ImageDigest The content this candidate was asked to run. Stages whose duration is a property of the content are filed with it; stages that are a property of the machine are not.
	ImageDigest string `json:"image_digest,omitempty"`

	// InstanceType The product name the provider sells this capacity under. Absent for a provider that sells asks against individual machines instead of named products.
	InstanceType string `json:"instance_type,omitempty"`

	// Lane What this capacity is for: a machine Mercator controls through an enrolled runtime and can hand successive workloads to, or a provider-native one-shot execution that holds nothing once its workload exits. It is part of the identity because the two have different stages to predict and different disks afterwards, so one key over both would report each lane's history as the other's.
	Lane CandidateIdentityLane `json:"lane,omitempty"`

	// Machine The machine this capacity is, where its backend can name one. It is never the lease and never the route Mercator took to reach the machine.
	Machine string `json:"machine,omitempty"`

	// Provider The backend the capacity comes from, which is the coarsest thing worth learning about and the only field every candidate has.
	Provider string `json:"provider,omitempty"`

	// Region Where the machine is, in the provider's own vocabulary. Absent for a provider that publishes no geography at all.
	Region string `json:"region,omitempty"`
}

type CandidateIdentityLane string

type CapabilityProfile struct {
	Container     ContainerCapabilities         `json:"container"`
	Lifecycle     LifecycleCapabilities         `json:"lifecycle"`
	Network       NetworkCapabilities           `json:"network"`
	Observability ObservabilityCapabilities     `json:"observability"`
	OfferKinds    []CapabilityProfileOfferKinds `json:"offer_kinds,omitempty"`
	Pricing       PricingCapabilities           `json:"pricing"`
	Resources     ResourceCapabilities          `json:"resources"`
}

type CapabilityProfileOfferKinds string

type CapacityEvidence struct {
	Available  bool    `json:"available"`
	Confidence float64 `json:"confidence"`
}

type CapacityTerms = domain.CapacityTerms

type CleanupError struct {
	Code        string                  `json:"code"`
	Disposition CleanupErrorDisposition `json:"disposition"`
	LaunchKey   string                  `json:"launch_key"`
	Message     string                  `json:"message"`
	Retryable   bool                    `json:"retryable"`
}

type CleanupErrorDisposition string

type CloudEvent = eventlog.CloudEvent

type CollectionReport struct {
	ConnectionsFromCache []string `json:"connections_from_cache,omitempty"`
	ConnectionsQueried   []string `json:"connections_queried,omitempty"`
	ExcludedConnections  []string `json:"excluded_connections,omitempty"`
}

type CommittedInterval = domain.CommittedInterval

type Confidence struct {
	// Answer What was being answered, in the vocabulary of whatever answered: the capacity claim, the reliability history, the image transfer, the Artifact read.
	Answer string  `json:"answer"`
	Value  float64 `json:"value"`
}

type ConnectionFailure struct {
	AdapterType  string `json:"adapter_type"`
	ConnectionId string `json:"connection_id"`
	Message      string `json:"message"`
}

type ConnectionListResponse struct {
	Connections []ConnectionRecord `json:"connections"`
}

type ConnectionRecord = connection.Record

type ConnectionResponse struct {
	Connection ConnectionRecord `json:"connection"`
}

type ConsoleEventLog interface {
	ReadAll(context.Context, eventlog.GlobalPosition, int, eventlog.EventFilter) ([]eventlog.StoredEvent, error)
	LatestPosition(context.Context, eventlog.EventFilter) (eventlog.GlobalPosition, error)
	Subscribe(context.Context, eventlog.SubscriptionRequest) (<-chan eventlog.Delivery, error)
}

type ContainerCapabilities struct {
	MaxContainers              int  `json:"max_containers"`
	MaxEnvironmentBytes        int  `json:"max_environment_bytes"`
	SupportsDigestRefs         bool `json:"supports_digest_refs"`
	SupportsEntrypointOverride bool `json:"supports_entrypoint_override"`
}

type ContainerSpec struct {
	Args       []string              `json:"args,omitempty"`
	Entrypoint []string              `json:"entrypoint,omitempty"`
	Env        map[string]EnvBinding `json:"env,omitempty"`
	Image      string                `json:"image"`
	Name       string                `json:"name"`
	Platform   Platform              `json:"platform"`
	Ports      []PortSpec            `json:"ports,omitempty"`
}

type CostTerm = domain.CostTerm

type CreateConnection201JSONResponse ConnectionResponse

type CreateConnection400JSONResponse ErrorResponse

type CreateConnection401JSONResponse ErrorResponse

type CreateConnection403JSONResponse ErrorResponse

type CreateConnection409JSONResponse ErrorResponse

type CreateConnection413JSONResponse ErrorResponse

type CreateConnection500JSONResponse ErrorResponse

type CreateConnection501JSONResponse ErrorResponse

type CreateConnectionJSONRequestBody = CreateConnectionRequest

type CreateConnectionParams struct {
	IdempotencyKey string `json:"Idempotency-Key"`
}

type CreateConnectionRequest struct {
	AdapterType  string            `json:"adapter_type"`
	Config       map[string]string `json:"config,omitempty"`
	ConnectionId string            `json:"connection_id"`
	Credential   Credential        `json:"credential,omitempty"`

	// Secret Write-only: accepted on create, sealed at rest, never echoed in any response.
	Secret string `json:"secret,omitempty"`
}

type CreateConnectionRequestObject struct {
	Params CreateConnectionParams
	Body   *CreateConnectionJSONRequestBody
}

type CreateConnectionResponseObject interface {
	VisitCreateConnectionResponse(w http.ResponseWriter) error
}

type CreateRevisionRequest struct {
	Revision WorkloadRevision `json:"revision"`
}

type CreateRun202JSONResponse RunResponse

type CreateRun400JSONResponse ErrorResponse

type CreateRun401JSONResponse ErrorResponse

type CreateRun403JSONResponse ErrorResponse

type CreateRun404JSONResponse ErrorResponse

type CreateRun409JSONResponse ErrorResponse

type CreateRun413JSONResponse ErrorResponse

type CreateRun500JSONResponse ErrorResponse

type CreateRunJSONRequestBody = CreateRunRequest

type CreateRunParams struct {
	IdempotencyKey string `json:"Idempotency-Key"`
}

type CreateRunRequest struct {
	// Args Container args for the image shorthand.
	Args []string `json:"args,omitempty"`

	// Env Run-level literal env bindings. For stored or explicit workload specs, these override or add to the workload container env for this run only. For image shorthand, these become the synthesized container env.
	Env map[string]EnvBinding `json:"env,omitempty"`

	// Image Top-level image shorthand. Synthesizes the single container when no full workload spec is supplied. Ignored when an explicit workload spec is present.
	Image string `json:"image,omitempty"`

	// RunId Optional. When omitted the server generates a uuidv7-based run id and returns it.
	RunId              string           `json:"run_id,omitempty"`
	Workload           WorkloadRevision `json:"workload,omitempty"`
	WorkloadId         string           `json:"workload_id,omitempty"`
	WorkloadRevisionId string           `json:"workload_revision_id,omitempty"`
}

type CreateRunRequestObject struct {
	Params CreateRunParams
	Body   *CreateRunJSONRequestBody
}

type CreateRunResponseObject interface {
	VisitCreateRunResponse(w http.ResponseWriter) error
}

type CreateWorkload202JSONResponse struct {
	WorkloadId string `json:"workload_id"`
}

type CreateWorkload400JSONResponse ErrorResponse

type CreateWorkload401JSONResponse ErrorResponse

type CreateWorkload403JSONResponse ErrorResponse

type CreateWorkload413JSONResponse ErrorResponse

type CreateWorkload501JSONResponse ErrorResponse

type CreateWorkloadJSONRequestBody = CreateWorkloadRequest

type CreateWorkloadParams struct {
	IdempotencyKey string `json:"Idempotency-Key"`
}

type CreateWorkloadRequest struct {
	Name       string `json:"name"`
	WorkloadId string `json:"workload_id"`
}

type CreateWorkloadRequestObject struct {
	Params CreateWorkloadParams
	Body   *CreateWorkloadJSONRequestBody
}

type CreateWorkloadResponseObject interface {
	VisitCreateWorkloadResponse(w http.ResponseWriter) error
}

type CreateWorkloadRevision202JSONResponse WorkloadRevisionResponse

type CreateWorkloadRevision400JSONResponse ErrorResponse

type CreateWorkloadRevision401JSONResponse ErrorResponse

type CreateWorkloadRevision403JSONResponse ErrorResponse

type CreateWorkloadRevision413JSONResponse ErrorResponse

type CreateWorkloadRevision501JSONResponse ErrorResponse

type CreateWorkloadRevisionJSONRequestBody = CreateRevisionRequest

type CreateWorkloadRevisionParams struct {
	IdempotencyKey string `json:"Idempotency-Key"`
}

type CreateWorkloadRevisionRequestObject struct {
	WorkloadId string `json:"workload_id"`
	Params     CreateWorkloadRevisionParams
	Body       *CreateWorkloadRevisionJSONRequestBody
}

type CreateWorkloadRevisionResponseObject interface {
	VisitCreateWorkloadRevisionResponse(w http.ResponseWriter) error
}

type Credential = credential.Credential

type DeleteConnection200JSONResponse struct {
	Deleted bool `json:"deleted"`
}

type DeleteConnection400JSONResponse ErrorResponse

type DeleteConnection401JSONResponse ErrorResponse

type DeleteConnection403JSONResponse ErrorResponse

type DeleteConnection404JSONResponse ErrorResponse

type DeleteConnection500JSONResponse ErrorResponse

type DeleteConnection501JSONResponse ErrorResponse

type DeleteConnectionRequestObject struct {
	ConnectionId string `json:"connection_id"`
}

type DeleteConnectionResponseObject interface {
	VisitDeleteConnectionResponse(w http.ResponseWriter) error
}

type DeliverSink202JSONResponse SinkResult

type DeliverSink401JSONResponse ErrorResponse

type DeliverSink501JSONResponse ErrorResponse

type DeliverSink502JSONResponse ErrorResponse

type DeliverSinkRequestObject struct {
	SinkId string `json:"sink_id"`
}

type DeliverSinkResponseObject interface {
	VisitDeliverSinkResponse(w http.ResponseWriter) error
}

type Deps struct {
	Orchestrator *orchestrator.Orchestrator
	Offers       OfferAggregator
	Workloads    *workload.Service
	Sinks        *sinkspkg.Manager
	Connections  *connection.Service
	Resolver     ImageResolver
	Events       ConsoleEventLog
}

type DiskDemand struct {
	// EstablishedLandBytes The part of that somebody enumerated. Content nobody could describe is priced in seconds and never refuses a machine, because those bytes may already be on its disk.
	EstablishedLandBytes int64 `json:"established_land_bytes,omitempty"`

	// FreeBytes The room the offer said this machine had left. A machine that could not measure its disk offers none.
	FreeBytes int64 `json:"free_bytes"`

	// LandBytes Everything this Run's content still had to put on this disk: the image bytes it must transfer, the Artifact versions it must read out of the object store, and the caches it declared that this host does not hold.
	LandBytes int64 `json:"land_bytes,omitempty"`

	// ReservedBytes The ephemeral disk the workload declared it needs. It is asked for beside the content rather than out of it, because a Run admitted on a fifty gigabyte floor whose fifty gigabytes turn out to be its own dataset was promised nothing.
	ReservedBytes int64 `json:"reserved_bytes,omitempty"`
}

type DiskRequirement struct {
	MinBytes int64 `json:"min_bytes"`
}

type EnvBinding = domain.EnvBinding

type ErrorResponse struct {
	Code    string      `json:"code"`
	Details []Violation `json:"details,omitempty"`
	Message string      `json:"message"`
}

type Estimate struct {
	Confidence float64 `json:"confidence,omitempty"`
	Expected   float64 `json:"expected,omitempty"`

	// Key The key the samples were read under, where any were. It is recorded so a reader can check what Mercator took the candidate to be against what it then learned about: an answer claiming this exact candidate, filed under a number a marketplace mints per search, is a claim of candidate-specific evidence made out of a key that cannot have any.
	Key string `json:"key,omitempty"`

	// Level Which evidence answered this estimate: measured launches of this exact candidate, of this provider in this region, of this provider, or none at all. A prior is named rather than left blank so a reader can tell a measurement from a published claim, which the seconds alone cannot say.
	Level        EstimateLevel `json:"level,omitempty"`
	ModelVersion string        `json:"model_version,omitempty"`
	P50          float64       `json:"p50,omitempty"`
	P90          float64       `json:"p90,omitempty"`

	// SampleCount How many measured launches stand behind this answer. Zero is the answer a prior gives, and it is a different claim from the same seconds read off one launch.
	SampleCount int    `json:"sample_count,omitempty"`
	Source      string `json:"source,omitempty"`
}

type EstimateLevel string

type EventListResponse struct {
	Events []CloudEvent `json:"events"`
}

type ExecutionPolicy struct {
	MaxPreStartAttempts int   `json:"max_pre_start_attempts"`
	MaxRuntimeSeconds   int64 `json:"max_runtime_seconds"`
}

type FleetAnswer = domain.FleetAnswer

type GetOpenAPI200JSONResponse map[string]interface{}

type GetOpenAPIRequestObject struct {
}

type GetOpenAPIResponseObject interface {
	VisitGetOpenAPIResponse(w http.ResponseWriter) error
}

type GetRun200JSONResponse RunResponse

type GetRun400JSONResponse ErrorResponse

type GetRun401JSONResponse ErrorResponse

type GetRun403JSONResponse ErrorResponse

type GetRun404JSONResponse ErrorResponse

type GetRunDecision200JSONResponse BookingDecisionResponse

type GetRunDecision400JSONResponse ErrorResponse

type GetRunDecision401JSONResponse ErrorResponse

type GetRunDecision403JSONResponse ErrorResponse

type GetRunDecision404JSONResponse ErrorResponse

type GetRunDecisionRequestObject struct {
	RunId string `json:"run_id"`
}

type GetRunDecisionResponseObject interface {
	VisitGetRunDecisionResponse(w http.ResponseWriter) error
}

type GetRunRequestObject struct {
	RunId string `json:"run_id"`
}

type GetRunResponseObject interface {
	VisitGetRunResponse(w http.ResponseWriter) error
}

type GetSinkStatus200JSONResponse SinkStatus

type GetSinkStatus401JSONResponse ErrorResponse

type GetSinkStatus404JSONResponse ErrorResponse

type GetSinkStatus501JSONResponse ErrorResponse

type GetSinkStatusRequestObject struct {
	SinkId string `json:"sink_id"`
}

type GetSinkStatusResponseObject interface {
	VisitGetSinkStatusResponse(w http.ResponseWriter) error
}

type GetWorkloadRevision200JSONResponse WorkloadRevisionResponse

type GetWorkloadRevision400JSONResponse ErrorResponse

type GetWorkloadRevision401JSONResponse ErrorResponse

type GetWorkloadRevision403JSONResponse ErrorResponse

type GetWorkloadRevision404JSONResponse ErrorResponse

type GetWorkloadRevision501JSONResponse ErrorResponse

type GetWorkloadRevisionRequestObject struct {
	WorkloadId string `json:"workload_id"`
	RevisionId string `json:"revision_id"`
}

type GetWorkloadRevisionResponseObject interface {
	VisitGetWorkloadRevisionResponse(w http.ResponseWriter) error
}

type HealthLive200JSONResponse struct {
	Status string `json:"status"`
}

type HealthLiveRequestObject struct {
}

type HealthLiveResponseObject interface {
	VisitHealthLiveResponse(w http.ResponseWriter) error
}

type HealthReady200JSONResponse struct {
	ApiEpoch              string   `json:"api_epoch"`
	BuildRevision         string   `json:"build_revision"`
	CompatibilityFeatures []string `json:"compatibility_features"`
	Status                string   `json:"status"`
	StorageEpoch          string   `json:"storage_epoch"`
	SupportedClientEpochs []string `json:"supported_client_epochs"`
}

type HealthReadyRequestObject struct {
}

type HealthReadyResponseObject interface {
	VisitHealthReadyResponse(w http.ResponseWriter) error
}

type HostFacts struct {
	// Attested Every host promise somebody established about this machine, by name. It is not a set of the true ones: false is an answer, and a name absent was never established.
	Attested map[string]bool `json:"attested,omitempty"`

	// Driver The accelerator driver a host runs and the highest accelerator capability it supports, in the vendor's own versioning. It is the host half of the compatibility contract: the image carries the workload's own accelerator stack, and these two decide whether it can run here at all.
	Driver AcceleratorDriver `json:"driver,omitempty"`
}

type HostRequirements struct {
	// Facts The host promises this Run refuses to run without. A machine that never stated one is refused UNKNOWN_FACT, as loudly as a machine that stated its opposite is refused CAPABILITY_MISMATCH.
	Facts []HostRequirementsFacts `json:"facts,omitempty"`

	// MinDriverCapability The lowest accelerator capability this workload's image was built for, in the vendor's own versioning. For NVIDIA it is the CUDA version the driver must support.
	MinDriverCapability string `json:"min_driver_capability,omitempty"`

	// MinDriverVersion The oldest accelerator driver this workload's image runs on, in the vendor's own versioning.
	MinDriverVersion string `json:"min_driver_version,omitempty"`
}

type HostRequirementsFacts string

type ImageInventory struct {
	// ImageDigests Image manifests this host holds whole and has unpacked, so it can start a container on one now.
	ImageDigests []string `json:"image_digests,omitempty"`

	// Known Whether the holder enumerated its content at all. False is an honest answer rather than a failure: a provider that cannot say what a fresh machine holds says so, and the uncertainty is priced rather than mistaken for warmth.
	Known bool `json:"known"`

	// LayerDiffIds The same unpacked content named the way a container daemon names it: the digest of the uncompressed layer. A Docker host can enumerate only these, so a resolved manifest carries both spaces and matches whichever one the host answers in.
	LayerDiffIds []string `json:"layer_diff_ids,omitempty"`

	// LayerDigests Compressed layer blobs this host holds unpacked, named the way a registry manifest names them. A host can hold layers of an image it never held whole, which is why a second version of the same image starts faster than a first.
	LayerDigests []string `json:"layer_digests,omitempty"`

	// ObservedAt When the holder last looked. Locality decays, so the age of this answer is material. How long anyone stands behind it is the offer's own expiry: the enumeration and the capacity claim come out of one observation, and an expired offer is refused whole.
	ObservedAt time.Time `json:"observed_at,omitempty"`

	// PulledImageDigests Image manifests whose content arrived here and which are not assembled into a runnable layer chain. Fetching and unpacking are separate acts, and a host that has done the first and not the second is neither warm nor cold: what is left is local work rather than a pull.
	PulledImageDigests []string `json:"pulled_image_digests,omitempty"`

	// UnknownImageDigests Image manifests this host looked at and could not account for: a runtime that would not describe one, or a store reporting part of its content present and unable to name which part. A host that enumerates itself can still fail on one image, and an image absent from every other list would otherwise read as the confident claim that none of it is here.
	UnknownImageDigests []string `json:"unknown_image_digests,omitempty"`
}

type ImageResolver interface {
	Resolve(context.Context, ociresolver.ResolveRequest) (ociresolver.ResolvedImage, error)
}

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

type InviteNode201JSONResponse NodeBootstrapResponse

type InviteNode400JSONResponse ErrorResponse

type InviteNode401JSONResponse ErrorResponse

type InviteNode409JSONResponse ErrorResponse

type InviteNode500JSONResponse ErrorResponse

type InviteNodeJSONRequestBody = InviteNodeRequest

type InviteNodeRequest struct {
	// AvailableUntil When this machine stops being Mercator's to use. Omitted is a machine with no such moment. Work that could still be running then is refused before it starts, judged against the runtime Mercator enforces rather than the one its caller expects.
	AvailableUntil time.Time `json:"available_until,omitempty"`

	// BillingIntervalSeconds The block of time this machine is bought in. Work that runs past the end of the interval Mercator has committed to commits it to the next whole one, and the part of that nothing uses is charged to the placement that bought it rather than to nobody. Omitted is a machine bought in no increments at all, which is an operator's own hardware: Mercator holds it continuously, so no second of it is a fresh commitment and there is no tail to charge.
	BillingIntervalSeconds int64 `json:"billing_interval_seconds,omitempty"`

	// EligibleServiceClasses The kinds of work this machine may be used for. Omitted is a machine held for nobody in particular. Work of any other class is refused this machine outright rather than priced on it.
	EligibleServiceClasses []ServiceClass `json:"eligible_service_classes,omitempty"`

	// NodeId Node identity to reserve. Generated when omitted.
	NodeId string `json:"node_id,omitempty"`

	// RentalId The Rental this node belongs to. Generated when omitted.
	RentalId string `json:"rental_id,omitempty"`

	// ShadowPriceUsdPerHour What holding this machine costs. Placement needs a price to weigh a node against fresh capacity; a node invited at zero has unknown pricing and is refused rather than treated as free.
	ShadowPriceUsdPerHour float32 `json:"shadow_price_usd_per_hour"`
}

type InviteNodeRequestObject struct {
	Body *InviteNodeJSONRequestBody
}

type InviteNodeResponseObject interface {
	VisitInviteNodeResponse(w http.ResponseWriter) error
}

type LaunchStageEstimates struct {
	AcquisitionSeconds      Estimate `json:"acquisition_seconds"`
	AgentReadySeconds       Estimate `json:"agent_ready_seconds"`
	ApplicationReadySeconds Estimate `json:"application_ready_seconds"`
	ArtifactFetchSeconds    Estimate `json:"artifact_fetch_seconds"`
	BootSeconds             Estimate `json:"boot_seconds"`
	ContainerStartSeconds   Estimate `json:"container_start_seconds"`
	ImageFetchSeconds       Estimate `json:"image_fetch_seconds"`
	UnpackSeconds           Estimate `json:"unpack_seconds"`
}

type LifecycleCapabilities struct {
	CancelQueued     bool   `json:"cancel_queued"`
	IdempotentLaunch string `json:"idempotent_launch"`
	ListOwned        bool   `json:"list_owned"`
	ProviderTtl      bool   `json:"provider_ttl"`
}

type ListAdapters200JSONResponse AdapterListResponse

type ListAdapters401JSONResponse ErrorResponse

type ListAdaptersRequestObject struct {
}

type ListAdaptersResponseObject interface {
	VisitListAdaptersResponse(w http.ResponseWriter) error
}

type ListConnections200JSONResponse ConnectionListResponse

type ListConnections400JSONResponse ErrorResponse

type ListConnections401JSONResponse ErrorResponse

type ListConnections403JSONResponse ErrorResponse

type ListConnections500JSONResponse ErrorResponse

type ListConnectionsRequestObject struct {
}

type ListConnectionsResponseObject interface {
	VisitListConnectionsResponse(w http.ResponseWriter) error
}

type ListNodes200JSONResponse NodeListResponse

type ListNodes400JSONResponse ErrorResponse

type ListNodes401JSONResponse ErrorResponse

type ListNodes500JSONResponse ErrorResponse

type ListNodesRequestObject struct {
}

type ListNodesResponseObject interface {
	VisitListNodesResponse(w http.ResponseWriter) error
}

type ListOffers200JSONResponse OfferListResponse

type ListOffers400JSONResponse ErrorResponse

type ListOffers401JSONResponse ErrorResponse

type ListOffers403JSONResponse ErrorResponse

type ListOffers502JSONResponse ErrorResponse

type ListOffersRequestObject struct {
}

type ListOffersResponseObject interface {
	VisitListOffersResponse(w http.ResponseWriter) error
}

type ListRunEvents200JSONResponse EventListResponse

type ListRunEvents400JSONResponse ErrorResponse

type ListRunEvents401JSONResponse ErrorResponse

type ListRunEvents403JSONResponse ErrorResponse

type ListRunEvents500JSONResponse ErrorResponse

type ListRunEventsRequestObject struct {
	RunId string `json:"run_id"`
}

type ListRunEventsResponseObject interface {
	VisitListRunEventsResponse(w http.ResponseWriter) error
}

type ListRuns200JSONResponse RunListResponse

type ListRuns400JSONResponse ErrorResponse

type ListRuns401JSONResponse ErrorResponse

type ListRuns403JSONResponse ErrorResponse

type ListRuns500JSONResponse ErrorResponse

type ListRunsParams struct {
	// Cursor Opaque cursor returned by the previous page.
	Cursor string `form:"cursor,omitempty" json:"cursor,omitempty"`
	Limit  int    `form:"limit,omitempty" json:"limit,omitempty"`
}

type ListRunsRequestObject struct {
	Params ListRunsParams
}

type ListRunsResponseObject interface {
	VisitListRunsResponse(w http.ResponseWriter) error
}

type ListWorkloadRevisions200JSONResponse WorkloadRevisionListResponse

type ListWorkloadRevisions400JSONResponse ErrorResponse

type ListWorkloadRevisions401JSONResponse ErrorResponse

type ListWorkloadRevisions403JSONResponse ErrorResponse

type ListWorkloadRevisions500JSONResponse ErrorResponse

type ListWorkloadRevisions501JSONResponse ErrorResponse

type ListWorkloadRevisionsRequestObject struct {
	WorkloadId string `json:"workload_id"`
}

type ListWorkloadRevisionsResponseObject interface {
	VisitListWorkloadRevisionsResponse(w http.ResponseWriter) error
}

type MemoryRequirement struct {
	MinBytes int64 `json:"min_bytes"`
}

type MiddlewareFunc func(http.Handler) http.Handler

type NetworkCapabilities struct {
	Inbound    NetworkCapabilitiesInbound `json:"inbound"`
	Protocols  []string                   `json:"protocols,omitempty"`
	PublicIpv4 bool                       `json:"public_ipv4"`
}

type NetworkCapabilitiesInbound string

type NetworkDownloadRequirement struct {
	AllowUnknown             bool                            `json:"allow_unknown"`
	MaxMeasurementAgeSeconds int64                           `json:"max_measurement_age_seconds"`
	MinP10Mbps               float64                         `json:"min_p10_mbps"`
	Scope                    NetworkDownloadRequirementScope `json:"scope"`
}

type NetworkDownloadRequirementScope string

type NetworkFact struct {
	Confidence  float64          `json:"confidence"`
	ObservedAt  time.Time        `json:"observed_at"`
	SampleCount int              `json:"sample_count"`
	Scope       NetworkFactScope `json:"scope"`
	Source      string           `json:"source"`
	Statistic   string           `json:"statistic"`
	ValidUntil  time.Time        `json:"valid_until"`
	ValueMbps   float64          `json:"value_mbps"`
}

type NetworkFactScope string

type NetworkFacts struct {
	Download []NetworkFact `json:"download,omitempty"`
}

type NetworkRequirements struct {
	Download NetworkDownloadRequirement `json:"download,omitempty"`
	Inbound  NetworkRequirementsInbound `json:"inbound"`
}

type NetworkRequirementsInbound string

type NodeBootstrapResponse struct {
	AgentVersion    string `json:"agent_version"`
	ControlPlaneUrl string `json:"control_plane_url"`

	// EnrollmentToken Short-lived and redeemable once. It is returned exactly this once and is never stored in a readable form.
	EnrollmentToken string `json:"enrollment_token"`
	Generation      int64  `json:"generation"`
	NodeId          string `json:"node_id"`
	RentalId        string `json:"rental_id"`
}

type NodeListResponse struct {
	Nodes []NodeSummary `json:"nodes"`
}

type NodeRegistry interface {
	Invite(ctx context.Context, invitation node.Invitation) (capability.NodeBootstrap, error)
	List(ctx context.Context) ([]node.Record, error)
}

type NodeSummary struct {
	Accelerators     int    `json:"accelerators,omitempty"`
	AgentVersion     string `json:"agent_version,omitempty"`
	ContainerRuntime string `json:"container_runtime,omitempty"`

	// DiskFreeBytes The room this node last measured, always stated. It is zero unless disk_report is measured, because bytes nobody established are not room: it is what the node's offer advertises, so a node with none wins no placement that declares a disk floor. Zero with disk_report measured is a machine that is full.
	DiskFreeBytes int64 `json:"disk_free_bytes"`

	// DiskReport What is known about the room on the filesystem this node's daemon keeps content on, which is three answers and not two. never_reported is an identity nobody has heard from yet, so nothing has been measured because nothing has been asked. unmeasurable is a node that answered and could not measure: its daemon keeps content somewhere its agent cannot see, which costs it every placement that declares a disk floor and never its membership of the fleet. measured is a number this node established, and zero of it is a full machine.
	DiskReport            NodeSummaryDiskReport `json:"disk_report"`
	Generation            int64                 `json:"generation"`
	Id                    string                `json:"id"`
	LastHeartbeatAt       time.Time             `json:"last_heartbeat_at,omitempty"`
	LeaseExpires          time.Time             `json:"lease_expires,omitempty"`
	RentalId              string                `json:"rental_id"`
	ShadowPriceUsdPerHour float32               `json:"shadow_price_usd_per_hour"`

	// State What the control plane believes about this node. A lost node is unobserved, not dead.
	State NodeSummaryState `json:"state"`
}

type NodeSummaryDiskReport string

type NodeSummaryState string

type ObservabilityCapabilities struct {
	Logs    string `json:"logs"`
	Metrics string `json:"metrics"`
	Shell   string `json:"shell"`
}

type OfferAggregator interface {
	AggregateOffers(context.Context, adapter.OfferRequest) (broker.OfferAggregation, error)
}

type OfferListResponse struct {
	Failures []ConnectionFailure `json:"failures"`
	Offers   []OfferSnapshot     `json:"offers"`
}

type OfferSnapshot = domain.OfferSnapshot

type Option func(*Server)

type PlacementPolicy struct {
	// AllowUnknownPricing Whether this Run would rather run on a machine nobody has quoted a price for than not run at all. It admits such a candidate and never prefers one: an unpriced candidate ranks behind every candidate somebody priced, and it cannot clear max_expected_cost_usd, because a bound on dollars is not cleared by a candidate that has none.
	AllowUnknownPricing bool `json:"allow_unknown_pricing,omitempty"`

	// ExpectedReadySeconds How long this workload takes to become ready for work once its process is running. It is the only prediction of the application-ready stage there is: readiness is the application's own semantics, so the workload is the only authority that can state it, and a Run that states nothing is predicted nothing.
	ExpectedReadySeconds   float64 `json:"expected_ready_seconds,omitempty"`
	ExpectedRuntimeSeconds float64 `json:"expected_runtime_seconds,omitempty"`

	// Group The family of Runs this one belongs to and the most of that family Mercator may have holding capacity at once. It is a bound on the work rather than a request for a machine: a member whose family is already that wide is queued GROUP_AT_PARALLELISM even where the fleet has capacity standing idle, and the wait ends when a member of the same family finishes. Every member states the width, because a group is a label the work carries rather than an object an operator creates: there is nothing to register before submitting, and a name without a width is refused with RUN_GROUP_INCOMPLETE. The name is deployment-global.
	Group              RunGroup `json:"group,omitempty"`
	MaxExpectedCostUsd float64  `json:"max_expected_cost_usd,omitempty"`
	MaxP90StartSeconds float64  `json:"max_p90_start_seconds,omitempty"`

	// ServiceClass The kind of work this Run is, which is the only thing that says what waiting is worth to it. Every class declares its own exchange rate, and the score is computed over those rates: interactive prices a second of waiting to the start at twenty times the rent of the machine doing the waiting, standard at that rent, experimental and batch price it to the finish at twice and a fifth of it, and opportunistic prices it at nothing and takes whatever costs least. A class Mercator does not know is refused with SERVICE_CLASS_UNKNOWN rather than ranked on price alone. Omitted means standard.
	ServiceClass PlacementPolicyServiceClass `json:"service_class"`
}

type PlacementPolicyServiceClass string

type PlacementPreviewRequest struct {
	RunId    string           `json:"run_id,omitempty"`
	Workload WorkloadRevision `json:"workload"`
}

type PlacementPreviewResponse struct {
	Decision BookingDecision `json:"decision"`
}

type Platform struct {
	Architecture string `json:"architecture"`
	Os           string `json:"os"`
}

type PortSpec struct {
	ContainerPort int              `json:"container_port"`
	Exposure      PortSpecExposure `json:"exposure"`
	Name          string           `json:"name"`
	Protocol      string           `json:"protocol"`
}

type PortSpecExposure string

type PreviewPlacement200JSONResponse PlacementPreviewResponse

type PreviewPlacement400JSONResponse ErrorResponse

type PreviewPlacement401JSONResponse ErrorResponse

type PreviewPlacement403JSONResponse ErrorResponse

type PreviewPlacement413JSONResponse ErrorResponse

type PreviewPlacement502JSONResponse ErrorResponse

type PreviewPlacementJSONRequestBody = PlacementPreviewRequest

type PreviewPlacementRequestObject struct {
	Body *PreviewPlacementJSONRequestBody
}

type PreviewPlacementResponseObject interface {
	VisitPreviewPlacementResponse(w http.ResponseWriter) error
}

type PriceModel struct {
	Currency             string  `json:"currency"`
	GranularitySeconds   int64   `json:"granularity_seconds"`
	Known                bool    `json:"known"`
	MinimumChargeSeconds int64   `json:"minimum_charge_seconds"`
	RatePerSecondUsd     float64 `json:"rate_per_second_usd"`
	SetupFeeUsd          float64 `json:"setup_fee_usd"`
}

type PricingCapabilities struct {
	Known bool `json:"known"`
}

type QueueSnapshot struct {
	ActiveSlots       int     `json:"active_slots"`
	QueuedWorkSeconds float64 `json:"queued_work_seconds"`
}

type QueuedAhead = domain.QueuedAhead

type RefreshRun200JSONResponse RunResponse

type RefreshRun400JSONResponse ErrorResponse

type RefreshRun401JSONResponse ErrorResponse

type RefreshRun403JSONResponse ErrorResponse

type RefreshRun502JSONResponse ErrorResponse

type RefreshRunRequestObject struct {
	RunId string `json:"run_id"`
}