sandbox

type APIError struct {
	// Status is the HTTP status of the response.
	Status int

	// Code is the machine-readable error code, empty when the response has
	// none.
	Code string

	// Details are additional error details, nil when the response has none.
	Details any

	// Body is the response body, parsed as JSON when possible, otherwise the
	// raw text.
	Body any
	// contains filtered or unexported fields
}

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

type ClientOptions struct {
	// APIKey is the Baseten API key used for authentication. Required unless
	// one of the advanced ManagementClient or TokenProvider options is set.
	APIKey string

	// TeamID is the team to act in. Empty uses the caller's only team, and
	// is an error for callers in more than one team.
	TeamID string

	// BaseURL overrides the default management API base URL. If empty,
	// "https://api.baseten.co" is used.
	BaseURL string

	// HTTPClient overrides the default HTTP client. If nil,
	// http.DefaultClient is used.
	HTTPClient interface {
		Do(*http.Request) (*http.Response, error)
	}

	// Headers are added to every request. The map is cloned at construction,
	// so later mutations by the caller do not affect the live client.
	Headers http.Header

	// Retries sets how many times calls to a sandbox are retried on dropped
	// connections and gateway errors.
	Retries RetryOptions

	// ManagementClient is an advanced alternative to APIKey: the management
	// client that sandbox tokens are requested through, with its own base
	// URL and authentication. For callers that authenticate the management
	// API other than with an API key. APIKey and TokenProvider must then be
	// empty.
	ManagementClient *client.ManagementClient

	// TokenProvider is an advanced alternative to APIKey: it returns the
	// bearer token for each request, for callers that obtain sandbox tokens
	// themselves. APIKey and ManagementClient must then be empty.
	TokenProvider TokenProvider
}

type CreateOptions struct {
	// Name is the sandbox's unique name. The server assigns one when empty.
	Name string

	// CreateIfNotExists returns the existing sandbox with this name instead
	// of failing when one exists. Requires Name.
	CreateIfNotExists bool

	// Image is the image reference, including its tag. Defaults to
	// "baseten/base-image:latest".
	Image string

	// Memory is the memory allocation in megabytes, which also sets the CPU
	// allocation. Defaults to 4096.
	Memory int

	// Region is where the sandbox runs. Empty uses the closest region.
	Region string

	// Envs are the environment variables injected into the sandbox, by name.
	Envs map[string]EnvValue

	// Labels are the key-value pairs for organizing and filtering.
	Labels map[string]string

	// ExternalID is a caller-owned identifier for external lookups.
	ExternalID string

	// Lifecycle is when the sandbox expires.
	Lifecycle *Lifecycle

	// Ports are the ports the sandbox exposes.
	Ports []Port

	// Network is the sandbox's network configuration. It cannot be updated
	// later.
	Network *Network
}

type CreateResult struct {
	*Sandbox

	// Info is the sandbox's record as of creation. The sandbox becomes ready
	// asynchronously, so its status is usually still deploying.
	Info Info
}

type DeleteOptions struct {
	// Name is the sandbox's name. Required.
	Name string
}

type EnvValue struct {
	// Value of the variable.
	Value string

	// NonSecret marks the value as not secret, so it is returned unmasked.
	// False, the default, keeps it secret.
	NonSecret bool
}

type ExpirationAction string

type ExpirationPolicy struct {
	// Type is the kind of policy, which decides whether After or At applies.
	Type ExpirationPolicyType

	// After is the duration for [ExpirationPolicyTypeTTLIdle] and
	// [ExpirationPolicyTypeTTLMaxAge].
	After time.Duration

	// At is the time for [ExpirationPolicyTypeDate].
	At time.Time

	// Action is what happens on expiry. Empty sends [ExpirationActionDelete].
	Action ExpirationAction
}

type ExpirationPolicyType string

type FileSystemCopyError struct {
	// Source is the path copied from.
	Source string

	// Destination is the path copied to.
	Destination string

	// Process is the cp process as it ended, whose Stderr holds its error
	// output.
	Process *ProcessInfo
}

type FileSystemCopyOptions struct {
	// Source is the path of the file or directory to copy. Required.
	Source string

	// Destination is the path to copy to. Required.
	Destination string

	// Timeout is how long to wait for the copy. Zero uses 180 seconds, and a
	// negative value waits with no limit. The copy keeps running regardless.
	Timeout time.Duration
}

