cloud

type BrowserLogin struct {
	// Endpoint is the control plane being logged in to.
	Endpoint Endpoint
	// OpenURL is the browser launcher. Injectable so a test drives the
	// whole flow without opening a real browser.
	OpenURL func(string) error
	// Timeout bounds the wait for the browser. A login that hangs forever is
	// indistinguishable from one about to succeed.
	Timeout time.Duration
	// Out receives the "open this URL" notice.
	Out io.Writer
}

type Caller interface {
	Call(ctx context.Context, procedure string, req, out any) error
}

type ClaimableAPI interface {
	Availability(ctx context.Context) (ClaimableAvailability, error)
	Challenge(ctx context.Context) (ClaimableChallenge, error)
	Start(ctx context.Context, req ClaimableStartRequest) (ClaimableDeploy, error)
}

type ClaimableAvailability struct {
	Available        bool             `json:"available"`
	Causes           []ClaimableCause `json:"causes,omitempty"`
	ComputeAvailable bool             `json:"computeAvailable"`
	ComputeCauses    []ClaimableCause `json:"computeCauses,omitempty"`
	// Limits are the claimable plan's caps, as the control plane enforces
	// them. Nil from a control plane that predates publishing them.
	Limits *ClaimableLimits `json:"limits,omitempty"`
}

type ClaimableCause struct {
	// Code is disabled | dependency_unavailable | not_supported.
	Code string `json:"code"`
	// Component is the switch or the dependency (claim_secret,
	// anonymous_signup, content_scan_web_risk, network_policing, ...).
	Component string `json:"component,omitempty"`
	Message   string `json:"message"`
}

type ClaimableChallenge struct {
	Challenge      string    `json:"challenge"`
	DifficultyBits uint32    `json:"difficultyBits"`
	ExpiresAt      time.Time `json:"expiresAt"`
}

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

type ClaimableDeploy struct {
	AccessToken string    `json:"accessToken"`
	OrgID       string    `json:"orgId"`
	ClaimURL    string    `json:"claimUrl"`
	ExpiresAt   time.Time `json:"expiresAt"`
	PurgeAfter  time.Time `json:"purgeAfter"`
	Reused      bool      `json:"reused"`
}

type ClaimableLimits struct {
	MaxStaticSites              int32 `json:"maxStaticSites,omitempty"`
	MaxStaticStoredMib          int32 `json:"maxStaticStoredMib,omitempty"`
	MaxServices                 int32 `json:"maxServices,omitempty"`
	MaxReplicas                 int32 `json:"maxReplicas,omitempty"`
	MaxMigrationJobs            int32 `json:"maxMigrationJobs,omitempty"`
	WorkloadCPUMillicores       int32 `json:"workloadCpuMillicores,omitempty"`
	WorkloadMemoryMib           int32 `json:"workloadMemoryMib,omitempty"`
	WorkloadEphemeralStorageMib int32 `json:"workloadEphemeralStorageMib,omitempty"`
	MaxDatabases                int32 `json:"maxDatabases,omitempty"`
	DatabaseInstances           int32 `json:"databaseInstances,omitempty"`
	DatabaseCPUMillicores       int32 `json:"databaseCpuMillicores,omitempty"`
	DatabaseMemoryMib           int32 `json:"databaseMemoryMib,omitempty"`
	DatabaseStorageMib          int32 `json:"databaseStorageMib,omitempty"`
	DatabaseMaxConnections      int32 `json:"databaseMaxConnections,omitempty"`
	DatabaseDeclaredStorageGib  int32 `json:"databaseDeclaredStorageGib,omitempty"`
}

type ClaimableStartRequest struct {
	Project      string `json:"project"`
	Env          string `json:"env"`
	DeviceID     string `json:"deviceId"`
	PoWChallenge string `json:"powChallenge"`
	PoWNonce     string `json:"powNonce"`
}

type ClaimableThrottle struct {
	// Scope is network | device | platform.
	Scope string
	// RetryAfter is how long to wait.
	RetryAfter time.Duration
}

type Client struct {
	Endpoint   Endpoint
	Credential Credential
	HTTP       *http.Client
	// contains filtered or unexported fields
}

type Credential struct {
	Kind   string
	Token  string
	Source CredentialSource
	// From is the human-readable origin: the flag name, the env var name,
	// the credentials file path, or the helper's description of the
	// session it used. Safe to print; never the token itself.
	From string
	// ExpiresAt is when the token stops being accepted, when known: a
	// helper's tokens and a stored login carry one; nil means unknown.
	ExpiresAt *time.Time
	// Scopes the issuer reported granting, when known (a stored login records
	// them). Informational — the server decides.
	Scopes []string
}

type CredentialSource string

type Declaration struct {
	Endpoint string
	TokenEnv string
}

type Endpoint struct {
	// ProjectID is a server-owned target identity, never credential/org selection.
	ProjectID   string
	ProjectName string
	// Env is the environment this endpoint was declared by. Carried so
	// error messages can name the KCL file to edit.
	Env string
	// URL is the base URL, trailing slash trimmed.
	URL string
	// TokenEnv is the env var NAME the credential is read from.
	TokenEnv string
}

type Error struct {
	// HTTPStatus is the response status. Kept because a response that is
	// not a Connect envelope at all (a proxy's HTML error page) has no
	// code, and the status is then the only classification available.
	HTTPStatus int

	// Code is the Connect error code as its wire name: "already_exists",
	// "not_found", "failed_precondition", "unauthenticated". Empty when
	// the body was not a Connect envelope.
	Code string

	// Reason is the app-defined domain reason from ReasonHeader, e.g.
	// "promotion_conflict" or "rollout_in_flight". Empty when the server
	// sent none.
	//
	// THIS IS THE FIELD TO BRANCH ON. The Connect code says the category
	// (FailedPrecondition), and three different refusals share it; the
	// reason says which one, and is the server's committed contract.
	Reason string

	// Scopes are the scopes a "scope_missing" refusal names, from the
	// response's accesstoken.ScopesHeader. Empty when the server named none.
	Scopes []string

	// Message is the server's own message, verbatim and untruncated. For
	// DISPLAY — never for control flow.
	Message string

	// Details are the Connect error details, each left in its wire form.
	//
	// NOT DECODED, and that is deliberate: decoding a google.protobuf.Any
	// would mean vendoring the control plane's protos into forge, which is
	// the one coupling forge's deploy story must not take on. Connect's
	// JSON binding includes a `debug` member carrying the message as
	// protojson when the server could produce it, so a caller reads the
	// payload as JSON (see DetailJSON) without a generated type.
	Details []ErrorDetail

	// Header is the response's headers, for the few facts a control plane
	// sends there beside the reason (a throttle's retry-after).
	Header http.Header

	// Procedure and Endpoint are where this happened, for the message.
	Procedure string
	Endpoint  string
	// contains filtered or unexported fields
}

type ErrorDetail struct {
	// Type is the protobuf full name, e.g.
	// "controlplane.v1.DeployPromoteRefusal".
	Type string `json:"type"`
	// Value is the base64 (raw std, unpadded) proto binary.
	Value string `json:"value"`
	// Debug is the same message as protojson, present when the server had
	// descriptors for it. This is the member a forge caller reads.
	Debug json.RawMessage `json:"debug,omitempty"`
}