modal

type AlreadyExistsError struct {
	Exception string
}

type App struct {
	AppID string
	Name  string
}

type AppFromNameParams struct {
	Environment     string
	CreateIfMissing bool
}

type AppService interface {
	FromName(ctx context.Context, name string, params *AppFromNameParams) (*App, error)
}

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

type Client struct {
	Apps              AppService
	CloudBucketMounts CloudBucketMountService
	Cls               ClsService
	Functions         FunctionService
	FunctionCalls     FunctionCallService
	Images            ImageService
	Proxies           ProxyService
	Queues            QueueService
	Sandboxes         SandboxService
	Secrets           SecretService
	Volumes           VolumeService
	// contains filtered or unexported fields
}

type ClientParams struct {
	TokenID     string
	TokenSecret string
	Environment string
	Config      *config
	Logger      *slog.Logger
	// ControlPlaneClient is a custom gRPC client for testing.
	// If provided, the client will use this instead of creating its own connection.
	// Typically used with mock clients in tests.
	ControlPlaneClient pb.ModalClientClient
	// ControlPlaneConn is the underlying gRPC connection for ControlPlaneClient.
	// If provided, Client.Close() will close this connection for proper cleanup.
	// Leave nil for mock clients that don't have real connections.
	ControlPlaneConn *grpc.ClientConn
	// GRPCUnaryInterceptors allows custom gRPC unary interceptors for telemetry, tracing, and observability.
	// These are appended after Modal's built-in interceptors (header injection, auth, retry, timeout).
	// Note that the Modal gRPC API is not considered a public API, and can change without warning.
	GRPCUnaryInterceptors []grpc.UnaryClientInterceptor
	// GRPCStreamInterceptors allows custom gRPC stream interceptors for telemetry, tracing, and observability.
	// These are appended after Modal's built-in stream interceptors (header injection).
	// Note that the Modal gRPC API is not considered a public API, and can change without warning.
	GRPCStreamInterceptors []grpc.StreamClientInterceptor
}

type CloudBucketMount struct {
	BucketName        string
	Secret            *Secret
	ReadOnly          bool
	RequesterPays     bool
	BucketEndpointURL *string
	KeyPrefix         *string
	OidcAuthRoleArn   *string
	// contains filtered or unexported fields
}

type CloudBucketMountParams struct {
	Secret            *Secret
	ReadOnly          bool
	RequesterPays     bool
	BucketEndpointURL *string
	KeyPrefix         *string
	OidcAuthRoleArn   *string
}

type CloudBucketMountService interface {
	New(bucketName string, params *CloudBucketMountParams) (*CloudBucketMount, error)
}

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

type ClsFromNameParams struct {
	Environment     string
	CreateIfMissing bool
}

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

type ClsService interface {
	FromName(ctx context.Context, appName string, name string, params *ClsFromNameParams) (*Cls, error)
}

type ClsWithBatchingParams struct {
	MaxBatchSize int
	Wait         time.Duration
}

type ClsWithConcurrencyParams struct {
	MaxInputs    int
	TargetInputs *int
}

type ClsWithOptionsParams struct {
	CPU              *float64
	CPULimit         *float64
	MemoryMiB        *int
	MemoryLimitMiB   *int
	GPU              *string
	Env              map[string]string
	Secrets          []*Secret
	Volumes          map[string]*Volume
	Retries          *Retries
	MaxContainers    *int
	BufferContainers *int
	ScaledownWindow  *time.Duration
	Timeout          *time.Duration
}

type ContainerProcess struct {
	Stdin  io.WriteCloser
	Stdout io.ReadCloser
	Stderr io.ReadCloser
	// contains filtered or unexported fields
}

type ExecutionError struct {
	Exception string
}

type Function struct {
	FunctionID string
	// contains filtered or unexported fields
}

type FunctionCall struct {
	FunctionCallID string
	// contains filtered or unexported fields
}

type FunctionCallCancelParams struct {
	TerminateContainers bool
}

type FunctionCallGetParams struct {
	// Timeout specifies the maximum duration to wait for the output.
	// If nil, no timeout is applied. If set to 0, it will check if the function
	// call is already completed.
	Timeout *time.Duration
}

type FunctionCallService interface {
	FromID(ctx context.Context, functionCallID string) (*FunctionCall, error)
}

type FunctionFromNameParams struct {
	Environment     string
	CreateIfMissing bool
}

type FunctionService interface {
	FromName(ctx context.Context, appName string, name string, params *FunctionFromNameParams) (*Function, error)
}

type FunctionStats struct {
	Backlog         int
	NumTotalRunners int
}

type FunctionTimeoutError struct {
	Exception string
}