type FileSystemDirectory struct {
	Name           string
	Path           string
	Files          []FileSystemFileInfo
	Subdirectories []FileSystemSubdirectoryInfo
}

type FileSystemEntryType string

type FileSystemFileInfo struct {
	Name string
	Path string

	// Size is the file's size in bytes.
	Size int64

	// Permissions is the file's mode, as the sandbox reports it.
	Permissions string

	Owner        string
	Group        string
	LastModified time.Time
}

type FileSystemFindMatch struct {
	// Path is relative to the searched path.
	Path string

	Type FileSystemEntryType
}

type FileSystemFindOptions struct {
	// Path is the path of the directory to search in. Required.
	Path string

	// Type finds only files or only directories. Empty finds both.
	Type FileSystemEntryType

	// Patterns are file patterns to include, such as "*.go".
	Patterns []string

	// MaxResults is the most results to return. Zero uses the sandbox's
	// default of 20, and a negative value returns all.
	MaxResults int

	// ExcludeDirs are directory names to skip. Empty uses the sandbox's
	// default of common dependency and build directories, such as
	// node_modules and .git.
	ExcludeDirs []string

	// IncludeHidden includes hidden files and directories, which the sandbox
	// skips by default.
	IncludeHidden bool
}

type FileSystemFindResult struct {
	Matches []FileSystemFindMatch

	// Total is the number of entries found, which may exceed the matches
	// returned.
	Total int
}

type FileSystemGrepMatch struct {
	// Path is relative to the searched path.
	Path string

	// Line is the line number, starting at 1.
	Line int

	Column int

	// Text is the matching line.
	Text string

	// Context is the matching line with up to
	// [FileSystemGrepOptions.ContextLines] lines before and after it,
	// newline-separated. Empty when ContextLines is zero.
	Context string
}

type FileSystemGrepOptions struct {
	// Path is the path of the directory to search in. Required.
	Path string

	// Query is the text to search for. Required.
	Query string

	// CaseSensitive makes the search case sensitive.
	CaseSensitive bool

	// MaxResults is the most results to return. Zero uses the sandbox's
	// default of 100.
	MaxResults int

	// FilePattern is a file pattern to include, such as "*.go".
	FilePattern string

	// ExcludeDirs are directory names to skip. Empty uses the sandbox's
	// default of common dependency and build directories, such as
	// node_modules and .git.
	ExcludeDirs []string

	// ContextLines is how many lines before and after each match to include
	// in its Context, at most 20. Zero includes none.
	ContextLines int
}

type FileSystemGrepResult struct {
	Matches []FileSystemGrepMatch

	// Total is the number of matching lines, which may exceed the matches
	// returned.
	Total int
}

type FileSystemListOptions struct {
	// Path is the path of the directory. Required.
	Path string
}

type FileSystemMkdirOptions struct {
	// Path is the path of the directory. Required.
	Path string

	// Permissions is the octal directory mode, such as "0755". Empty uses the
	// sandbox's default.
	Permissions string
}

type FileSystemReadBytesOptions struct {
	// Path is the path of the file. Required.
	Path string
}

type FileSystemReadOptions struct {
	// Path is the path of the file. Required.
	Path string
}

type FileSystemRemoveOptions struct {
	// Path is the path of the file or directory. Required.
	Path string

	// Recursive removes a directory and everything in it.
	Recursive bool
}

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

type FileSystemSubdirectoryInfo struct {
	Name string
	Path string
}

type FileSystemWatchEvent struct {
	// Ops are the kinds of change, more than one when the sandbox reports
	// several together.
	Ops []FileSystemWatchOp

	// Path is the full path of the changed entry.
	Path string
}

type FileSystemWatchOp string

type FileSystemWatchOptions struct {
	// Path is the path of the directory to watch. Required.
	Path string

	// Recursive also watches every subdirectory, including ones created
	// later.
	Recursive bool

	// Ignore skips events whose full path contains any of these substrings.
	Ignore []string
}

type FileSystemWriteBytesOptions struct {
	// Path is the path of the file, created or replaced. Required.
	Path string

	// Content is the content to write.
	Content []byte

	// Permissions is the octal file mode, such as "0755", applied when the
	// file is created. An existing file keeps its mode. Empty uses the
	// sandbox's default.
	Permissions string
}

type FileSystemWriteOptions struct {
	// Path is the path of the file, created or replaced. Required.
	Path string

	// Content is the text content to write.
	Content string
}

type FileSystemWriteTreeOptions struct {
	// Path is the path of the directory to write under. Required.
	Path string

	// Files is the text content of each file, by path relative to Path.
	Files map[string]string
}

type GatewayError struct {
	APIError
}

type GetInfoOptions struct {
	// Name is the sandbox's name. Required.
	Name string

	// ShowSecrets returns environment variable values unmasked. Requires the
	// workspace admin role.
	ShowSecrets bool
}

type GetOptions struct {
	// Name is the sandbox's name. Required.
	Name string
}

type ImageBuildError struct {
	// ImageName is the name of the image.
	ImageName string

	// Status is the status last seen, [ImageStatusFailed] when the build
	// failed.
	Status ImageStatus

	// TimedOut is whether the wait ran out of time. Processing continues
	// regardless.
	TimedOut bool
}

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

type ImageBuilderAddFileOptions struct {
	// Destination is the path in the image. Required.
	Destination string

	// Content is the file's content.
	Content []byte

	// ContextName is the file's name in the build context. Empty uses the
	// destination's base name, with a suffix such as " (1)" if another entry
	// already has that name.
	ContextName string

	// Mode is the file's permission bits in the image. Zero uses 0644.
	Mode fs.FileMode
}

type ImageBuilderAddLocalDirOptions struct {
	// Source is the local directory's path. Required.
	Source string

	// Destination is the path in the image. Required.
	Destination string

	// ContextName is the directory's name in the build context. Empty uses
	// the source's base name, with a suffix such as " (1)" if another entry
	// already has that name.
	ContextName string
}

type ImageBuilderAddLocalFileOptions struct {
	// Source is the local file's path. Required.
	Source string

	// Destination is the path in the image. Required.
	Destination string

	// ContextName is the file's name in the build context. Empty uses the
	// source's base name, with a suffix such as " (1)" if another entry
	// already has that name.
	ContextName string
}

type ImageBuilderOptions struct {
	// BaseImage is the registry image to start from, as FROM <BaseImage>.
	// Required.
	BaseImage string

	// SandboxAPIImage is the image to copy the sandbox API binary from, when
	// the Dockerfile does not bring it in itself. Empty uses
	// ghcr.io/blaxel-ai/sandbox:latest.
	SandboxAPIImage string
}

type ImageCleanupOptions struct{}

type ImageCleanupResult struct {
	// Deleted is how many image versions were removed.
	Deleted int

	// Message describes the outcome.
	Message string
}

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

type ImageDeleteOptions struct {
	// Name is the image's name. Required.
	Name string
}

type ImageDeleteTagOptions struct {
	// Name is the image's name. Required.
	Name string

	// Tag is the version to delete. Required.
	Tag string
}

type ImageGetInfoOptions struct {
	// Name is the image's name. Required.
	Name string
}

type ImageIgnoreFileFunc func(context.Context, ImageIgnoreFileOptions) (ignore bool, err error)

type ImageIgnoreFileOptions struct {
	// RelPath is the path relative to the directory's root, using forward
	// slashes on all platforms.
	RelPath string

	// Entry is the directory entry as returned by [os.ReadDir].
	Entry fs.DirEntry
}

type ImageIgnoreFileProcessorOptions struct {
	// Path is the absolute path to the .dockerignore file.
	Path string

	// Contents is the raw bytes of the .dockerignore file.
	Contents []byte
}

type ImageInfo struct {
	// Name is the image's unique name.
	Name string

	// Status is the status of the image's latest version.
	Status ImageStatus

	// CreatedAt is when the image was created, zero when unknown.
	CreatedAt time.Time

	// UpdatedAt is when the image was last updated, zero when unknown.
	UpdatedAt time.Time

	// LastDeployedAt is when a sandbox last used the image, zero when none
	// has.
	LastDeployedAt time.Time

	// SizeBytes is the image's size, zero when unknown.
	SizeBytes int64

	// TagCount is how many versions the image has.
	TagCount int
}