type FunctionUpdateAutoscalerParams struct {
	MinContainers    *uint32
	MaxContainers    *uint32
	BufferContainers *uint32
	ScaledownWindow  *uint32
}

type Image struct {
	ImageID string
	// contains filtered or unexported fields
}

type ImageDeleteParams struct{}

type ImageDockerfileCommandsParams struct {
	// Environment variables to set in the build environment.
	Env map[string]string

	// Secrets that will be made available as environment variables to this layer's build environment.
	Secrets []*Secret

	// GPU reservation for this layer's build environment (e.g. "A100", "T4:2", "A100-80GB:4").
	GPU string

	// Ignore cached builds for this layer, similar to 'docker build --no-cache'.
	ForceBuild bool
}

type ImageFromRegistryParams struct {
	Secret *Secret // Secret for private registry authentication.
}

type ImageService interface {
	FromRegistry(tag string, params *ImageFromRegistryParams) *Image
	FromAwsEcr(tag string, secret *Secret) *Image
	FromGcpArtifactRegistry(tag string, secret *Secret) *Image
	FromID(ctx context.Context, imageID string) (*Image, error)
	Delete(ctx context.Context, imageID string, params *ImageDeleteParams) error
}

type InternalFailure struct {
	Exception string
}

type InvalidError struct {
	Exception string
}

type NotFoundError struct {
	Exception string
}

type Profile struct {
	ServerURL           string
	TokenID             string
	TokenSecret         string
	Environment         string
	ImageBuilderVersion string
	LogLevel            string
}

type Proxy struct {
	ProxyID string
}

type ProxyFromNameParams struct {
	Environment string
}

type ProxyService interface {
	FromName(ctx context.Context, name string, params *ProxyFromNameParams) (*Proxy, error)
}

type Queue struct {
	QueueID string
	Name    string
	// contains filtered or unexported fields
}

type QueueClearParams struct {
	Partition string // partition to clear (default "")
	All       bool   // clear *all* partitions (mutually exclusive with Partition)
}

type QueueDeleteParams struct {
	Environment  string
	AllowMissing bool
}

type QueueEmptyError struct {
	Exception string
}

type QueueEphemeralParams struct {
	Environment string
}

type QueueFromNameParams struct {
	Environment     string
	CreateIfMissing bool
}

type QueueFullError struct {
	Exception string
}

type QueueGetManyParams struct {
	QueueGetParams
}

type QueueGetParams struct {
	Timeout   *time.Duration // wait max (nil = indefinitely)
	Partition string
}

type QueueIterateParams struct {
	ItemPollTimeout time.Duration // exit if no new items within this period
	Partition       string
}

type QueueLenParams struct {
	Partition string
	Total     bool // total across all partitions (mutually exclusive with Partition)
}

type QueuePutManyParams struct {
	QueuePutParams
}

type QueuePutParams struct {
	Timeout      *time.Duration // max wait for space (nil = indefinitely)
	Partition    string
	PartitionTTL time.Duration // ttl for the *partition* (default 24h)
}

type QueueService interface {
	Ephemeral(ctx context.Context, params *QueueEphemeralParams) (*Queue, error)
	FromName(ctx context.Context, name string, params *QueueFromNameParams) (*Queue, error)
	Delete(ctx context.Context, name string, params *QueueDeleteParams) error
}

type RemoteError struct {
	Exception string
}

type Retries struct {
	MaxRetries         int
	BackoffCoefficient float32
	InitialDelay       time.Duration
	MaxDelay           time.Duration
}

type RetriesParams struct {
	BackoffCoefficient *float32       // Multiplier for exponential backoff. Defaults to 2.0.
	InitialDelay       *time.Duration // Defaults to 1s.
	MaxDelay           *time.Duration // Defaults to 60s.
}

type Sandbox struct {
	SandboxID string
	Stdin     io.WriteCloser
	Stdout    io.ReadCloser
	Stderr    io.ReadCloser
	// contains filtered or unexported fields
}

type SandboxCreateConnectCredentials struct {
	URL   string
	Token string
}

type SandboxCreateConnectTokenParams struct {
	// Optional user-provided metadata string that will be added to the headers by the proxy when forwarding requests to the Sandbox.
	UserMetadata string
}