type ImageLibraryInfo struct {
	// Name is the image's stable identifier.
	Name string

	// DisplayName is the image's human-readable name.
	DisplayName string

	// Description is a short description.
	Description string

	// LongDescription is a detailed description.
	LongDescription string

	// Image is the image reference, including its tag, to pass as
	// [CreateOptions.Image].
	Image string

	// Memory is the recommended memory allocation in megabytes, zero when
	// there is none.
	Memory int

	// Ports are the ports the image exposes.
	Ports []Port

	// Categories are the image's categories.
	Categories []string

	// Tags are the image's tags.
	Tags []string

	// URL is the image's documentation URL.
	URL string

	// Icon is the URL of the image's icon.
	Icon string

	// IconLight is the URL of the image's light-mode icon.
	IconLight string

	// IconDark is the URL of the image's dark-mode icon.
	IconDark string

	// Enterprise is whether the image requires an enterprise plan.
	Enterprise bool

	// CreationExtraArgs are kernel selection arguments suggested when
	// creating a sandbox from this image.
	CreationExtraArgs map[string]string

	// CreationVolumes are volume attachments suggested when creating a
	// sandbox from this image.
	CreationVolumes []ImageLibraryVolume
}

type ImageLibraryVolume struct {
	// Name is the volume's name, or an internal identifier for an ephemeral
	// volume.
	Name string

	// MountPath is the absolute path the volume is mounted at.
	MountPath string

	// Type is the volume's type, empty for a persistent volume.
	Type string

	// SizeMB is the storage capacity in megabytes of an ephemeral volume.
	SizeMB int

	// ReadOnly is whether the volume is mounted read-only.
	ReadOnly bool
}

type ImageListLibraryOptions struct{}

type ImageListOptions struct {
	// NamePrefix keeps only images whose names start with this,
	// case-sensitively.
	NamePrefix string

	// Sort is the order of the listing. Empty uses [ImageSortCreatedAtDesc].
	Sort ImageSort

	// PageSize is how many images each underlying request fetches. Zero uses
	// the server's default.
	PageSize int
}

type ImageListTagsOptions struct {
	// Name is the image's name. Required.
	Name string

	// NamePrefix keeps only tags that start with this.
	NamePrefix string

	// Sort is the order of the listing.
	Sort ImageTagSort

	// PageSize is how many versions each underlying request fetches. Zero
	// uses the server's default.
	PageSize int
}

type ImageLogLine struct {
	// Timestamp is when the line was written.
	Timestamp time.Time

	// Severity is the line's severity level.
	Severity int

	// Text is the line's text.
	Text string
}

type ImageLogsOptions struct {
	// Name is the image's name. Required.
	Name string

	// StartTime keeps only lines from this time on. Zero means no lower
	// bound.
	StartTime time.Time

	// EndTime keeps only lines up to this time. Zero means now.
	EndTime time.Time
}

type ImagePushOptions struct {
	// Name is the image's name. Required. To create a sandbox from the
	// image, pass "<name>:latest" as [CreateOptions.Image].
	Name string

	// SourceBuilder is a builder whose Dockerfile and files make up the
	// build context. Its recorded errors, if any, fail the push before
	// anything is sent.
	SourceBuilder *ImageBuilder

	// SourceRegistry is a registry image to import.
	SourceRegistry *ImageRegistrySource

	// SourceZip is a build context, already zipped.
	SourceZip []byte

	// SourceDirectory is a local directory to zip as the build context.
	// Files keep their modes, a link to a file within the directory stores
	// a copy of the file, a link to a file outside it fails the push, a link
	// to a directory stores an empty directory, and a broken link is left
	// out.
	//
	// Paths are left out as a .dockerignore at the directory's root says,
	// read through IgnoreFileProcessor, or else by DefaultIgnoreFile. The
	// root Dockerfile and .dockerignore are always kept, as Docker keeps them.
	SourceDirectory string

	// SourceFiles are the build context's files, by forward-slashed path
	// relative to its root, each with mode 0644.
	SourceFiles map[string][]byte

	// IgnoreFileProcessor parses the .dockerignore at the root of
	// SourceDirectory into an [ImageIgnoreFileFunc], which should match
	// Docker's .dockerignore semantics. Required if SourceDirectory has a
	// .dockerignore; otherwise the push fails before anything is sent. This
	// package has no .dockerignore parser of its own.
	IgnoreFileProcessor func(context.Context, ImageIgnoreFileProcessorOptions) (ImageIgnoreFileFunc, error)

	// DefaultIgnoreFile filters SourceDirectory when it has no
	// .dockerignore. If nil, [DefaultImageIgnoreFile] is used. Pass a
	// function that always returns false to push everything.
	DefaultIgnoreFile ImageIgnoreFileFunc

	// NoTempFile zips a build context read from local files, from
	// SourceDirectory or a builder's local files and directories, in memory
	// instead of in a temporary file. Other build contexts are always zipped
	// in memory.
	NoTempFile bool

	// NoWait returns as soon as the image is pushed, instead of waiting for
	// it to be ready to use.
	NoWait bool

	// Timeout is how long to wait for the image to be ready to use. Zero
	// uses 15 minutes, and a negative value waits with no limit. The build
	// continues regardless.
	Timeout time.Duration

	// PollInterval is how often to check the image's status while waiting.
	// Zero uses 3 seconds.
	PollInterval time.Duration
}

type ImageRegistrySource struct {
	// Image is the registry image reference to import. Required.
	Image string

	// DockerConfig is a Docker config.json with the credentials for pulling
	// Image from a private registry.
	DockerConfig string
}

type ImageSort string

type ImageStatus string

type ImageTagInfo struct {
	// Name is the version's tag.
	Name string

	// CreatedAt is when the version was created, zero when unknown.
	CreatedAt time.Time

	// UpdatedAt is when the version was last updated, zero when unknown.
	UpdatedAt time.Time

	// SizeBytes is the version's size, zero when unknown.
	SizeBytes int64
}

type ImageTagSort string

type ImageUploadError struct {
	// ImageName is the name of the image whose source was being uploaded.
	ImageName string

	// Status is the HTTP status of the storage response.
	Status int

	// Body is the raw text of the storage response body.
	Body string
}

type ImageWaitBuiltOptions struct {
	// Name is the image's name. Required.
	Name string

	// Timeout is how long to wait. Zero uses 15 minutes, and a negative
	// value waits with no limit. The build continues regardless.
	Timeout time.Duration

	// PollInterval is how often to check the image's status. Zero uses 3
	// seconds.
	PollInterval time.Duration
}

type Info struct {
	// Name is the sandbox's unique name.
	Name string

	// URL is the base URL of the sandbox's execution API. Empty until the
	// server assigns one.
	URL string

	// Status is the sandbox's status.
	Status Status

	// Image is the image reference, including its tag.
	Image string

	// Memory is the memory allocation in megabytes, which also sets the CPU
	// allocation.
	Memory int

	// Region is where the sandbox runs.
	Region string

	// Envs are the environment variables injected into the sandbox, by name.
	// Values come back masked unless revealed with
	// [GetInfoOptions.ShowSecrets], so sending them back in an update
	// overwrites the real values with the mask.
	Envs map[string]EnvValue

	// Labels are the key-value pairs for organizing and filtering.
	Labels map[string]string

	// ExternalID is the caller-owned identifier for external lookups.
	ExternalID string

	// Lifecycle is when the sandbox expires, nil when it has no lifecycle.
	Lifecycle *Lifecycle

	// Ports are the ports the sandbox exposes.
	Ports []Port

	// Network is the sandbox's network configuration, nil when it has none.
	Network *Network

	// CreatedAt is when the sandbox was created.
	CreatedAt time.Time

	// UpdatedAt is when the sandbox was last updated, zero when it never was.
	UpdatedAt time.Time

	// CreatedBy is who created the sandbox.
	CreatedBy string

	// UpdatedBy is who last updated the sandbox.
	UpdatedBy string

	// LastUsedAt is when the sandbox was last used, zero when it never was.
	LastUsedAt time.Time

	// ExpiresIn is how long until the sandbox expires, zero when it does not.
	ExpiresIn time.Duration
}

type Lifecycle struct {
	// ExpirationPolicies are the rules for when the sandbox expires.
	ExpirationPolicies []ExpirationPolicy

	// TerminatedRetention is how long a terminated sandbox is kept before it
	// is deleted. Zero uses the server's default.
	TerminatedRetention time.Duration
}