type SandboxCreateParams struct {
	CPU                 float64                      // CPU request in fractional, physical cores.
	CPULimit            float64                      // Hard limit in fractional, physical CPU cores. Zero means no limit.
	MemoryMiB           int                          // Memory request in MiB.
	MemoryLimitMiB      int                          // Hard memory limit in MiB. Zero means no limit.
	GPU                 string                       // GPU reservation for the Sandbox (e.g. "A100", "T4:2", "A100-80GB:4").
	Timeout             time.Duration                // Maximum lifetime of the Sandbox. Defaults to 5 minutes. If you pass zero you get the default 5 minutes.
	IdleTimeout         time.Duration                // The amount of time that a Sandbox can be idle before being terminated.
	Workdir             string                       // Working directory of the Sandbox.
	Command             []string                     // Command to run in the Sandbox on startup.
	Env                 map[string]string            // Environment variables to set in the Sandbox.
	Secrets             []*Secret                    // Secrets to inject into the Sandbox as environment variables.
	Volumes             map[string]*Volume           // Mount points for Volumes.
	CloudBucketMounts   map[string]*CloudBucketMount // Mount points for cloud buckets.
	PTY                 bool                         // Enable a PTY for the Sandbox.
	EncryptedPorts      []int                        // List of encrypted ports to tunnel into the Sandbox, with TLS encryption.
	H2Ports             []int                        // List of encrypted ports to tunnel into the Sandbox, using HTTP/2.
	UnencryptedPorts    []int                        // List of ports to tunnel into the Sandbox without encryption.
	BlockNetwork        bool                         // Whether to block all network access from the Sandbox.
	CIDRAllowlist       []string                     // List of CIDRs the Sandbox is allowed to access. Cannot be used with BlockNetwork.
	Cloud               string                       // Cloud provider to run the Sandbox on.
	Regions             []string                     // Region(s) to run the Sandbox on.
	Verbose             bool                         // Enable verbose logging.
	Proxy               *Proxy                       // Reference to a Modal Proxy to use in front of this Sandbox.
	Name                string                       // Optional name for the Sandbox. Unique within an App.
	ExperimentalOptions map[string]any               // Experimental options
}

type SandboxExecParams struct {
	// Stdout defines whether to pipe or ignore standard output.
	Stdout StdioBehavior
	// Stderr defines whether to pipe or ignore standard error.
	Stderr StdioBehavior
	// Workdir is the working directory to run the command in.
	Workdir string
	// Timeout is the timeout for command execution. Defaults to 0 (no timeout).
	Timeout time.Duration
	// Environment variables to set for the command.
	Env map[string]string
	// Secrets to inject as environment variables for the command.
	Secrets []*Secret
	// PTY defines whether to enable a PTY for the command.
	PTY bool
}

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

type SandboxFilesystemError struct {
	Exception string
}

type SandboxFromNameParams struct {
	Environment string
}

type SandboxListParams struct {
	AppID       string            // Filter by App ID
	Tags        map[string]string // Only include Sandboxes that have all these tags
	Environment string            // Override environment for this request
}

type SandboxService interface {
	Create(ctx context.Context, app *App, image *Image, params *SandboxCreateParams) (*Sandbox, error)
	FromID(ctx context.Context, sandboxID string) (*Sandbox, error)
	FromName(ctx context.Context, appName, name string, params *SandboxFromNameParams) (*Sandbox, error)
	List(ctx context.Context, params *SandboxListParams) (iter.Seq2[*Sandbox, error], error)
}

type SandboxTimeoutError struct {
	Exception string
}

type Secret struct {
	SecretID string
	Name     string
}

type SecretDeleteParams struct {
	Environment  string
	AllowMissing bool
}

type SecretFromMapParams struct {
	Environment string
}

type SecretFromNameParams struct {
	Environment  string
	RequiredKeys []string
}

type SecretService interface {
	FromName(ctx context.Context, name string, params *SecretFromNameParams) (*Secret, error)
	FromMap(ctx context.Context, keyValuePairs map[string]string, params *SecretFromMapParams) (*Secret, error)
	Delete(ctx context.Context, name string, params *SecretDeleteParams) error
}

type StdioBehavior string

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

type Tunnel struct {
	Host            string // The public hostname for the tunnel
	Port            int    // The public port for the tunnel
	UnencryptedHost string // The unencrypted hostname (if applicable)
	UnencryptedPort int    // The unencrypted port (if applicable)
}

type Volume struct {
	VolumeID string
	Name     string
	// contains filtered or unexported fields
}

type VolumeDeleteParams struct {
	Environment  string
	AllowMissing bool
}

type VolumeEphemeralParams struct {
	Environment string
}

type VolumeFromNameParams struct {
	Environment     string
	CreateIfMissing bool
}

type VolumeService interface {
	FromName(ctx context.Context, name string, params *VolumeFromNameParams) (*Volume, error)
	Ephemeral(ctx context.Context, params *VolumeEphemeralParams) (*Volume, error)
	Delete(ctx context.Context, name string, params *VolumeDeleteParams) error
}