type ListOptions struct {
	// Query searches sandbox names and labels.
	Query string

	// Statuses keeps only sandboxes with one of these statuses. Cannot be
	// combined with ExternalID.
	Statuses []Status

	// ExternalID keeps only sandboxes with this external identifier. Cannot
	// be combined with Statuses.
	ExternalID string

	// PageSize is how many sandboxes each underlying request fetches. Zero
	// uses the server's default.
	PageSize int
}

type Network struct {
	// Subnet is the subnet the sandbox joins. Empty uses the server's
	// default.
	Subnet string

	// Proxy routes the sandbox's outbound traffic, nil for none.
	Proxy *NetworkProxy
}

type NetworkProxy struct {
	// AllowedDomains are the only domains the sandbox may reach, when set.
	AllowedDomains []string

	// ForbiddenDomains are domains the sandbox may not reach.
	ForbiddenDomains []string

	// Bypass are domains whose traffic goes direct instead of through the
	// proxy.
	Bypass []string

	// Routing adds headers, body fields, and secrets to requests for
	// matching destinations.
	Routing []NetworkProxyRoute
}

type NetworkProxyRoute struct {
	// Destinations are the domains this route applies to.
	Destinations []string

	// Headers are added to matching requests.
	Headers map[string]string

	// Body fields are added to matching requests.
	Body map[string]string

	// Secrets are added to matching requests. Write-only: never returned.
	Secrets map[string]string
}

type Port struct {
	// Target is the port number in the sandbox.
	Target int

	// Name is the port's name.
	Name string

	// Protocol is the port's protocol. Empty uses the server's default.
	Protocol PortProtocol
}

type PortProtocol string

type ProcessCloseStdinOptions struct {
	// Identifier is the process's PID or name. Required.
	Identifier string
}

type ProcessExecEvent struct {
	// TextStream is which output Text came from.
	TextStream ProcessStream

	// Text is a chunk of output exactly as written: not split into lines,
	// so output such as a prompt arrives without waiting for a newline. It
	// may be empty when the sandbox sends an empty chunk. If the process
	// finished before streaming started, each line instead arrives as its
	// own event, without its newline.
	Text string

	// Exit is the process's final state, set on the last event only.
	Exit *ProcessInfo
}

type ProcessExecOptions struct {
	// Command is the shell command to run. Required.
	Command string

	// WorkingDir is the directory to run the command in. Empty uses the
	// sandbox's default.
	WorkingDir string

	// Env are environment variables for the process, on top of the
	// sandbox's own.
	Env map[string]string

	// Name names the process, so it can be referred to by name instead of
	// its PID.
	Name string

	// Timeout kills the process after this long, rounded up to whole
	// seconds. Zero means never.
	Timeout time.Duration

	// KeepAlive keeps the sandbox from going idle while the process runs.
	KeepAlive bool

	// RestartOnFailure restarts the process when it fails.
	RestartOnFailure bool

	// MaxRestarts is how many times the process is restarted on failure.
	MaxRestarts int

	// Stdin keeps the process's standard input open for writing.
	Stdin bool

	// WaitForPorts returns only once the process listens on these ports.
	WaitForPorts []int

	// WaitForCompletion returns only once the process has exited. When
	// false, the process keeps running in the background.
	WaitForCompletion bool
}

type ProcessExecStreamOptions struct {
	// Command is the shell command to run. Required.
	Command string

	// WorkingDir is the directory to run the command in. Empty uses the
	// sandbox's default.
	WorkingDir string

	// Env are environment variables for the process, on top of the
	// sandbox's own.
	Env map[string]string

	// Name names the process, so it can be referred to by name instead of
	// its PID.
	Name string

	// Timeout kills the process after this long, rounded up to whole
	// seconds. Zero means never.
	Timeout time.Duration

	// KeepAlive keeps the sandbox from going idle while the process runs.
	KeepAlive bool

	// RestartOnFailure restarts the process when it fails.
	RestartOnFailure bool

	// MaxRestarts is how many times the process is restarted on failure.
	MaxRestarts int

	// Stdin keeps the process's standard input open for writing.
	Stdin bool

	// WaitForPorts starts streaming only once the process listens on these
	// ports.
	WaitForPorts []int
}

type ProcessGetOptions struct {
	// Identifier is the process's PID or name. Required.
	Identifier string
}

type ProcessInfo struct {
	// PID is the process ID.
	PID string

	// Name is the process's name, if it was given one.
	Name string

	// Command is the command the process runs.
	Command string

	// Status is the process's status.
	Status ProcessStatus

	// ExitCode is the process's exit code, once it has exited.
	ExitCode int

	// Stdout is the process's standard output so far.
	Stdout string

	// Stderr is the process's standard error so far.
	Stderr string

	// Logs is the process's standard output and standard error so far,
	// interleaved.
	Logs string

	// WorkingDir is the directory the process runs in.
	WorkingDir string

	// StartedAt is when the process started.
	StartedAt time.Time

	// CompletedAt is when the process exited, zero while it runs.
	CompletedAt time.Time

	// KeepAlive is whether the process keeps the sandbox from going idle.
	KeepAlive bool

	// MaxRestarts is how many times the process is restarted on failure.
	MaxRestarts int

	// RestartCount is how many times the process has been restarted.
	RestartCount int

	// RestartOnFailure is whether the process is restarted when it fails.
	RestartOnFailure bool

	// Stdin is whether the process accepts standard input.
	Stdin bool
}

type ProcessKillOptions struct {
	// Identifier is the process's PID or name. Required.
	Identifier string
}

type ProcessListOptions struct{}

type ProcessLogLine struct {
	// TextStream is which output Text came from, empty when the sandbox did
	// not report it.
	TextStream ProcessStream

	// Text is the line, without its line ending. It may be empty, for an
	// empty line.
	Text string
}

type ProcessLogs struct {
	// Stdout is the process's standard output.
	Stdout string

	// Stderr is the process's standard error.
	Stderr string

	// Logs is the process's standard output and standard error,
	// interleaved.
	Logs string
}

type ProcessLogsOptions struct {
	// Identifier is the process's PID or name. Required.
	Identifier string
}

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

type ProcessStatus string

type ProcessStopOptions struct {
	// Identifier is the process's PID or name. Required.
	Identifier string
}

type ProcessStream string

type ProcessStreamLogsOptions struct {
	// Identifier is the process's PID or name. Required.
	Identifier string
}

type ProcessWaitOptions struct {
	// Identifier is the process's PID or name. Required.
	Identifier string

	// Timeout is how long to wait. Zero uses 60 seconds, and a negative
	// value waits with no limit. The process keeps running regardless.
	Timeout time.Duration

	// PollInterval is how often to check the process. Zero uses 1 second.
	PollInterval time.Duration
}

type ProcessWaitTimeoutError struct {
	// Identifier is the PID or name of the process waited on.
	Identifier string

	// Err is the last error seen while polling, nil when the last poll
	// succeeded.
	Err error
}

type ProcessWriteStdinOptions struct {
	// Identifier is the process's PID or name, which must have been started
	// with [ProcessExecOptions.Stdin]. Required.
	Identifier string

	// Data is written to the process's standard input as is. Include any
	// trailing newline the process expects.
	Data []byte
}

type RetryOptions struct {
	// ReadMaxRetries is the retry limit for reads on a dropped or reset
	// connection. Defaults to 5.
	ReadMaxRetries int

	// GatewayMaxRetries is the retry limit for 502, 503, and 504 responses
	// from the edge in front of a sandbox. Defaults to 2.
	GatewayMaxRetries int

	// UploadMaxRetries is the retry limit for uploads on a dropped or reset
	// connection. Defaults to 3.
	UploadMaxRetries int
}

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

type SandboxFromURLOptions struct {
	// URL is the base URL of the sandbox's execution API, as in [Info.URL].
	// Required.
	URL string
}

type Status string

type TokenProvider func(ctx context.Context, opts TokenProviderOptions) (string, error)

type TokenProviderOptions struct {
	// RevokedToken is a token the server just rejected as revoked, set when
	// the request is being sent again with a new one. Revocation can happen
	// well before a token's expiry, for example when any API key of the
	// token's user changes.
	RevokedToken string
}

type UpdateOptions struct {
	// Name is the sandbox's name. Required.
	Name string

	// Lifecycle replaces when the sandbox expires.
	Lifecycle *Lifecycle

	// Envs replace the sandbox's environment variables. Values returned
	// masked in [Info.Envs] overwrite the real values if sent back.
	Envs map[string]EnvValue

	// ExternalID is a caller-owned identifier for external lookups.
	ExternalID string

	// Labels replace the sandbox's labels.
	Labels map[string]string
}