import { Client, Status, ClientMiddleware } from 'nice-grpc';
import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';

/**
 * A generic empty message that you can re-use to avoid defining duplicated
 * empty messages in your APIs. A typical example is to use it as the request
 * or the response type of an API method. For instance:
 *
 *     service Foo {
 *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
 *     }
 *
 * The JSON representation for `Empty` is empty JSON object `{}`.
 */
interface Empty {
}
declare const Empty: MessageFns$2<Empty>;
type Builtin$2 = Date | Function | Uint8Array | string | number | boolean | undefined;
type DeepPartial$2<T> = T extends Builtin$2 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$2<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$2<U>> : T extends {} ? {
    [K in keyof T]?: DeepPartial$2<T[K]>;
} : Partial<T>;
interface MessageFns$2<T> {
    encode(message: T, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): T;
    fromJSON(object: any): T;
    toJSON(message: T): unknown;
    create(base?: DeepPartial$2<T>): T;
    fromPartial(object: DeepPartial$2<T>): T;
}

declare enum AppDeployVisibility {
    APP_DEPLOY_VISIBILITY_UNSPECIFIED = 0,
    APP_DEPLOY_VISIBILITY_WORKSPACE = 1,
    APP_DEPLOY_VISIBILITY_PUBLIC = 2,
    UNRECOGNIZED = -1
}
declare enum AppDisconnectReason {
    APP_DISCONNECT_REASON_UNSPECIFIED = 0,
    APP_DISCONNECT_REASON_LOCAL_EXCEPTION = 1,
    APP_DISCONNECT_REASON_KEYBOARD_INTERRUPT = 2,
    APP_DISCONNECT_REASON_ENTRYPOINT_COMPLETED = 3,
    APP_DISCONNECT_REASON_DEPLOYMENT_EXCEPTION = 4,
    APP_DISCONNECT_REASON_REMOTE_EXCEPTION = 5,
    UNRECOGNIZED = -1
}
/**
 * NOTE: make sure to update the frontend if we add a new state here
 * https://github.com/modal-labs/modal/blob/main/frontend/src/routes/(dashboard)/%5B%5Bworkspace%5D%5D/apps/+page.svelte#L95
 */
declare enum AppState {
    APP_STATE_UNSPECIFIED = 0,
    /** APP_STATE_EPHEMERAL - Will be discharged when the client disconnects */
    APP_STATE_EPHEMERAL = 1,
    APP_STATE_DETACHED = 2,
    /** APP_STATE_DEPLOYED - Will be discharged when overwritten */
    APP_STATE_DEPLOYED = 3,
    /** APP_STATE_STOPPING - Winding down app due to user termination. */
    APP_STATE_STOPPING = 4,
    /** APP_STATE_STOPPED - Stopped */
    APP_STATE_STOPPED = 5,
    /** APP_STATE_INITIALIZING - App is created and in process of deployment. */
    APP_STATE_INITIALIZING = 6,
    /** APP_STATE_DISABLED - Same as stopped but prevented from being garbage collected */
    APP_STATE_DISABLED = 7,
    /** APP_STATE_DETACHED_DISCONNECTED - App is detached and local client has disconnected. */
    APP_STATE_DETACHED_DISCONNECTED = 8,
    /**
     * APP_STATE_DERIVED - App is derived from another workspace. Acts as a static, immutable group of functions.
     *
     * @deprecated
     */
    APP_STATE_DERIVED = 9,
    UNRECOGNIZED = -1
}
declare enum AppStopSource {
    APP_STOP_SOURCE_UNSPECIFIED = 0,
    APP_STOP_SOURCE_CLI = 1,
    APP_STOP_SOURCE_PYTHON_CLIENT = 2,
    APP_STOP_SOURCE_WEB = 3,
    UNRECOGNIZED = -1
}
declare enum CertificateStatus {
    CERTIFICATE_STATUS_PENDING = 0,
    CERTIFICATE_STATUS_ISSUED = 1,
    CERTIFICATE_STATUS_FAILED = 2,
    CERTIFICATE_STATUS_REVOKED = 3,
    UNRECOGNIZED = -1
}
declare enum CheckpointStatus {
    CHECKPOINT_STATUS_UNSPECIFIED = 0,
    CHECKPOINT_STATUS_PENDING = 1,
    CHECKPOINT_STATUS_PROCESSING = 2,
    CHECKPOINT_STATUS_READY = 3,
    CHECKPOINT_STATUS_FAILED = 4,
    UNRECOGNIZED = -1
}
declare enum CloudProvider {
    CLOUD_PROVIDER_UNSPECIFIED = 0,
    CLOUD_PROVIDER_AWS = 1,
    CLOUD_PROVIDER_GCP = 2,
    CLOUD_PROVIDER_AUTO = 3,
    CLOUD_PROVIDER_OCI = 4,
    UNRECOGNIZED = -1
}
declare enum DNSRecordType {
    DNS_RECORD_TYPE_A = 0,
    DNS_RECORD_TYPE_TXT = 1,
    DNS_RECORD_TYPE_CNAME = 2,
    UNRECOGNIZED = -1
}
/** Which data format a binary message is encoded with. */
declare enum DataFormat {
    DATA_FORMAT_UNSPECIFIED = 0,
    /** DATA_FORMAT_PICKLE - Cloudpickle */
    DATA_FORMAT_PICKLE = 1,
    /** DATA_FORMAT_ASGI - "Asgi" protobuf message */
    DATA_FORMAT_ASGI = 2,
    /** DATA_FORMAT_GENERATOR_DONE - "GeneratorDone" protobuf message */
    DATA_FORMAT_GENERATOR_DONE = 3,
    DATA_FORMAT_CBOR = 4,
    UNRECOGNIZED = -1
}
declare enum DeploymentNamespace {
    DEPLOYMENT_NAMESPACE_UNSPECIFIED = 0,
    DEPLOYMENT_NAMESPACE_WORKSPACE = 1,
    DEPLOYMENT_NAMESPACE_GLOBAL = 3,
    UNRECOGNIZED = -1
}
declare enum EndpointApiSurface {
    ENDPOINT_API_SURFACE_UNSPECIFIED = 0,
    ENDPOINT_API_SURFACE_OPENAI_CHAT_COMPLETIONS = 1,
    ENDPOINT_API_SURFACE_OPENAI_RESPONSES = 2,
    ENDPOINT_API_SURFACE_ANTHROPIC_MESSAGES = 3,
    UNRECOGNIZED = -1
}
declare enum EndpointInputModality {
    ENDPOINT_INPUT_MODALITY_UNSPECIFIED = 0,
    ENDPOINT_INPUT_MODALITY_TEXT = 1,
    ENDPOINT_INPUT_MODALITY_IMAGE = 2,
    ENDPOINT_INPUT_MODALITY_AUDIO = 3,
    UNRECOGNIZED = -1
}
declare enum EndpointProvisioningStatus {
    ENDPOINT_PROVISIONING_STATUS_UNSPECIFIED = 0,
    ENDPOINT_PROVISIONING_STATUS_PENDING = 1,
    ENDPOINT_PROVISIONING_STATUS_RUNNING = 2,
    ENDPOINT_PROVISIONING_STATUS_SUCCEEDED = 3,
    ENDPOINT_PROVISIONING_STATUS_FAILED = 4,
    UNRECOGNIZED = -1
}
declare enum EndpointStopSource {
    ENDPOINT_STOP_SOURCE_UNSPECIFIED = 0,
    ENDPOINT_STOP_SOURCE_CLI = 1,
    ENDPOINT_STOP_SOURCE_WEB = 2,
    UNRECOGNIZED = -1
}
declare enum EnvironmentRole {
    ENVIRONMENT_ROLE_UNSPECIFIED = 0,
    ENVIRONMENT_ROLE_VIEWER = 1,
    ENVIRONMENT_ROLE_CONTRIBUTOR = 2,
    UNRECOGNIZED = -1
}
declare enum ExecOutputOption {
    EXEC_OUTPUT_OPTION_UNSPECIFIED = 0,
    EXEC_OUTPUT_OPTION_DEVNULL = 1,
    EXEC_OUTPUT_OPTION_PIPE = 2,
    EXEC_OUTPUT_OPTION_STDOUT = 3,
    UNRECOGNIZED = -1
}
declare enum FileDescriptor {
    FILE_DESCRIPTOR_UNSPECIFIED = 0,
    FILE_DESCRIPTOR_STDOUT = 1,
    FILE_DESCRIPTOR_STDERR = 2,
    FILE_DESCRIPTOR_INFO = 3,
    UNRECOGNIZED = -1
}
declare enum FunctionCallInvocationType {
    FUNCTION_CALL_INVOCATION_TYPE_UNSPECIFIED = 0,
    FUNCTION_CALL_INVOCATION_TYPE_SYNC_LEGACY = 1,
    FUNCTION_CALL_INVOCATION_TYPE_ASYNC_LEGACY = 2,
    FUNCTION_CALL_INVOCATION_TYPE_ASYNC = 3,
    FUNCTION_CALL_INVOCATION_TYPE_SYNC = 4,
    UNRECOGNIZED = -1
}
declare enum FunctionCallType {
    FUNCTION_CALL_TYPE_UNSPECIFIED = 0,
    FUNCTION_CALL_TYPE_UNARY = 1,
    FUNCTION_CALL_TYPE_MAP = 2,
    UNRECOGNIZED = -1
}
declare enum GPUType {
    /**
     * GPU_TYPE_UNSPECIFIED - Note: this enum is no longer used by current clients - don't add new types
     * Old clients still send it, so we use it server-side for compatibility
     */
    GPU_TYPE_UNSPECIFIED = 0,
    GPU_TYPE_T4 = 1,
    GPU_TYPE_A100 = 2,
    GPU_TYPE_A10G = 3,
    GPU_TYPE_ANY = 4,
    GPU_TYPE_A100_80GB = 8,
    GPU_TYPE_L4 = 9,
    GPU_TYPE_H100 = 10,
    GPU_TYPE_L40S = 11,
    GPU_TYPE_H200 = 12,
    UNRECOGNIZED = -1
}
declare enum IdentityProviderType {
    IDENTITY_PROVIDER_TYPE_UNSPECIFIED = 0,
    IDENTITY_PROVIDER_TYPE_GITHUB = 1,
    IDENTITY_PROVIDER_TYPE_OKTA = 2,
    IDENTITY_PROVIDER_TYPE_GOOGLE_OAUTH = 3,
    UNRECOGNIZED = -1
}
declare enum MemberRole {
    MEMBER_ROLE_UNSPECIFIED = 0,
    MEMBER_ROLE_USER = 1,
    MEMBER_ROLE_MANAGER = 2,
    MEMBER_ROLE_OWNER = 3,
    UNRECOGNIZED = -1
}
declare enum ObjectCreationType {
    /** OBJECT_CREATION_TYPE_UNSPECIFIED - just lookup */
    OBJECT_CREATION_TYPE_UNSPECIFIED = 0,
    OBJECT_CREATION_TYPE_CREATE_IF_MISSING = 1,
    OBJECT_CREATION_TYPE_CREATE_FAIL_IF_EXISTS = 2,
    OBJECT_CREATION_TYPE_CREATE_OVERWRITE_IF_EXISTS = 3,
    /** OBJECT_CREATION_TYPE_ANONYMOUS_OWNED_BY_APP - deprecate at some point */
    OBJECT_CREATION_TYPE_ANONYMOUS_OWNED_BY_APP = 4,
    OBJECT_CREATION_TYPE_EPHEMERAL = 5,
    UNRECOGNIZED = -1
}
declare enum ParameterType {
    PARAM_TYPE_UNSPECIFIED = 0,
    PARAM_TYPE_STRING = 1,
    PARAM_TYPE_INT = 2,
    /** PARAM_TYPE_PICKLE - currently unused */
    PARAM_TYPE_PICKLE = 3,
    PARAM_TYPE_BYTES = 4,
    /** PARAM_TYPE_UNKNOWN - used in schemas to signify unrecognized or un-annotated types */
    PARAM_TYPE_UNKNOWN = 5,
    PARAM_TYPE_LIST = 6,
    PARAM_TYPE_DICT = 7,
    PARAM_TYPE_NONE = 8,
    PARAM_TYPE_BOOL = 9,
    UNRECOGNIZED = -1
}
declare enum ProgressType {
    /** IMAGE_SNAPSHOT_UPLOAD - TODO(erikbern): shouldn't be zero, and needs prefix */
    IMAGE_SNAPSHOT_UPLOAD = 0,
    /** FUNCTION_QUEUED - TODO(erikbern): needs_prefix */
    FUNCTION_QUEUED = 1,
    UNRECOGNIZED = -1
}
declare enum ProxyIpStatus {
    PROXY_IP_STATUS_UNSPECIFIED = 0,
    PROXY_IP_STATUS_CREATING = 1,
    PROXY_IP_STATUS_ONLINE = 2,
    PROXY_IP_STATUS_TERMINATED = 3,
    PROXY_IP_STATUS_UNHEALTHY = 4,
    UNRECOGNIZED = -1
}
declare enum RateLimitInterval {
    RATE_LIMIT_INTERVAL_UNSPECIFIED = 0,
    RATE_LIMIT_INTERVAL_SECOND = 1,
    RATE_LIMIT_INTERVAL_MINUTE = 2,
    UNRECOGNIZED = -1
}
declare enum RegistryAuthType {
    /** REGISTRY_AUTH_TYPE_UNSPECIFIED - Older clients send this instead of "public". */
    REGISTRY_AUTH_TYPE_UNSPECIFIED = 0,
    REGISTRY_AUTH_TYPE_AWS = 1,
    REGISTRY_AUTH_TYPE_GCP = 2,
    REGISTRY_AUTH_TYPE_PUBLIC = 3,
    REGISTRY_AUTH_TYPE_STATIC_CREDS = 4,
    UNRECOGNIZED = -1
}
declare enum SeekWhence {
    SEEK_SET = 0,
    SEEK_CUR = 1,
    SEEK_END = 2,
    UNRECOGNIZED = -1
}
declare enum SystemErrorCode {
    SYSTEM_ERROR_CODE_UNSPECIFIED = 0,
    /** SYSTEM_ERROR_CODE_PERM - EPERM: Operation not permitted */
    SYSTEM_ERROR_CODE_PERM = 1,
    /** SYSTEM_ERROR_CODE_NOENT - ENOENT: No such file or directory */
    SYSTEM_ERROR_CODE_NOENT = 2,
    /** SYSTEM_ERROR_CODE_IO - EIO: Input/output error */
    SYSTEM_ERROR_CODE_IO = 5,
    /** SYSTEM_ERROR_CODE_NXIO - ENXIO: No such device or address */
    SYSTEM_ERROR_CODE_NXIO = 6,
    /** SYSTEM_ERROR_CODE_NOMEM - ENOMEM: Out of memory */
    SYSTEM_ERROR_CODE_NOMEM = 12,
    /** SYSTEM_ERROR_CODE_ACCES - EACCES: Permission denied */
    SYSTEM_ERROR_CODE_ACCES = 13,
    /** SYSTEM_ERROR_CODE_EXIST - EEXIST: File exists */
    SYSTEM_ERROR_CODE_EXIST = 17,
    /** SYSTEM_ERROR_CODE_NOTDIR - ENOTDIR: Not a directory */
    SYSTEM_ERROR_CODE_NOTDIR = 20,
    /** SYSTEM_ERROR_CODE_ISDIR - EISDIR: Is a directory */
    SYSTEM_ERROR_CODE_ISDIR = 21,
    /** SYSTEM_ERROR_CODE_INVAL - EINVAL: Invalid argument */
    SYSTEM_ERROR_CODE_INVAL = 22,
    /** SYSTEM_ERROR_CODE_MFILE - EMFILE: Too many open files */
    SYSTEM_ERROR_CODE_MFILE = 24,
    /** SYSTEM_ERROR_CODE_FBIG - EFBIG: File too large */
    SYSTEM_ERROR_CODE_FBIG = 27,
    /** SYSTEM_ERROR_CODE_NOSPC - ENOSPC: No space left on device */
    SYSTEM_ERROR_CODE_NOSPC = 28,
    UNRECOGNIZED = -1
}
declare enum TaskSnapshotBehavior {
    TASK_SNAPSHOT_BEHAVIOR_UNSPECIFIED = 0,
    TASK_SNAPSHOT_BEHAVIOR_SNAPSHOT = 1,
    TASK_SNAPSHOT_BEHAVIOR_RESTORE = 2,
    TASK_SNAPSHOT_BEHAVIOR_NONE = 3,
    UNRECOGNIZED = -1
}
declare enum TaskState {
    TASK_STATE_UNSPECIFIED = 0,
    TASK_STATE_CREATED = 6,
    TASK_STATE_QUEUED = 1,
    TASK_STATE_WORKER_ASSIGNED = 2,
    TASK_STATE_LOADING_IMAGE = 3,
    TASK_STATE_ACTIVE = 4,
    TASK_STATE_COMPLETED = 5,
    TASK_STATE_CREATING_CONTAINER = 7,
    TASK_STATE_IDLE = 8,
    TASK_STATE_PREEMPTIBLE = 9,
    TASK_STATE_PREEMPTED = 10,
    TASK_STATE_LOADING_CHECKPOINT_IMAGE = 11,
    UNRECOGNIZED = -1
}
declare enum TunnelType {
    TUNNEL_TYPE_UNSPECIFIED = 0,
    /** TUNNEL_TYPE_H2 - HTTP/2 tunnel */
    TUNNEL_TYPE_H2 = 1,
    UNRECOGNIZED = -1
}
declare enum VolumeFsVersion {
    VOLUME_FS_VERSION_UNSPECIFIED = 0,
    VOLUME_FS_VERSION_V1 = 1,
    VOLUME_FS_VERSION_V2 = 2,
    UNRECOGNIZED = -1
}
declare enum WebhookAsyncMode {
    WEBHOOK_ASYNC_MODE_UNSPECIFIED = 0,
    /** WEBHOOK_ASYNC_MODE_DISABLED - No longer used by client */
    WEBHOOK_ASYNC_MODE_DISABLED = 2,
    /** WEBHOOK_ASYNC_MODE_TRIGGER - No longer used by client (previously used when wait_for_response=False) */
    WEBHOOK_ASYNC_MODE_TRIGGER = 3,
    /** WEBHOOK_ASYNC_MODE_AUTO - The default */
    WEBHOOK_ASYNC_MODE_AUTO = 4,
    UNRECOGNIZED = -1
}
declare enum WebhookType {
    WEBHOOK_TYPE_UNSPECIFIED = 0,
    WEBHOOK_TYPE_ASGI_APP = 1,
    WEBHOOK_TYPE_FUNCTION = 2,
    WEBHOOK_TYPE_WSGI_APP = 3,
    WEBHOOK_TYPE_WEB_SERVER = 4,
    UNRECOGNIZED = -1
}
declare enum ClassParameterInfo_ParameterSerializationFormat {
    PARAM_SERIALIZATION_FORMAT_UNSPECIFIED = 0,
    /** PARAM_SERIALIZATION_FORMAT_PICKLE - legacy format - pickle of (args, kwargs) tuple */
    PARAM_SERIALIZATION_FORMAT_PICKLE = 1,
    /** PARAM_SERIALIZATION_FORMAT_PROTO - new format using api.FunctionParameterSet */
    PARAM_SERIALIZATION_FORMAT_PROTO = 2,
    UNRECOGNIZED = -1
}
declare enum CloudBucketMount_BucketType {
    UNSPECIFIED = 0,
    S3 = 1,
    R2 = 2,
    GCP = 3,
    UNRECOGNIZED = -1
}
declare enum CloudBucketMount_MetadataTTLType {
    METADATA_TTL_TYPE_UNSPECIFIED = 0,
    METADATA_TTL_TYPE_MINIMAL = 1,
    METADATA_TTL_TYPE_INDEFINITE = 2,
    UNRECOGNIZED = -1
}
declare enum FileEntry_FileType {
    UNSPECIFIED = 0,
    FILE = 1,
    DIRECTORY = 2,
    SYMLINK = 3,
    FIFO = 4,
    SOCKET = 5,
    UNRECOGNIZED = -1
}
declare enum Function_DefinitionType {
    DEFINITION_TYPE_UNSPECIFIED = 0,
    DEFINITION_TYPE_SERIALIZED = 1,
    DEFINITION_TYPE_FILE = 2,
    UNRECOGNIZED = -1
}
declare enum Function_FunctionType {
    FUNCTION_TYPE_UNSPECIFIED = 0,
    FUNCTION_TYPE_GENERATOR = 1,
    FUNCTION_TYPE_FUNCTION = 2,
    UNRECOGNIZED = -1
}
declare enum FunctionSchema_FunctionSchemaType {
    FUNCTION_SCHEMA_UNSPECIFIED = 0,
    FUNCTION_SCHEMA_V1 = 1,
    UNRECOGNIZED = -1
}
declare enum GenericResult_GenericStatus {
    GENERIC_STATUS_UNSPECIFIED = 0,
    GENERIC_STATUS_SUCCESS = 1,
    GENERIC_STATUS_FAILURE = 2,
    /** GENERIC_STATUS_TERMINATED - Used when a task was killed using an external signal. */
    GENERIC_STATUS_TERMINATED = 3,
    GENERIC_STATUS_TIMEOUT = 4,
    /**
     * GENERIC_STATUS_INIT_FAILURE - Used when the user's function fails to initialize (ex. S3 mount failed due to invalid credentials).
     * Terminates the function and all remaining inputs.
     */
    GENERIC_STATUS_INIT_FAILURE = 5,
    GENERIC_STATUS_INTERNAL_FAILURE = 6,
    /** GENERIC_STATUS_IDLE_TIMEOUT - Used when sandboxes are terminated due to idle_timeout */
    GENERIC_STATUS_IDLE_TIMEOUT = 7,
    UNRECOGNIZED = -1
}
declare enum NetworkAccess_NetworkAccessType {
    UNSPECIFIED = 0,
    OPEN = 1,
    BLOCKED = 2,
    ALLOWLIST = 3,
    UNRECOGNIZED = -1
}
declare enum PTYInfo_PTYType {
    /** PTY_TYPE_UNSPECIFIED - Nothing */
    PTY_TYPE_UNSPECIFIED = 0,
    /** PTY_TYPE_FUNCTION - Run function in PTY */
    PTY_TYPE_FUNCTION = 1,
    /** PTY_TYPE_SHELL - Replace function with shell */
    PTY_TYPE_SHELL = 2,
    UNRECOGNIZED = -1
}
declare enum SandboxRestoreRequest_SandboxNameOverrideType {
    SANDBOX_NAME_OVERRIDE_TYPE_UNSPECIFIED = 0,
    SANDBOX_NAME_OVERRIDE_TYPE_NONE = 1,
    SANDBOX_NAME_OVERRIDE_TYPE_STRING = 2,
    UNRECOGNIZED = -1
}
declare enum Warning_WarningType {
    WARNING_TYPE_UNSPECIFIED = 0,
    WARNING_TYPE_CLIENT_DEPRECATION = 1,
    WARNING_TYPE_RESOURCE_LIMIT = 2,
    WARNING_TYPE_FUNCTION_CONFIGURATION = 3,
    UNRECOGNIZED = -1
}
interface AppClientDisconnectRequest {
    appId: string;
    reason: AppDisconnectReason;
    exception: string;
}
declare const AppClientDisconnectRequest: MessageFns$1<AppClientDisconnectRequest>;
interface AppCountLogsRequest {
    appId: string;
    taskId: string;
    functionId: string;
    functionCallId: string;
    sandboxId: string;
    searchText: string;
    since: Date | undefined;
    until: Date | undefined;
    bucketSecs: number;
    source: FileDescriptor;
}
declare const AppCountLogsRequest: MessageFns$1<AppCountLogsRequest>;
interface AppCountLogsResponse {
    appId: string;
    buckets: AppCountLogsResponse_LogBucket[];
}
declare const AppCountLogsResponse: MessageFns$1<AppCountLogsResponse>;
interface AppCountLogsResponse_LogBucket {
    bucketStartAt: Date | undefined;
    stdoutLogs: number;
    stderrLogs: number;
    systemLogs: number;
}
declare const AppCountLogsResponse_LogBucket: MessageFns$1<AppCountLogsResponse_LogBucket>;
interface AppCreateRequest {
    clientId: string;
    /** Human readable label for the app */
    description: string;
    environmentName: string;
    appState: AppState;
    /** Additional metadata to attach to the App */
    tags: {
        [key: string]: string;
    };
}
declare const AppCreateRequest: MessageFns$1<AppCreateRequest>;
interface AppCreateResponse {
    appId: string;
    appPageUrl: string;
    appLogsUrl: string;
}
declare const AppCreateResponse: MessageFns$1<AppCreateResponse>;
interface AppDeployRequest {
    appId: string;
    name: string;
    objectEntity: string;
    visibility: AppDeployVisibility;
    tag: string;
}
declare const AppDeployRequest: MessageFns$1<AppDeployRequest>;
interface AppDeployResponse {
    url: string;
}
declare const AppDeployResponse: MessageFns$1<AppDeployResponse>;
interface AppDeploymentHistory {
    appId: string;
    version: number;
    clientVersion: string;
    deployedAt: number;
    deployedBy: string;
    deployedByAvatarUrl: string;
    tag: string;
    rollbackVersion: number;
    rollbackAllowed: boolean;
    commitInfo?: CommitInfo | undefined;
}
declare const AppDeploymentHistory: MessageFns$1<AppDeploymentHistory>;
interface AppDeploymentHistoryRequest {
    appId: string;
}
declare const AppDeploymentHistoryRequest: MessageFns$1<AppDeploymentHistoryRequest>;
interface AppDeploymentHistoryResponse {
    appDeploymentHistories: AppDeploymentHistory[];
}
declare const AppDeploymentHistoryResponse: MessageFns$1<AppDeploymentHistoryResponse>;
interface AppFetchLogsRequest {
    appId: string;
    since: Date | undefined;
    until: Date | undefined;
    limit: number;
    source: FileDescriptor;
    functionId: string;
    functionCallId: string;
    taskId: string;
    sandboxId: string;
    searchText: string;
}
declare const AppFetchLogsRequest: MessageFns$1<AppFetchLogsRequest>;
interface AppFetchLogsResponse {
    batches: TaskLogsBatch[];
}
declare const AppFetchLogsResponse: MessageFns$1<AppFetchLogsResponse>;
interface AppGetByDeploymentNameRequest {
    name: string;
    environmentName: string;
}
declare const AppGetByDeploymentNameRequest: MessageFns$1<AppGetByDeploymentNameRequest>;
interface AppGetByDeploymentNameResponse {
    /** Null when App with requested name is not deployed */
    appId: string;
    /** Populated if App with requested name was recently stopped */
    previousAppId: string;
    /** Populated because server may resolve default environment */
    environmentName: string;
    /** Lifecycle of current App or recently stopped App */
    lifecycle: AppLifecycle | undefined;
}
declare const AppGetByDeploymentNameResponse: MessageFns$1<AppGetByDeploymentNameResponse>;
interface AppGetLayoutRequest {
    appId: string;
}
declare const AppGetLayoutRequest: MessageFns$1<AppGetLayoutRequest>;
interface AppGetLayoutResponse {
    appLayout: AppLayout | undefined;
}
declare const AppGetLayoutResponse: MessageFns$1<AppGetLayoutResponse>;
interface AppGetLifecycleRequest {
    appId: string;
}
declare const AppGetLifecycleRequest: MessageFns$1<AppGetLifecycleRequest>;
interface AppGetLifecycleResponse {
    lifecycle: AppLifecycle | undefined;
}
declare const AppGetLifecycleResponse: MessageFns$1<AppGetLifecycleResponse>;
interface AppGetLogsRequest {
    appId: string;
    timeout: number;
    lastEntryId: string;
    functionId: string;
    parametrizedFunctionId: string;
    inputId: string;
    taskId: string;
    functionCallId: string;
    fileDescriptor: FileDescriptor;
    sandboxId: string;
    searchText: string;
}
declare const AppGetLogsRequest: MessageFns$1<AppGetLogsRequest>;
interface AppGetObjectsItem {
    tag: string;
    object: Object_ | undefined;
}
declare const AppGetObjectsItem: MessageFns$1<AppGetObjectsItem>;
interface AppGetObjectsRequest {
    appId: string;
    includeUnindexed: boolean;
    /** True starting with 0.67.x clients, which don't create method placeholder functions */
    onlyClassFunction: boolean;
}
declare const AppGetObjectsRequest: MessageFns$1<AppGetObjectsRequest>;
interface AppGetObjectsResponse {
    items: AppGetObjectsItem[];
}
declare const AppGetObjectsResponse: MessageFns$1<AppGetObjectsResponse>;
interface AppGetOrCreateRequest {
    appName: string;
    environmentName: string;
    objectCreationType: ObjectCreationType;
}
declare const AppGetOrCreateRequest: MessageFns$1<AppGetOrCreateRequest>;
interface AppGetOrCreateResponse {
    appId: string;
}
declare const AppGetOrCreateResponse: MessageFns$1<AppGetOrCreateResponse>;
interface AppGetTagsRequest {
    appId: string;
}
declare const AppGetTagsRequest: MessageFns$1<AppGetTagsRequest>;
interface AppGetTagsResponse {
    tags: {
        [key: string]: string;
    };
}
declare const AppGetTagsResponse: MessageFns$1<AppGetTagsResponse>;
interface AppHeartbeatRequest {
    appId: string;
}
declare const AppHeartbeatRequest: MessageFns$1<AppHeartbeatRequest>;
interface AppLayout {
    objects: Object_[];
    /** tag -> function id */
    functionIds: {
        [key: string]: string;
    };
    /** tag -> class id */
    classIds: {
        [key: string]: string;
    };
}
declare const AppLayout: MessageFns$1<AppLayout>;
interface AppLifecycle {
    appState: AppState;
    createdAt: number;
    /** User or service user name */
    createdBy: string;
    /** Most recent deployment event */
    deployedAt: number;
    /** User or service user name */
    deployedBy: string;
    /** Only meaningful when App is deployed */
    version: number;
    /** Unset when App is still running */
    stoppedAt: number;
    /** User or service user name, null if running or ephemeral App that finished normally */
    stoppedBy: string;
}
declare const AppLifecycle: MessageFns$1<AppLifecycle>;
interface AppListRequest {
    environmentName: string;
}
declare const AppListRequest: MessageFns$1<AppListRequest>;
interface AppListResponse {
    apps: AppListResponse_AppListItem[];
}
declare const AppListResponse: MessageFns$1<AppListResponse>;
interface AppListResponse_AppListItem {
    appId: string;
    description: string;
    state: AppState;
    createdAt: number;
    stoppedAt: number;
    nRunningTasks: number;
    name: string;
}
declare const AppListResponse_AppListItem: MessageFns$1<AppListResponse_AppListItem>;
interface AppLookupRequest {
    appName: string;
    environmentName: string;
}
declare const AppLookupRequest: MessageFns$1<AppLookupRequest>;
interface AppLookupResponse {
    appId: string;
}
declare const AppLookupResponse: MessageFns$1<AppLookupResponse>;
interface AppPublishRequest {
    appId: string;
    name: string;
    /** Additional metadata to identify a deployment */
    deploymentTag: string;
    /** Published app will be in this state */
    appState: AppState;
    /** function_name -> function_id */
    functionIds: {
        [key: string]: string;
    };
    /** class_name -> class_id */
    classIds: {
        [key: string]: string;
    };
    /** function_id -> definition_id */
    definitionIds: {
        [key: string]: string;
    };
    /** Unused by client, but used internally */
    rollbackVersion: number;
    /** Unused by client, but used internally */
    clientVersion: string;
    /** Git information for deployment tracking */
    commitInfo: CommitInfo | undefined;
    /** Additional metadata to attach to the App */
    tags: {
        [key: string]: string;
    };
}
declare const AppPublishRequest: MessageFns$1<AppPublishRequest>;
interface AppPublishResponse {
    url: string;
    serverWarnings: Warning[];
    deployedAt: number;
}
declare const AppPublishResponse: MessageFns$1<AppPublishResponse>;
interface AppRollbackRequest {
    appId: string;
    /** signed as we support negative "roll back n versions" requests */
    version: number;
}
declare const AppRollbackRequest: MessageFns$1<AppRollbackRequest>;
interface AppRolloverRequest {
    appId: string;
}
declare const AppRolloverRequest: MessageFns$1<AppRolloverRequest>;
interface AppRolloverResponse {
    url: string;
    serverWarnings: Warning[];
    deployedAt: number;
}
declare const AppRolloverResponse: MessageFns$1<AppRolloverResponse>;
interface AppSetObjectsRequest {
    appId: string;
    indexedObjectIds: {
        [key: string]: string;
    };
    clientId: string;
    unindexedObjectIds: string[];
    /** promotes an app from initializing to this new state */
    newAppState: AppState;
}
declare const AppSetObjectsRequest: MessageFns$1<AppSetObjectsRequest>;
interface AppSetTagsRequest {
    appId: string;
    tags: {
        [key: string]: string;
    };
}
declare const AppSetTagsRequest: MessageFns$1<AppSetTagsRequest>;
interface AppStopRequest {
    appId: string;
    source: AppStopSource;
}
declare const AppStopRequest: MessageFns$1<AppStopRequest>;
interface AttemptAwaitRequest {
    attemptToken: string;
    /** Used for waypoints. */
    requestedAt: number;
    timeoutSecs: number;
}
declare const AttemptAwaitRequest: MessageFns$1<AttemptAwaitRequest>;
interface AttemptAwaitResponse {
    output?: FunctionGetOutputsItem | undefined;
}
declare const AttemptAwaitResponse: MessageFns$1<AttemptAwaitResponse>;
interface AttemptRetryRequest {
    functionId: string;
    parentInputId: string;
    input: FunctionPutInputsItem | undefined;
    attemptToken: string;
}
declare const AttemptRetryRequest: MessageFns$1<AttemptRetryRequest>;
interface AttemptRetryResponse {
    attemptToken: string;
}
declare const AttemptRetryResponse: MessageFns$1<AttemptRetryResponse>;
interface AttemptStartRequest {
    functionId: string;
    parentInputId: string;
    input: FunctionPutInputsItem | undefined;
}
declare const AttemptStartRequest: MessageFns$1<AttemptStartRequest>;
interface AttemptStartResponse {
    attemptToken: string;
    retryPolicy: FunctionRetryPolicy | undefined;
}
declare const AttemptStartResponse: MessageFns$1<AttemptStartResponse>;
interface AuthTokenGetRequest {
}
declare const AuthTokenGetRequest: MessageFns$1<AuthTokenGetRequest>;
interface AuthTokenGetResponse {
    token: string;
}
declare const AuthTokenGetResponse: MessageFns$1<AuthTokenGetResponse>;
/**
 * A collection of user-configurable settings for Function autoscaling
 * These are used for static configuration and for dynamic autoscaler updates
 */
interface AutoscalerSettings {
    /** Minimum containers when scale-to-zero is not desired; pka "keep_warm" or "warm_pool_size" */
    minContainers?: number | undefined;
    /** Limit on the number of containers that can be running for each Function; pka "concurrency_limit" */
    maxContainers?: number | undefined;
    /** Additional container to spin up when Function is active */
    bufferContainers?: number | undefined;
    /** Stabilization window (in seconds) before scaling up; requires sustained demand over this period */
    scaleupWindow?: number | undefined;
    /** Maximum amount of time a container can be idle before being scaled down, in seconds; pka "container_idle_timeout" */
    scaledownWindow?: number | undefined;
    /** Target concurrent inputs per replica for Flash autoscaling. */
    targetConcurrency?: number | undefined;
    /** Maximum number of containers that can be scaled down per minute for Flash autoscaling. */
    scaledownRateLimit?: number | undefined;
}
declare const AutoscalerSettings: MessageFns$1<AutoscalerSettings>;
interface BaseImage {
    imageId: string;
    dockerTag: string;
}
declare const BaseImage: MessageFns$1<BaseImage>;
interface BlobCreateRequest {
    /**
     * TODO(erikbern): how are these garbage collected?
     * Shouldn't they belong to an app?
     */
    contentMd5: string;
    contentSha256Base64: string;
    contentLength: number;
}
declare const BlobCreateRequest: MessageFns$1<BlobCreateRequest>;
interface BlobCreateResponse {
    blobId: string;
    uploadUrl?: string | undefined;
    multipart?: MultiPartUpload | undefined;
    blobIds: string[];
    uploadUrls?: UploadUrlList | undefined;
    multiparts?: MultiPartUploadList | undefined;
}
declare const BlobCreateResponse: MessageFns$1<BlobCreateResponse>;
interface BlobGetRequest {
    blobId: string;
}
declare const BlobGetRequest: MessageFns$1<BlobGetRequest>;
interface BlobGetResponse {
    downloadUrl: string;
}
declare const BlobGetResponse: MessageFns$1<BlobGetResponse>;
interface BuildFunction {
    definition: string;
    globals: Uint8Array;
    input: FunctionInput | undefined;
}
declare const BuildFunction: MessageFns$1<BuildFunction>;
interface CancelInputEvent {
    inputIds: string[];
    terminateContainers: boolean;
    cancellationReason: string;
}
declare const CancelInputEvent: MessageFns$1<CancelInputEvent>;
interface CheckpointInfo {
    checksum: string;
    status: CheckpointStatus;
    checkpointId: string;
    runtimeFingerprint: string;
    size: number;
    checksumIsFileIndex: boolean;
    originalTaskId: string;
    runscRuntimeVersion: string;
}
declare const CheckpointInfo: MessageFns$1<CheckpointInfo>;
interface ClassCreateRequest {
    appId: string;
    existingClassId: string;
    methods: ClassMethod[];
    /** True starting with 0.67.x clients, which don't create method placeholder functions */
    onlyClassFunction: boolean;
}
declare const ClassCreateRequest: MessageFns$1<ClassCreateRequest>;
interface ClassCreateResponse {
    classId: string;
    handleMetadata: ClassHandleMetadata | undefined;
}
declare const ClassCreateResponse: MessageFns$1<ClassCreateResponse>;
interface ClassGetRequest {
    appName: string;
    objectTag: string;
    environmentName: string;
    /** True starting with 0.67.x clients, which don't create method placeholder functions */
    onlyClassFunction: boolean;
    appVersion: number;
}
declare const ClassGetRequest: MessageFns$1<ClassGetRequest>;
interface ClassGetResponse {
    classId: string;
    handleMetadata: ClassHandleMetadata | undefined;
    serverWarnings: Warning[];
}
declare const ClassGetResponse: MessageFns$1<ClassGetResponse>;
interface ClassHandleMetadata {
    methods: ClassMethod[];
    classFunctionId: string;
    classFunctionMetadata: FunctionHandleMetadata | undefined;
}
declare const ClassHandleMetadata: MessageFns$1<ClassHandleMetadata>;
interface ClassMethod {
    functionName: string;
    functionId: string;
    /** Class methods need to hydrate all functions on the class */
    functionHandleMetadata: FunctionHandleMetadata | undefined;
}
declare const ClassMethod: MessageFns$1<ClassMethod>;
interface ClassParameterInfo {
    format: ClassParameterInfo_ParameterSerializationFormat;
    /** only set for PARAM_SERIALIZATION_FORMAT_PROTO */
    schema: ClassParameterSpec[];
}
declare const ClassParameterInfo: MessageFns$1<ClassParameterInfo>;
/** TODO: rename into NamedPayloadType or similar */
interface ClassParameterSpec {
    name: string;
    /** TODO: deprecate - use full_type instead */
    type: ParameterType;
    hasDefault: boolean;
    /** Default *values* are only registered for class parameters */
    stringDefault?: string | undefined;
    intDefault?: number | undefined;
    pickleDefault?: Uint8Array | undefined;
    bytesDefault?: Uint8Array | undefined;
    boolDefault?: boolean | undefined;
    /** supersedes `type` */
    fullType: GenericPayloadType | undefined;
}
declare const ClassParameterSpec: MessageFns$1<ClassParameterSpec>;
interface ClientHelloResponse {
    warning: string;
    /** Deprecated, no longer used in client */
    imageBuilderVersion: string;
    serverWarnings: Warning[];
}
declare const ClientHelloResponse: MessageFns$1<ClientHelloResponse>;
interface CloudBucketMount$1 {
    bucketName: string;
    mountPath: string;
    credentialsSecretId: string;
    readOnly: boolean;
    bucketType: CloudBucketMount_BucketType;
    requesterPays: boolean;
    bucketEndpointUrl?: string | undefined;
    keyPrefix?: string | undefined;
    oidcAuthRoleArn?: string | undefined;
    forcePathStyle: boolean;
    metadataTtlType?: CloudBucketMount_MetadataTTLType | undefined;
    metadataTtlSeconds?: number | undefined;
}
declare const CloudBucketMount$1: MessageFns$1<CloudBucketMount$1>;
interface ClusterGetRequest {
    clusterId: string;
}
declare const ClusterGetRequest: MessageFns$1<ClusterGetRequest>;
interface ClusterGetResponse {
    cluster: ClusterStats | undefined;
}
declare const ClusterGetResponse: MessageFns$1<ClusterGetResponse>;
interface ClusterListRequest {
    environmentName: string;
}
declare const ClusterListRequest: MessageFns$1<ClusterListRequest>;
interface ClusterListResponse {
    clusters: ClusterStats[];
}
declare const ClusterListResponse: MessageFns$1<ClusterListResponse>;
interface ClusterStats {
    appId: string;
    taskIds: string[];
    clusterId: string;
    /** Defined as start time of the first task in the cluster */
    startedAt: number;
}
declare const ClusterStats: MessageFns$1<ClusterStats>;
interface CommitInfo {
    /** Only git is supported for now */
    vcs: string;
    branch: string;
    commitHash: string;
    commitTimestamp: number;
    dirty: boolean;
    authorName: string;
    authorEmail: string;
    repoUrl: string;
}
declare const CommitInfo: MessageFns$1<CommitInfo>;
interface ContainerCheckpointRequest {
    checkpointId: string;
}
declare const ContainerCheckpointRequest: MessageFns$1<ContainerCheckpointRequest>;
interface ContainerExecGetOutputRequest {
    execId: string;
    timeout: number;
    lastBatchIndex: number;
    fileDescriptor: FileDescriptor;
    /** Old clients (up to 0.65.39) expect string output. Newer clients stream raw bytes */
    getRawBytes: boolean;
}
declare const ContainerExecGetOutputRequest: MessageFns$1<ContainerExecGetOutputRequest>;
interface ContainerExecPutInputRequest {
    execId: string;
    input: RuntimeInputMessage | undefined;
}
declare const ContainerExecPutInputRequest: MessageFns$1<ContainerExecPutInputRequest>;
interface ContainerExecRequest {
    taskId: string;
    command: string[];
    /**
     * If pty_info is provided, open a PTY, but also this container exec is treated an
     * "interactive shell" request, and it will be terminated if messages are not periodically
     * sent on the stdin stream on some interval (currently 40 seconds).
     */
    ptyInfo?: PTYInfo | undefined;
    /**
     * Send SIGTERM to running container on exit of exec command.
     *
     * @deprecated
     */
    terminateContainerOnExit: boolean;
    /** For internal debugging use only. */
    runtimeDebug: boolean;
    stdoutOutput: ExecOutputOption;
    stderrOutput: ExecOutputOption;
    timeoutSecs: number;
    workdir?: string | undefined;
    secretIds: string[];
}
declare const ContainerExecRequest: MessageFns$1<ContainerExecRequest>;
interface ContainerExecResponse {
    execId: string;
}
declare const ContainerExecResponse: MessageFns$1<ContainerExecResponse>;
interface ContainerExecWaitRequest {
    execId: string;
    timeout: number;
}
declare const ContainerExecWaitRequest: MessageFns$1<ContainerExecWaitRequest>;
interface ContainerExecWaitResponse {
    exitCode?: number | undefined;
    completed: boolean;
}
declare const ContainerExecWaitResponse: MessageFns$1<ContainerExecWaitResponse>;
interface ContainerFileCloseRequest {
    fileDescriptor: string;
}
declare const ContainerFileCloseRequest: MessageFns$1<ContainerFileCloseRequest>;
interface ContainerFileDeleteBytesRequest {
    fileDescriptor: string;
    startInclusive?: number | undefined;
    endExclusive?: number | undefined;
}
declare const ContainerFileDeleteBytesRequest: MessageFns$1<ContainerFileDeleteBytesRequest>;
interface ContainerFileFlushRequest {
    fileDescriptor: string;
}
declare const ContainerFileFlushRequest: MessageFns$1<ContainerFileFlushRequest>;
interface ContainerFileLsRequest {
    path: string;
}
declare const ContainerFileLsRequest: MessageFns$1<ContainerFileLsRequest>;
interface ContainerFileMkdirRequest {
    path: string;
    makeParents: boolean;
}
declare const ContainerFileMkdirRequest: MessageFns$1<ContainerFileMkdirRequest>;
interface ContainerFileOpenRequest {
    /** file descriptor is hydrated when sent from server -> worker */
    fileDescriptor?: string | undefined;
    path: string;
    mode: string;
}
declare const ContainerFileOpenRequest: MessageFns$1<ContainerFileOpenRequest>;
interface ContainerFileReadLineRequest {
    fileDescriptor: string;
}
declare const ContainerFileReadLineRequest: MessageFns$1<ContainerFileReadLineRequest>;
interface ContainerFileReadRequest {
    fileDescriptor: string;
    n?: number | undefined;
}
declare const ContainerFileReadRequest: MessageFns$1<ContainerFileReadRequest>;
interface ContainerFileRmRequest {
    path: string;
    recursive: boolean;
}
declare const ContainerFileRmRequest: MessageFns$1<ContainerFileRmRequest>;
interface ContainerFileSeekRequest {
    fileDescriptor: string;
    offset: number;
    whence: SeekWhence;
}
declare const ContainerFileSeekRequest: MessageFns$1<ContainerFileSeekRequest>;
interface ContainerFileWatchRequest {
    path: string;
    recursive: boolean;
    timeoutSecs?: number | undefined;
}
declare const ContainerFileWatchRequest: MessageFns$1<ContainerFileWatchRequest>;
interface ContainerFileWriteReplaceBytesRequest {
    fileDescriptor: string;
    data: Uint8Array;
    startInclusive?: number | undefined;
    endExclusive?: number | undefined;
}
declare const ContainerFileWriteReplaceBytesRequest: MessageFns$1<ContainerFileWriteReplaceBytesRequest>;
interface ContainerFileWriteRequest {
    fileDescriptor: string;
    data: Uint8Array;
}
declare const ContainerFileWriteRequest: MessageFns$1<ContainerFileWriteRequest>;
interface ContainerFilesystemExecGetOutputRequest {
    execId: string;
    timeout: number;
}
declare const ContainerFilesystemExecGetOutputRequest: MessageFns$1<ContainerFilesystemExecGetOutputRequest>;
interface ContainerFilesystemExecRequest {
    fileOpenRequest?: ContainerFileOpenRequest | undefined;
    fileWriteRequest?: ContainerFileWriteRequest | undefined;
    fileReadRequest?: ContainerFileReadRequest | undefined;
    fileFlushRequest?: ContainerFileFlushRequest | undefined;
    fileReadLineRequest?: ContainerFileReadLineRequest | undefined;
    fileSeekRequest?: ContainerFileSeekRequest | undefined;
    fileDeleteBytesRequest?: ContainerFileDeleteBytesRequest | undefined;
    fileWriteReplaceBytesRequest?: ContainerFileWriteReplaceBytesRequest | undefined;
    fileCloseRequest?: ContainerFileCloseRequest | undefined;
    fileLsRequest?: ContainerFileLsRequest | undefined;
    fileMkdirRequest?: ContainerFileMkdirRequest | undefined;
    fileRmRequest?: ContainerFileRmRequest | undefined;
    fileWatchRequest?: ContainerFileWatchRequest | undefined;
    taskId: string;
}
declare const ContainerFilesystemExecRequest: MessageFns$1<ContainerFilesystemExecRequest>;
interface ContainerFilesystemExecResponse {
    execId: string;
    /** only set when the request opens a new file, i.e., ContainerFileOpenRequest */
    fileDescriptor?: string | undefined;
}
declare const ContainerFilesystemExecResponse: MessageFns$1<ContainerFilesystemExecResponse>;
interface ContainerHeartbeatRequest {
    /** Bad client version. */
    canceledInputsReturnOutputs: boolean;
    canceledInputsReturnOutputsV2: boolean;
}
declare const ContainerHeartbeatRequest: MessageFns$1<ContainerHeartbeatRequest>;
interface ContainerHeartbeatResponse {
    cancelInputEvent?: CancelInputEvent | undefined;
}
declare const ContainerHeartbeatResponse: MessageFns$1<ContainerHeartbeatResponse>;
interface ContainerLogRequest {
    logs: TaskLogs[];
}
declare const ContainerLogRequest: MessageFns$1<ContainerLogRequest>;
interface ContainerReloadVolumesRequest {
    taskId: string;
}
declare const ContainerReloadVolumesRequest: MessageFns$1<ContainerReloadVolumesRequest>;
interface ContainerReloadVolumesResponse {
}
declare const ContainerReloadVolumesResponse: MessageFns$1<ContainerReloadVolumesResponse>;
interface ContainerStopRequest {
    taskId: string;
}
declare const ContainerStopRequest: MessageFns$1<ContainerStopRequest>;
interface ContainerStopResponse {
}
declare const ContainerStopResponse: MessageFns$1<ContainerStopResponse>;
interface CreationInfo {
    /** This message is used in metadata for resource objects like Dict, Queue, Volume, etc. */
    createdAt: number;
    /** User name or service name */
    createdBy: string;
}
declare const CreationInfo: MessageFns$1<CreationInfo>;
interface CustomDomainConfig {
    name: string;
}
declare const CustomDomainConfig: MessageFns$1<CustomDomainConfig>;
interface CustomDomainInfo {
    url: string;
}
declare const CustomDomainInfo: MessageFns$1<CustomDomainInfo>;
interface DNSRecord {
    type: DNSRecordType;
    name: string;
    value: string;
}
declare const DNSRecord: MessageFns$1<DNSRecord>;
/** Chunks of data that can be streamed in and out of tasks. */
interface DataChunk {
    dataFormat: DataFormat;
    data?: Uint8Array | undefined;
    dataBlobId?: string | undefined;
    /** Index of this data chunk in the stream. */
    index: number;
}
declare const DataChunk: MessageFns$1<DataChunk>;
interface DictClearRequest {
    dictId: string;
}
declare const DictClearRequest: MessageFns$1<DictClearRequest>;
interface DictContainsRequest {
    dictId: string;
    key: Uint8Array;
}
declare const DictContainsRequest: MessageFns$1<DictContainsRequest>;
interface DictContainsResponse {
    found: boolean;
}
declare const DictContainsResponse: MessageFns$1<DictContainsResponse>;
interface DictContentsRequest {
    dictId: string;
    /**
     * Setting these to True will populate the corresponding field in the response, otherwise it will be null
     * This lets us support the keys/values/items SDK API through one RPC without unnecessary data transfer
     */
    keys: boolean;
    values: boolean;
}
declare const DictContentsRequest: MessageFns$1<DictContentsRequest>;
interface DictDeleteRequest {
    dictId: string;
}
declare const DictDeleteRequest: MessageFns$1<DictDeleteRequest>;
interface DictEntry {
    key: Uint8Array;
    value: Uint8Array;
}
declare const DictEntry: MessageFns$1<DictEntry>;
interface DictGetByIdRequest {
    dictId: string;
}
declare const DictGetByIdRequest: MessageFns$1<DictGetByIdRequest>;
interface DictGetByIdResponse {
    dictId: string;
    metadata: DictMetadata | undefined;
}
declare const DictGetByIdResponse: MessageFns$1<DictGetByIdResponse>;
interface DictGetOrCreateRequest {
    deploymentName: string;
    environmentName: string;
    objectCreationType: ObjectCreationType;
    /** Unused after 1.4.0 */
    data: DictEntry[];
}
declare const DictGetOrCreateRequest: MessageFns$1<DictGetOrCreateRequest>;
interface DictGetOrCreateResponse {
    dictId: string;
    metadata: DictMetadata | undefined;
}
declare const DictGetOrCreateResponse: MessageFns$1<DictGetOrCreateResponse>;
interface DictGetRequest {
    dictId: string;
    key: Uint8Array;
}
declare const DictGetRequest: MessageFns$1<DictGetRequest>;
interface DictGetResponse {
    found: boolean;
    value?: Uint8Array | undefined;
}
declare const DictGetResponse: MessageFns$1<DictGetResponse>;
interface DictHeartbeatRequest {
    dictId: string;
}
declare const DictHeartbeatRequest: MessageFns$1<DictHeartbeatRequest>;
interface DictLenRequest {
    dictId: string;
}
declare const DictLenRequest: MessageFns$1<DictLenRequest>;
interface DictLenResponse {
    len: number;
}
declare const DictLenResponse: MessageFns$1<DictLenResponse>;
interface DictListRequest {
    environmentName: string;
    pagination: ListPagination | undefined;
}
declare const DictListRequest: MessageFns$1<DictListRequest>;
interface DictListResponse {
    dicts: DictListResponse_DictInfo[];
    environmentName: string;
}
declare const DictListResponse: MessageFns$1<DictListResponse>;
interface DictListResponse_DictInfo {
    name: string;
    /** Superseded by metadata, used by clients up to 1.1.2 */
    createdAt: number;
    dictId: string;
    metadata: DictMetadata | undefined;
}
declare const DictListResponse_DictInfo: MessageFns$1<DictListResponse_DictInfo>;
interface DictMetadata {
    name: string;
    creationInfo: CreationInfo | undefined;
}
declare const DictMetadata: MessageFns$1<DictMetadata>;
interface DictPopRequest {
    dictId: string;
    key: Uint8Array;
}
declare const DictPopRequest: MessageFns$1<DictPopRequest>;
interface DictPopResponse {
    found: boolean;
    value?: Uint8Array | undefined;
}
declare const DictPopResponse: MessageFns$1<DictPopResponse>;
interface DictUpdateRequest {
    dictId: string;
    updates: DictEntry[];
    ifNotExists: boolean;
}
declare const DictUpdateRequest: MessageFns$1<DictUpdateRequest>;
interface DictUpdateResponse {
    created: boolean;
}
declare const DictUpdateResponse: MessageFns$1<DictUpdateResponse>;
interface Domain {
    domainId: string;
    domainName: string;
    createdAt: number;
    certificateStatus: CertificateStatus;
    dnsRecords: DNSRecord[];
}
declare const Domain: MessageFns$1<Domain>;
interface DomainCertificateVerifyRequest {
    domainId: string;
}
declare const DomainCertificateVerifyRequest: MessageFns$1<DomainCertificateVerifyRequest>;
interface DomainCertificateVerifyResponse {
    domain: Domain | undefined;
}
declare const DomainCertificateVerifyResponse: MessageFns$1<DomainCertificateVerifyResponse>;
interface DomainCreateRequest {
    domainName: string;
}
declare const DomainCreateRequest: MessageFns$1<DomainCreateRequest>;
interface DomainCreateResponse {
    domainId: string;
    dnsRecords: DNSRecord[];
}
declare const DomainCreateResponse: MessageFns$1<DomainCreateResponse>;
interface DomainListRequest {
}
declare const DomainListRequest: MessageFns$1<DomainListRequest>;
interface DomainListResponse {
    domains: Domain[];
}
declare const DomainListResponse: MessageFns$1<DomainListResponse>;
interface EndpointComputeRegionSpec {
    auto?: Empty | undefined;
    colocated?: Empty | undefined;
    explicit?: EndpointComputeRegionSpec_ExplicitRegions | undefined;
}
declare const EndpointComputeRegionSpec: MessageFns$1<EndpointComputeRegionSpec>;
interface EndpointComputeRegionSpec_ExplicitRegions {
    regions: string[];
}
declare const EndpointComputeRegionSpec_ExplicitRegions: MessageFns$1<EndpointComputeRegionSpec_ExplicitRegions>;
interface EndpointCreateRequest {
    name: string;
    description: string;
    proxyRegions: string[];
    computeRegion: EndpointComputeRegionSpec | undefined;
    model: EndpointModelSource | undefined;
    apiSurfaces: EndpointApiSurface[];
    inputModalities: EndpointInputModality[];
    environmentName: string;
}
declare const EndpointCreateRequest: MessageFns$1<EndpointCreateRequest>;
interface EndpointCreateResponse {
    endpointId: string;
    endpointPageUrl: string;
}
declare const EndpointCreateResponse: MessageFns$1<EndpointCreateResponse>;
interface EndpointCustomModelSource {
    baseModelRepoId: string;
    huggingface?: EndpointHuggingFaceModelSource | undefined;
    modalVolume?: EndpointModalVolumeModelSource | undefined;
}
declare const EndpointCustomModelSource: MessageFns$1<EndpointCustomModelSource>;
interface EndpointHuggingFaceModelSource {
    repoId: string;
    revision: string;
    huggingfaceToken: string;
}
declare const EndpointHuggingFaceModelSource: MessageFns$1<EndpointHuggingFaceModelSource>;
interface EndpointListItem {
    endpointId: string;
    name: string;
    description: string;
    activeDeploymentId: string;
    updatedAt: number;
    metadata: EndpointMetadata | undefined;
    appState: AppState;
    functionId: string;
    createdByAvatarUrl: string;
    provisioningStatus: EndpointProvisioningStatus;
}
declare const EndpointListItem: MessageFns$1<EndpointListItem>;
interface EndpointListRequest {
    environmentName: string;
    pagination: ListPagination | undefined;
}
declare const EndpointListRequest: MessageFns$1<EndpointListRequest>;
interface EndpointListResponse {
    items: EndpointListItem[];
    environmentName: string;
}
declare const EndpointListResponse: MessageFns$1<EndpointListResponse>;
interface EndpointMetadata {
    name: string;
    creationInfo: CreationInfo | undefined;
}
declare const EndpointMetadata: MessageFns$1<EndpointMetadata>;
interface EndpointModalVolumeModelSource {
    volumeId: string;
    modelPath: string;
}
declare const EndpointModalVolumeModelSource: MessageFns$1<EndpointModalVolumeModelSource>;
interface EndpointModelSource {
    baseModelRepoId?: string | undefined;
    custom?: EndpointCustomModelSource | undefined;
}
declare const EndpointModelSource: MessageFns$1<EndpointModelSource>;
interface EndpointStopRequest {
    endpointId: string;
    source: EndpointStopSource;
}
declare const EndpointStopRequest: MessageFns$1<EndpointStopRequest>;
interface EndpointStopResponse {
}
declare const EndpointStopResponse: MessageFns$1<EndpointStopResponse>;
interface EnvironmentCreateRequest {
    name: string;
    isManaged: boolean;
    settings: EnvironmentSettings | undefined;
}
declare const EnvironmentCreateRequest: MessageFns$1<EnvironmentCreateRequest>;
interface EnvironmentDeleteRequest {
    name: string;
}
declare const EnvironmentDeleteRequest: MessageFns$1<EnvironmentDeleteRequest>;
interface EnvironmentGetManagedRequest {
    environmentId: string;
}
declare const EnvironmentGetManagedRequest: MessageFns$1<EnvironmentGetManagedRequest>;
interface EnvironmentGetManagedResponse {
    environmentId: string;
    name: string;
    createdAt: number;
    principalRoles: EnvironmentGetManagedResponse_PrincipalEnvRole[];
    additionalRoles: EnvironmentGetManagedResponse_PrincipalEnvRole[];
}
declare const EnvironmentGetManagedResponse: MessageFns$1<EnvironmentGetManagedResponse>;
interface EnvironmentGetManagedResponse_PrincipalEnvRole {
    userId: string;
    serviceUserId: string;
    email: string;
    avatarUrl: string;
    serviceUserName: string;
    role: EnvironmentRole;
    memberRole: MemberRole;
    userName: string;
}
declare const EnvironmentGetManagedResponse_PrincipalEnvRole: MessageFns$1<EnvironmentGetManagedResponse_PrincipalEnvRole>;
interface EnvironmentGetOrCreateRequest {
    deploymentName: string;
    objectCreationType: ObjectCreationType;
}
declare const EnvironmentGetOrCreateRequest: MessageFns$1<EnvironmentGetOrCreateRequest>;
interface EnvironmentGetOrCreateResponse {
    environmentId: string;
    metadata: EnvironmentMetadata | undefined;
}
declare const EnvironmentGetOrCreateResponse: MessageFns$1<EnvironmentGetOrCreateResponse>;
interface EnvironmentListItem {
    name: string;
    webhookSuffix: string;
    createdAt: number;
    default: boolean;
    isManaged: boolean;
    environmentId: string;
    maxConcurrentTasks?: number | undefined;
    maxConcurrentGpus?: number | undefined;
    currentConcurrentTasks: number;
    currentConcurrentGpus: number;
}
declare const EnvironmentListItem: MessageFns$1<EnvironmentListItem>;
interface EnvironmentListResponse {
    items: EnvironmentListItem[];
}
declare const EnvironmentListResponse: MessageFns$1<EnvironmentListResponse>;
interface EnvironmentMetadata {
    name: string;
    settings: EnvironmentSettings | undefined;
}
declare const EnvironmentMetadata: MessageFns$1<EnvironmentMetadata>;
interface EnvironmentRoleSetRequest {
    environmentId: string;
    userId: string;
    serviceUserId: string;
    role: EnvironmentRole;
}
declare const EnvironmentRoleSetRequest: MessageFns$1<EnvironmentRoleSetRequest>;
interface EnvironmentSetManagedRequest {
    environmentId: string;
    managed: boolean;
}
declare const EnvironmentSetManagedRequest: MessageFns$1<EnvironmentSetManagedRequest>;
/**
 * Environment-scoped settings, with workspace-level defaults.
 * Note that we use MergeFrom to combine workspace / environment settings,
 * which will *append* any `repeated` fields!
 */
interface EnvironmentSettings {
    imageBuilderVersion: string;
    webhookSuffix: string;
    maxConcurrentGpus?: number | undefined;
    maxConcurrentTasks?: number | undefined;
}
declare const EnvironmentSettings: MessageFns$1<EnvironmentSettings>;
interface EnvironmentUpdateRequest {
    currentName: string;
    name: string | undefined;
    webSuffix: string | undefined;
    maxConcurrentTasks?: number | undefined;
    maxConcurrentGpus?: number | undefined;
}
declare const EnvironmentUpdateRequest: MessageFns$1<EnvironmentUpdateRequest>;
/** A file entry when listing files in a volume or network file system. */
interface FileEntry {
    path: string;
    type: FileEntry_FileType;
    mtime: number;
    size: number;
}
declare const FileEntry: MessageFns$1<FileEntry>;
interface FilesystemRuntimeOutputBatch {
    output: Uint8Array[];
    error?: SystemErrorMessage | undefined;
    batchIndex: number;
    eof: boolean;
}
declare const FilesystemRuntimeOutputBatch: MessageFns$1<FilesystemRuntimeOutputBatch>;
interface FlashContainerDeregisterRequest {
    serviceName: string;
}
declare const FlashContainerDeregisterRequest: MessageFns$1<FlashContainerDeregisterRequest>;
interface FlashContainerListRequest {
    functionId: string;
}
declare const FlashContainerListRequest: MessageFns$1<FlashContainerListRequest>;
interface FlashContainerListResponse {
    containers: FlashContainerListResponse_Container[];
}
declare const FlashContainerListResponse: MessageFns$1<FlashContainerListResponse>;
interface FlashContainerListResponse_Container {
    taskId: string;
    host: string;
    port: number;
}
declare const FlashContainerListResponse_Container: MessageFns$1<FlashContainerListResponse_Container>;
interface FlashContainerRegisterRequest {
    /** not used? */
    serviceName: string;
    priority: number;
    weight: number;
    host: string;
    port: number;
}
declare const FlashContainerRegisterRequest: MessageFns$1<FlashContainerRegisterRequest>;
interface FlashContainerRegisterResponse {
    url: string;
}
declare const FlashContainerRegisterResponse: MessageFns$1<FlashContainerRegisterResponse>;
interface FlashSetTargetSlotsMetricsRequest {
    /** TODO(claudia): add other metrics to use in autoscaling decisions */
    functionId: string;
    targetSlots: number;
}
declare const FlashSetTargetSlotsMetricsRequest: MessageFns$1<FlashSetTargetSlotsMetricsRequest>;
interface FlashSetTargetSlotsMetricsResponse {
}
declare const FlashSetTargetSlotsMetricsResponse: MessageFns$1<FlashSetTargetSlotsMetricsResponse>;
interface FunctionMessage {
    moduleName: string;
    functionName: string;
    mountIds: string[];
    imageId: string;
    functionSerialized: Uint8Array;
    definitionType: Function_DefinitionType;
    functionType: Function_FunctionType;
    resources: Resources | undefined;
    secretIds: string[];
    rateLimit: RateLimit | undefined;
    webhookConfig: WebhookConfig | undefined;
    sharedVolumeMounts: SharedVolumeMount[];
    proxyId?: string | undefined;
    retryPolicy: FunctionRetryPolicy | undefined;
    /** To be replaced by autoscaler_settings.max_containers */
    concurrencyLimit: number;
    timeoutSecs: number;
    ptyInfo: PTYInfo | undefined;
    classSerialized: Uint8Array;
    /** To be replaced by autoscaler_settings.scaledown_period */
    taskIdleTimeoutSecs: number;
    /** Deprecated at some point */
    cloudProvider?: CloudProvider | undefined;
    /** To be replaced by autoscaler_settings.min_containers */
    warmPoolSize: number;
    webUrl: string;
    webUrlInfo: WebUrlInfo | undefined;
    /** If set, overrides the runtime used by the function, either "runc" or "gvisor". */
    runtime: string;
    /** Formerly stub_name */
    appName: string;
    volumeMounts: VolumeMount[];
    maxConcurrentInputs: number;
    customDomainInfo: CustomDomainInfo[];
    /** For internal debugging use only. */
    workerId: string;
    /** For internal debugging use only. */
    runtimeDebug: boolean;
    /** TODO: combine into enum? */
    isBuilderFunction: boolean;
    isAutoSnapshot: boolean;
    isMethod: boolean;
    isCheckpointingFunction: boolean;
    checkpointingEnabled: boolean;
    checkpoint: CheckpointInfo | undefined;
    objectDependencies: ObjectDependency[];
    blockNetwork: boolean;
    /**
     * In the SDK, we've deprecated `max_inputs` (which only ever implemented `max_inputs=1`)
     * in favor of a boolean `single_use_containers` parameter.
     */
    maxInputs: number;
    s3Mounts: S3Mount[];
    cloudBucketMounts: CloudBucketMount$1[];
    schedulerPlacement?: SchedulerPlacement | undefined;
    /** if "Function" is actually a class grouping multiple methods */
    isClass: boolean;
    /** for class methods use this function id instead for invocations - the *referenced* function should have is_class=True */
    useFunctionId: string;
    /** for class methods - this method name needs to be included in the FunctionInput */
    useMethodName: string;
    classParameterInfo: ClassParameterInfo | undefined;
    /** Maximum number of inputs to fetch at once */
    batchMaxSize: number;
    /** Miliseconds to block before a response is needed */
    batchLingerMs: number;
    i6pnEnabled: boolean;
    ExperimentalConcurrentCancellations: boolean;
    targetConcurrentInputs: number;
    /** TODO(irfansharif): Remove, once https://github.com/modal-labs/modal/pull/15645 lands. */
    ExperimentalTaskTemplatesEnabled: boolean;
    /** for fallback options, where the first/most-preferred "template" is derived from fields above */
    ExperimentalTaskTemplates: TaskTemplate[];
    /**
     * When the function is a "grouped" one, this records the # of tasks we want
     * to schedule in tandem.
     */
    ExperimentalGroupSize: number;
    /** If set, the function will be run in an untrusted environment. */
    untrusted: boolean;
    /** To be replaced by autoscaler_settings.buffer_containers */
    ExperimentalBufferContainers: number;
    /**
     * _experimental_proxy_ip -> ProxyInfo
     * TODO: deprecate.
     *
     * @deprecated
     */
    ExperimentalProxyIp?: string | undefined;
    /** For internal debugging use only. */
    runtimePerfRecord: boolean;
    schedule: Schedule | undefined;
    /** For internal debugging use only. */
    snapshotDebug: boolean;
    /** Mapping of method names to method definitions, only non-empty for class service functions */
    methodDefinitions: {
        [key: string]: MethodDefinition;
    };
    methodDefinitionsSet: boolean;
    ExperimentalCustomScaling: boolean;
    /** Supersedes cloud_provider */
    cloudProviderStr: string;
    /** Experimental support for GPU snapshotting */
    ExperimentalEnableGpuSnapshot: boolean;
    /** Bundle of parameters related to autoscaling */
    autoscalerSettings: AutoscalerSettings | undefined;
    /** Function schema, may be missing: client doesn't block deployment if it fails to get it */
    functionSchema: FunctionSchema | undefined;
    /**
     * For server-side experimental functionality. Prefer using this over individual _experimental_* fields.
     * Note the value type as string. Internally we'll coerce all values to string with str().
     * On the server, it's necessary to convert back to the most natural type (e.g. int) when relevant.
     */
    experimentalOptions: {
        [key: string]: string;
    };
    /**
     * Deprecated: still set by client but ignored by server. The scheduler
     * derives this from the image's builder_version directly.
     */
    mountClientDependencies: boolean;
    flashServiceUrls: string[];
    flashServiceLabel: string;
    /** GPU memory snapshotting (alpha) */
    enableGpuSnapshot: boolean;
    startupTimeoutSecs: number;
    /** can be used as inputs */
    supportedInputFormats: DataFormat[];
    supportedOutputFormats: DataFormat[];
    httpConfig?: HTTPConfig | undefined;
    /**
     * Attribute on the module with the implementation, which may differ from function_name
     * when the user provided a custom name= for the Function inside the Application namespace
     */
    implementationName: string;
    /** When True, containers will shut down after handling a single input */
    singleUseContainers: boolean;
    /** When True, the function is a server function */
    isServer: boolean;
    /** Where inputs to a function should be routed through. */
    routingRegion: string;
}
declare const FunctionMessage: MessageFns$1<FunctionMessage>;
interface FunctionAsyncInvokeRequest {
    functionId: string;
    parentInputId: string;
    input: FunctionInput | undefined;
}
declare const FunctionAsyncInvokeRequest: MessageFns$1<FunctionAsyncInvokeRequest>;
interface FunctionAsyncInvokeResponse {
    retryWithBlobUpload: boolean;
    functionCallId: string;
}
declare const FunctionAsyncInvokeResponse: MessageFns$1<FunctionAsyncInvokeResponse>;
interface FunctionBindParamsRequest {
    functionId: string;
    serializedParams: Uint8Array;
    functionOptions: FunctionOptions$1 | undefined;
    environmentName: string;
    /** Only used for the input plane. */
    authSecret: string;
}
declare const FunctionBindParamsRequest: MessageFns$1<FunctionBindParamsRequest>;
interface FunctionBindParamsResponse {
    boundFunctionId: string;
    handleMetadata: FunctionHandleMetadata | undefined;
}
declare const FunctionBindParamsResponse: MessageFns$1<FunctionBindParamsResponse>;
interface FunctionCallCallGraphInfo {
    functionCallId: string;
    parentInputId: string;
    functionName: string;
    moduleName: string;
}
declare const FunctionCallCallGraphInfo: MessageFns$1<FunctionCallCallGraphInfo>;
interface FunctionCallCancelRequest {
    functionCallId: string;
    terminateContainers: boolean;
    /** Only provided for sync input cancellation on the input plane. Async input cancellation does not provide this field this. */
    functionId?: string | undefined;
}
declare const FunctionCallCancelRequest: MessageFns$1<FunctionCallCancelRequest>;
interface FunctionCallFromIdRequest {
    functionCallId: string;
}
declare const FunctionCallFromIdRequest: MessageFns$1<FunctionCallFromIdRequest>;
/** Everything you need to build a FunctionCallHandler. */
interface FunctionCallFromIdResponse {
    functionCallId: string;
    numInputs: number;
}
declare const FunctionCallFromIdResponse: MessageFns$1<FunctionCallFromIdResponse>;
interface FunctionCallGetDataRequest {
    functionCallId?: string | undefined;
    attemptToken?: string | undefined;
    lastIndex: number;
}
declare const FunctionCallGetDataRequest: MessageFns$1<FunctionCallGetDataRequest>;
interface FunctionCallInfo {
    functionCallId: string;
    idx: number;
    /** when the call was created */
    createdAt: number;
    /** if cron job, when run was scheduled */
    scheduledAt: number;
    pendingInputs: InputCategoryInfo | undefined;
    failedInputs: InputCategoryInfo | undefined;
    succeededInputs: InputCategoryInfo | undefined;
    timeoutInputs: InputCategoryInfo | undefined;
    cancelledInputs: InputCategoryInfo | undefined;
    totalInputs: number;
}
declare const FunctionCallInfo: MessageFns$1<FunctionCallInfo>;
interface FunctionCallListRequest {
    functionId: string;
}
declare const FunctionCallListRequest: MessageFns$1<FunctionCallListRequest>;
interface FunctionCallListResponse {
    functionCalls: FunctionCallInfo[];
}
declare const FunctionCallListResponse: MessageFns$1<FunctionCallListResponse>;
interface FunctionCallPutDataRequest {
    functionCallId?: string | undefined;
    attemptToken?: string | undefined;
    dataChunks: DataChunk[];
}
declare const FunctionCallPutDataRequest: MessageFns$1<FunctionCallPutDataRequest>;
interface FunctionCreateRequest {
    function: FunctionMessage | undefined;
    appId: string;
    /**
     * Deprecated: now passed in the Function definition
     *
     * @deprecated
     */
    schedule: Schedule | undefined;
    existingFunctionId: string;
    /** supersedes 'function' field above */
    functionData: FunctionData | undefined;
}
declare const FunctionCreateRequest: MessageFns$1<FunctionCreateRequest>;
interface FunctionCreateResponse {
    functionId: string;
    /**
     * Used up until 0.62.212
     *
     * @deprecated
     */
    DeprecatedWebUrl: string;
    function: FunctionMessage | undefined;
    handleMetadata: FunctionHandleMetadata | undefined;
    serverWarnings: Warning[];
}
declare const FunctionCreateResponse: MessageFns$1<FunctionCreateResponse>;
/**
 * Note: FunctionData pulls "up" a subset of fields from Function message that
 * will get deprecated there and made authoritative here, at the top-level.
 * All remaining fields will stay within the Function message itself and a
 * single FunctionData will contain a list of such (ranked) Functions. The
 * top-level fields capture data not specific to any particular underlying
 * task (like warm-pool-size, applicable across all tasks), while fields
 * specific to the task (like the resource request) will exist at the bottom
 * level.
 */
interface FunctionData {
    moduleName: string;
    functionName: string;
    functionType: Function_FunctionType;
    /** Scheduling related fields. */
    warmPoolSize: number;
    concurrencyLimit: number;
    taskIdleTimeoutSecs: number;
    /**
     * When the function is a "grouped" one, this records the # of tasks we want
     * to schedule in tandem.
     */
    ExperimentalGroupSize: number;
    ExperimentalBufferContainers: number;
    ExperimentalCustomScaling: boolean;
    ExperimentalEnableGpuSnapshot: boolean;
    /** for internal debugging use only */
    workerId: string;
    timeoutSecs: number;
    webUrl: string;
    webUrlInfo: WebUrlInfo | undefined;
    webhookConfig: WebhookConfig | undefined;
    customDomainInfo: CustomDomainInfo[];
    /**
     * _experimental_proxy_ip -> ProxyInfo
     * TODO: deprecate.
     *
     * @deprecated
     */
    ExperimentalProxyIp?: string | undefined;
    /** Mapping of method names to method definitions, only non-empty for class service functions */
    methodDefinitions: {
        [key: string]: MethodDefinition;
    };
    methodDefinitionsSet: boolean;
    /** if "Function" is actually a class grouping multiple methods - applies across all underlying tasks */
    isClass: boolean;
    classParameterInfo: ClassParameterInfo | undefined;
    isMethod: boolean;
    /** used for methods */
    useFunctionId: string;
    /** used for methods */
    useMethodName: string;
    rankedFunctions: FunctionData_RankedFunction[];
    schedule: Schedule | undefined;
    /** If set, the function will be run in an untrusted environment. */
    untrusted: boolean;
    /** For internal debugging use only. */
    snapshotDebug: boolean;
    /** For internal debugging use only. */
    runtimePerfRecord: boolean;
    /** Bundle of parameters related to autoscaling */
    autoscalerSettings: AutoscalerSettings | undefined;
    functionSchema: FunctionSchema | undefined;
    experimentalOptions: {
        [key: string]: string;
    };
    flashServiceUrls: string[];
    flashServiceLabel: string;
    startupTimeoutSecs: number;
    supportedInputFormats: DataFormat[];
    supportedOutputFormats: DataFormat[];
    httpConfig?: HTTPConfig | undefined;
    /**
     * Attribute on the module with the implementation, which may differ from function_name
     * when the user provided a custom name= for the Function inside the Application namespace
     */
    implementationName: string;
    /** When True, the function is a server function */
    isServer: boolean;
    /** Where inputs to a function should be routed through. */
    routingRegion: string;
}
declare const FunctionData: MessageFns$1<FunctionData>;
interface FunctionData_RankedFunction {
    rank: number;
    function: FunctionMessage | undefined;
}
declare const FunctionData_RankedFunction: MessageFns$1<FunctionData_RankedFunction>;
interface FunctionFinishInputsRequest {
    functionId: string;
    functionCallId: string;
    numInputs: number;
}
declare const FunctionFinishInputsRequest: MessageFns$1<FunctionFinishInputsRequest>;
interface FunctionGetCallGraphRequest {
    functionCallId: string;
}
declare const FunctionGetCallGraphRequest: MessageFns$1<FunctionGetCallGraphRequest>;
interface FunctionGetCallGraphResponse {
    inputs: InputCallGraphInfo[];
    functionCalls: FunctionCallCallGraphInfo[];
}
declare const FunctionGetCallGraphResponse: MessageFns$1<FunctionGetCallGraphResponse>;
interface FunctionGetCurrentStatsRequest {
    functionId: string;
}
declare const FunctionGetCurrentStatsRequest: MessageFns$1<FunctionGetCurrentStatsRequest>;
interface FunctionGetDynamicConcurrencyRequest {
    functionId: string;
    targetConcurrency: number;
    maxConcurrency: number;
}
declare const FunctionGetDynamicConcurrencyRequest: MessageFns$1<FunctionGetDynamicConcurrencyRequest>;
interface FunctionGetDynamicConcurrencyResponse {
    concurrency: number;
}
declare const FunctionGetDynamicConcurrencyResponse: MessageFns$1<FunctionGetDynamicConcurrencyResponse>;
interface FunctionGetInputsItem {
    inputId: string;
    input: FunctionInput | undefined;
    killSwitch: boolean;
    functionCallId: string;
    functionCallInvocationType: FunctionCallInvocationType;
    retryCount: number;
    /** intercepted and only used by the worker. */
    functionMapIdx?: number | undefined;
    attemptToken: string;
    fromInputPlane: boolean;
}
declare const FunctionGetInputsItem: MessageFns$1<FunctionGetInputsItem>;
interface FunctionGetInputsRequest {
    functionId: string;
    maxValues: number;
    averageCallTime: number;
    /** Container aims to fetch multiple inputs at the same time */
    inputConcurrency: number;
    /** Maximum number of inputs to fetch at once */
    batchMaxSize: number;
    /** Miliseconds to block before a response is needed */
    batchLingerMs: number;
}
declare const FunctionGetInputsRequest: MessageFns$1<FunctionGetInputsRequest>;
interface FunctionGetInputsResponse {
    inputs: FunctionGetInputsItem[];
    /** How long to sleep before requesting another input. */
    rateLimitSleepDuration: number;
}
declare const FunctionGetInputsResponse: MessageFns$1<FunctionGetInputsResponse>;
interface FunctionGetOutputsItem {
    result: GenericResult | undefined;
    idx: number;
    inputId: string;
    /** for result.data_oneof */
    dataFormat: DataFormat;
    taskId: string;
    inputStartedAt: number;
    outputCreatedAt: number;
    retryCount: number;
    /** datadog function call trace tag */
    fcTraceTag: string;
}
declare const FunctionGetOutputsItem: MessageFns$1<FunctionGetOutputsItem>;
interface FunctionGetOutputsRequest {
    functionCallId: string;
    maxValues: number;
    timeout: number;
    lastEntryId: string;
    /** expires *any* remaining outputs soon after this call, not just the returned ones */
    clearOnSuccess: boolean;
    /** Used for waypoints. */
    requestedAt: number;
    /** The jwts the client expects the server to be processing. This is optional and used for sync inputs only. */
    inputJwts: string[];
    /** for async batch requests. this indicates which index to start from. */
    startIdx?: number | undefined;
    /** for async batch requests. this indicates which index to end at. */
    endIdx?: number | undefined;
}
declare const FunctionGetOutputsRequest: MessageFns$1<FunctionGetOutputsRequest>;
interface FunctionGetOutputsResponse {
    idxs: number[];
    outputs: FunctionGetOutputsItem[];
    lastEntryId: string;
    numUnfinishedInputs: number;
}
declare const FunctionGetOutputsResponse: MessageFns$1<FunctionGetOutputsResponse>;
interface FunctionGetRequest {
    appName: string;
    objectTag: string;
    environmentName: string;
    appVersion: number;
}
declare const FunctionGetRequest: MessageFns$1<FunctionGetRequest>;
interface FunctionGetResponse {
    functionId: string;
    handleMetadata: FunctionHandleMetadata | undefined;
    serverWarnings: Warning[];
}
declare const FunctionGetResponse: MessageFns$1<FunctionGetResponse>;
interface FunctionGetSerializedRequest {
    functionId: string;
}
declare const FunctionGetSerializedRequest: MessageFns$1<FunctionGetSerializedRequest>;
interface FunctionGetSerializedResponse {
    functionSerialized: Uint8Array;
    classSerialized: Uint8Array;
}
declare const FunctionGetSerializedResponse: MessageFns$1<FunctionGetSerializedResponse>;
/**
 * contains all the info about a function that is needed to trigger the right
 * behaviour when using a FunctionHandler. Notably excludes things purely
 * used for *executing* the function in a container entrypoint
 */
interface FunctionHandleMetadata {
    /** Should be a subset and use IDs/types from `Function` above */
    functionName: string;
    functionType: Function_FunctionType;
    webUrl: string;
    isMethod: boolean;
    /** used for methods */
    useFunctionId: string;
    /** used for methods */
    useMethodName: string;
    definitionId: string;
    classParameterInfo: ClassParameterInfo | undefined;
    /** Mapping of method names to their metadata, only non-empty for class service functions */
    methodHandleMetadata: {
        [key: string]: FunctionHandleMetadata;
    };
    functionSchema: FunctionSchema | undefined;
    inputPlaneUrl?: string | undefined;
    inputPlaneRegion?: string | undefined;
    /** Use optional to ensure unset values default to None instead of 0 */
    maxObjectSizeBytes?: number | undefined;
    /** (Optional) urls for flash services */
    ExperimentalFlashUrls: string[];
    supportedInputFormats: DataFormat[];
    supportedOutputFormats: DataFormat[];
}
declare const FunctionHandleMetadata: MessageFns$1<FunctionHandleMetadata>;
interface FunctionInput {
    args?: Uint8Array | undefined;
    argsBlobId?: string | undefined;
    finalInput: boolean;
    /** For args_oneof. */
    dataFormat: DataFormat;
    /** specifies which method to call when calling a class/object function */
    methodName?: string | undefined;
}
declare const FunctionInput: MessageFns$1<FunctionInput>;
interface FunctionMapRequest {
    functionId: string;
    parentInputId: string;
    returnExceptions: boolean;
    functionCallType: FunctionCallType;
    pipelinedInputs: FunctionPutInputsItem[];
    functionCallInvocationType: FunctionCallInvocationType;
    fromSpawnMap: boolean;
}
declare const FunctionMapRequest: MessageFns$1<FunctionMapRequest>;
interface FunctionMapResponse {
    functionCallId: string;
    pipelinedInputs: FunctionPutInputsResponseItem[];
    retryPolicy: FunctionRetryPolicy | undefined;
    functionCallJwt: string;
    syncClientRetriesEnabled: boolean;
    maxInputsOutstanding: number;
}
declare const FunctionMapResponse: MessageFns$1<FunctionMapResponse>;
/** todo(ayush): update this to also use `autoscaler_settings` */
interface FunctionOptions$1 {
    secretIds: string[];
    /** Currently not supported */
    mountIds: string[];
    resources?: Resources | undefined;
    retryPolicy?: FunctionRetryPolicy | undefined;
    concurrencyLimit?: number | undefined;
    timeoutSecs?: number | undefined;
    taskIdleTimeoutSecs?: number | undefined;
    warmPoolSize?: number | undefined;
    volumeMounts: VolumeMount[];
    targetConcurrentInputs?: number | undefined;
    replaceVolumeMounts: boolean;
    replaceSecretIds: boolean;
    bufferContainers?: number | undefined;
    maxConcurrentInputs?: number | undefined;
    batchMaxSize?: number | undefined;
    batchLingerMs?: number | undefined;
    schedulerPlacement?: SchedulerPlacement | undefined;
    cloudProviderStr?: string | undefined;
    replaceCloudBucketMounts: boolean;
    cloudBucketMounts: CloudBucketMount$1[];
    pinnedAppVersion?: number | undefined;
}
declare const FunctionOptions$1: MessageFns$1<FunctionOptions$1>;
interface FunctionPrecreateRequest {
    appId: string;
    functionName: string;
    existingFunctionId: string;
    functionType: Function_FunctionType;
    webhookConfig: WebhookConfig | undefined;
    /** for class methods - use this function id instead for invocations - the *referenced* function should have is_class=True */
    useFunctionId: string;
    /** for class methods - this method name needs to be included in the FunctionInput */
    useMethodName: string;
    /** Mapping of method names to method definitions, only non-empty for class service functions */
    methodDefinitions: {
        [key: string]: MethodDefinition;
    };
    functionSchema: FunctionSchema | undefined;
    supportedInputFormats: DataFormat[];
    supportedOutputFormats: DataFormat[];
}
declare const FunctionPrecreateRequest: MessageFns$1<FunctionPrecreateRequest>;
interface FunctionPrecreateResponse {
    functionId: string;
    handleMetadata: FunctionHandleMetadata | undefined;
}
declare const FunctionPrecreateResponse: MessageFns$1<FunctionPrecreateResponse>;
interface FunctionPutInputsItem {
    idx: number;
    input: FunctionInput | undefined;
    r2Failed: boolean;
    r2ThroughputBytesS: number;
}
declare const FunctionPutInputsItem: MessageFns$1<FunctionPutInputsItem>;
interface FunctionPutInputsRequest {
    functionId: string;
    functionCallId: string;
    inputs: FunctionPutInputsItem[];
}
declare const FunctionPutInputsRequest: MessageFns$1<FunctionPutInputsRequest>;
interface FunctionPutInputsResponse {
    inputs: FunctionPutInputsResponseItem[];
}
declare const FunctionPutInputsResponse: MessageFns$1<FunctionPutInputsResponse>;
interface FunctionPutInputsResponseItem {
    idx: number;
    inputId: string;
    inputJwt: string;
}
declare const FunctionPutInputsResponseItem: MessageFns$1<FunctionPutInputsResponseItem>;
interface FunctionPutOutputsItem {
    inputId: string;
    result: GenericResult | undefined;
    inputStartedAt: number;
    outputCreatedAt: number;
    /** for result.data_oneof */
    dataFormat: DataFormat;
    retryCount: number;
    /** injected by the worker */
    functionCallId: string;
    /** injected by the worker */
    functionMapIdx?: number | undefined;
    /** injected by the worker */
    fromInputPlane: boolean;
}
declare const FunctionPutOutputsItem: MessageFns$1<FunctionPutOutputsItem>;
interface FunctionPutOutputsRequest {
    outputs: FunctionPutOutputsItem[];
    /** Used for waypoints. */
    requestedAt: number;
}
declare const FunctionPutOutputsRequest: MessageFns$1<FunctionPutOutputsRequest>;
interface FunctionRetryInputsItem {
    inputJwt: string;
    input: FunctionInput | undefined;
    retryCount: number;
}
declare const FunctionRetryInputsItem: MessageFns$1<FunctionRetryInputsItem>;
interface FunctionRetryInputsRequest {
    functionCallJwt: string;
    inputs: FunctionRetryInputsItem[];
}
declare const FunctionRetryInputsRequest: MessageFns$1<FunctionRetryInputsRequest>;
interface FunctionRetryInputsResponse {
    inputJwts: string[];
}
declare const FunctionRetryInputsResponse: MessageFns$1<FunctionRetryInputsResponse>;
interface FunctionRetryPolicy {
    backoffCoefficient: number;
    initialDelayMs: number;
    maxDelayMs: number;
    /** NOTE: two-byte field number not used for special reason. copy-paste error. Ref: PR #2542 */
    retries: number;
}
declare const FunctionRetryPolicy: MessageFns$1<FunctionRetryPolicy>;
interface FunctionSchema {
    /** allows easy disambiguation between empty schema and no schema collection etc. */
    schemaType: FunctionSchema_FunctionSchemaType;
    arguments: ClassParameterSpec[];
    returnType: GenericPayloadType | undefined;
}
declare const FunctionSchema: MessageFns$1<FunctionSchema>;
interface FunctionStats$1 {
    backlog: number;
    numTotalTasks: number;
    numRunningInputs: number;
    inputHeadroom: number;
}
declare const FunctionStats$1: MessageFns$1<FunctionStats$1>;
interface FunctionUpdateSchedulingParamsRequest {
    functionId: string;
    warmPoolSizeOverride: number;
    settings: AutoscalerSettings | undefined;
}
declare const FunctionUpdateSchedulingParamsRequest: MessageFns$1<FunctionUpdateSchedulingParamsRequest>;
interface FunctionUpdateSchedulingParamsResponse {
}
declare const FunctionUpdateSchedulingParamsResponse: MessageFns$1<FunctionUpdateSchedulingParamsResponse>;
interface GPUConfig {
    /** Deprecated, at some point */
    type: GPUType;
    count: number;
    gpuType: string;
}
declare const GPUConfig: MessageFns$1<GPUConfig>;
interface GenericPayloadType {
    baseType: ParameterType;
    /** sub-type for generic types like lists */
    subTypes: GenericPayloadType[];
}
declare const GenericPayloadType: MessageFns$1<GenericPayloadType>;
/** Used for both tasks and function outputs */
interface GenericResult {
    /** Status of the task or function output. */
    status: GenericResult_GenericStatus;
    /** Exception message for failures, if available. */
    exception: string;
    /** Status code of the container entrypoint or builder process if it terminates unexpectedly. */
    exitcode: number;
    /** String value of the Python traceback. */
    traceback: string;
    /** Pickled traceback object. */
    serializedTb: Uint8Array;
    /** Pickled line cache for traceback object. */
    tbLineCache: Uint8Array;
    /** Inline data of the result. */
    data?: Uint8Array | undefined;
    /** Blob ID for large data. */
    dataBlobId?: string | undefined;
    /** (?) */
    propagationReason: string;
}
declare const GenericResult: MessageFns$1<GenericResult>;
interface HTTPConfig {
    port: number;
    proxyRegions: string[];
    startupTimeout: number;
    exitGracePeriod: number;
    h2Enabled: boolean;
    targetConcurrency: number;
}
declare const HTTPConfig: MessageFns$1<HTTPConfig>;
interface Image$1 {
    baseImages: BaseImage[];
    dockerfileCommands: string[];
    contextFiles: ImageContextFile[];
    version: string;
    secretIds: string[];
    /**
     * Part of Image definition, because presence of GPU drivers
     * affects the image that's built.
     */
    contextMountId: string;
    gpuConfig: GPUConfig | undefined;
    imageRegistryConfig: ImageRegistryConfig | undefined;
    /** deprecated after 0.58.96 */
    buildFunctionDef: string;
    /** deprecated after 0.58.96 */
    buildFunctionGlobals: Uint8Array;
    /** If set, overrides the runtime used by the function. Specify either "runc" or "gvisor". */
    runtime: string;
    /** Not included in image definition checksum as debug features do not affect built image. */
    runtimeDebug: boolean;
    buildFunction: BuildFunction | undefined;
    /** Build arguments for the image (--build-arg) for ARG substitution in Dockerfile. */
    buildArgs: {
        [key: string]: string;
    };
    /** Volume mount for RUN commands */
    volumeMounts: VolumeMount[];
}
declare const Image$1: MessageFns$1<Image$1>;
interface ImageContextFile {
    filename: string;
    data: Uint8Array;
}
declare const ImageContextFile: MessageFns$1<ImageContextFile>;
interface ImageDeleteRequest {
    imageId: string;
}
declare const ImageDeleteRequest: MessageFns$1<ImageDeleteRequest>;
interface ImageFromIdRequest {
    imageId: string;
}
declare const ImageFromIdRequest: MessageFns$1<ImageFromIdRequest>;
interface ImageFromIdResponse {
    imageId: string;
    metadata: ImageMetadata | undefined;
}
declare const ImageFromIdResponse: MessageFns$1<ImageFromIdResponse>;
interface ImageGetByTagRequest {
    /** Full "name:tag" string. Must be non-empty. */
    tag: string;
    environmentName: string;
}
declare const ImageGetByTagRequest: MessageFns$1<ImageGetByTagRequest>;
interface ImageGetByTagResponse {
    imageId: string;
}
declare const ImageGetByTagResponse: MessageFns$1<ImageGetByTagResponse>;
interface ImageGetOrCreateRequest {
    image: Image$1 | undefined;
    appId: string;
    /** ignored */
    existingImageId: string;
    buildFunctionId: string;
    forceBuild: boolean;
    namespace: DeploymentNamespace;
    builderVersion: string;
    /** Only admins can publish global images, but this provides an extra failsafe */
    allowGlobalDeployment: boolean;
    /** Force the Image to build but don't clobber any Images with the same recipe in the cache */
    ignoreCache: boolean;
}
declare const ImageGetOrCreateRequest: MessageFns$1<ImageGetOrCreateRequest>;
interface ImageGetOrCreateResponse {
    /** image_id is set regardless if the image is built (use ImageJoinStreaming to wait for build) */
    imageId: string;
    /** result of build - only set if the image has finished building (regardless if success or not) */
    result: GenericResult | undefined;
    /** image metadata - only set if the image has built successfully */
    metadata: ImageMetadata | undefined;
}
declare const ImageGetOrCreateResponse: MessageFns$1<ImageGetOrCreateResponse>;
interface ImageJoinStreamingRequest {
    imageId: string;
    timeout: number;
    lastEntryId: string;
    includeLogsForFinished: boolean;
}
declare const ImageJoinStreamingRequest: MessageFns$1<ImageJoinStreamingRequest>;
interface ImageJoinStreamingResponse {
    result: GenericResult | undefined;
    taskLogs: TaskLogs[];
    entryId: string;
    eof: boolean;
    /** set on success */
    metadata: ImageMetadata | undefined;
}
declare const ImageJoinStreamingResponse: MessageFns$1<ImageJoinStreamingResponse>;
interface ImageListTagsItem {
    tag: string;
    imageId: string;
    revisionId: string;
    createdAt: number;
    updatedAt: number;
}
declare const ImageListTagsItem: MessageFns$1<ImageListTagsItem>;
interface ImageListTagsRequest {
    environmentName: string;
    /** Prefix search over full "name:tag" strings. */
    tagPrefix: string;
    /** Defaults to 100. Values above 100 are rejected by the server. */
    maxObjects: number;
    pageToken: string;
}
declare const ImageListTagsRequest: MessageFns$1<ImageListTagsRequest>;
interface ImageListTagsResponse {
    items: ImageListTagsItem[];
    nextPageToken: string;
    environmentName: string;
}
declare const ImageListTagsResponse: MessageFns$1<ImageListTagsResponse>;
interface ImageMetadata {
    /** The output of `python -VV. Not set if missing */
    pythonVersionInfo?: string | undefined;
    /**
     * Installed python packages, as listed by by `pip list`.
     * package name -> version. Empty if missing
     */
    pythonPackages: {
        [key: string]: string;
    };
    /**
     * The working directory of the image, as an absolute file path.
     *
     * For most images, this is not set, which means to use the default workdir:
     * - On function runners, the default is `/root` (home directory).
     * - For image builds and sandbox environments, it is `/`.
     */
    workdir?: string | undefined;
    /** The version of glibc in this image, if any. */
    libcVersionInfo?: string | undefined;
    /** The builder version for/with which the image was created. */
    imageBuilderVersion?: string | undefined;
}
declare const ImageMetadata: MessageFns$1<ImageMetadata>;
interface ImagePublishRequest {
    imageId: string;
    /** Full "name:tag" string. Must be non-empty. Each ImagePublish RPC writes exactly one tag. */
    tag: string;
    environmentName: string;
    /** Marks the published tag as public. Public read protocol is defined separately. */
    isPublic: boolean;
}
declare const ImagePublishRequest: MessageFns$1<ImagePublishRequest>;
interface ImagePublishResponse {
    imageId: string;
    revisionId: string;
}
declare const ImagePublishResponse: MessageFns$1<ImagePublishResponse>;
interface ImageRegistryConfig {
    registryAuthType: RegistryAuthType;
    secretId: string;
}
declare const ImageRegistryConfig: MessageFns$1<ImageRegistryConfig>;
interface ImageTagRevisionsItem {
    imageId: string;
    revisionId: string;
    createdAt: number;
}
declare const ImageTagRevisionsItem: MessageFns$1<ImageTagRevisionsItem>;
interface ImageTagRevisionsRequest {
    /** Full "name:tag" string. Must be non-empty. */
    tag: string;
    environmentName: string;
    /** Defaults to 100. Values above 100 are rejected by the server. */
    maxObjects: number;
    pageToken: string;
}
declare const ImageTagRevisionsRequest: MessageFns$1<ImageTagRevisionsRequest>;
interface ImageTagRevisionsResponse {
    items: ImageTagRevisionsItem[];
    nextPageToken: string;
    tag: string;
    environmentName: string;
}
declare const ImageTagRevisionsResponse: MessageFns$1<ImageTagRevisionsResponse>;
interface InputCallGraphInfo {
    inputId: string;
    status: GenericResult_GenericStatus;
    functionCallId: string;
    taskId: string;
}
declare const InputCallGraphInfo: MessageFns$1<InputCallGraphInfo>;
interface InputCategoryInfo {
    total: number;
    latest: InputInfo[];
}
declare const InputCategoryInfo: MessageFns$1<InputCategoryInfo>;
interface InputInfo {
    inputId: string;
    idx: number;
    taskId: string;
    startedAt: number;
    finishedAt: number;
    taskStartupTime: number;
    taskFirstInput: boolean;
}
declare const InputInfo: MessageFns$1<InputInfo>;
interface ListPagination {
    maxObjects: number;
    createdBefore: number;
}
declare const ListPagination: MessageFns$1<ListPagination>;
interface MapAwaitRequest {
    functionCallId?: string | undefined;
    mapToken?: string | undefined;
    lastEntryId: string;
    /** Used for waypoints. */
    requestedAt: number;
    timeout: number;
}
declare const MapAwaitRequest: MessageFns$1<MapAwaitRequest>;
interface MapAwaitResponse {
    outputs: FunctionGetOutputsItem[];
    lastEntryId: string;
}
declare const MapAwaitResponse: MessageFns$1<MapAwaitResponse>;
interface MapCheckInputsRequest {
    lastEntryId: string;
    timeout: number;
    attemptTokens: string[];
}
declare const MapCheckInputsRequest: MessageFns$1<MapCheckInputsRequest>;
interface MapCheckInputsResponse {
    lost: boolean[];
}
declare const MapCheckInputsResponse: MessageFns$1<MapCheckInputsResponse>;
interface MapStartOrContinueItem {
    input: FunctionPutInputsItem | undefined;
    /** None if this is a fresh input, otherwise it is the attempt token for a retry. */
    attemptToken?: string | undefined;
}
declare const MapStartOrContinueItem: MessageFns$1<MapStartOrContinueItem>;
interface MapStartOrContinueRequest {
    functionId: string;
    parentInputId: string;
    functionCallId?: string | undefined;
    mapToken?: string | undefined;
    items: MapStartOrContinueItem[];
}
declare const MapStartOrContinueRequest: MessageFns$1<MapStartOrContinueRequest>;
interface MapStartOrContinueResponse {
    /**
     * function_id and function_call_id are not necessary if map_token is provided.
     * All 3 will be sent until it is safe to only send map_token.
     */
    mapToken: string;
    functionId: string;
    functionCallId: string;
    maxInputsOutstanding: number;
    attemptTokens: string[];
    retryPolicy: FunctionRetryPolicy | undefined;
}
declare const MapStartOrContinueResponse: MessageFns$1<MapStartOrContinueResponse>;
interface MethodDefinition {
    functionName: string;
    functionType: Function_FunctionType;
    webhookConfig: WebhookConfig | undefined;
    webUrl: string;
    webUrlInfo: WebUrlInfo | undefined;
    customDomainInfo: CustomDomainInfo[];
    functionSchema: FunctionSchema | undefined;
    supportedInputFormats: DataFormat[];
    supportedOutputFormats: DataFormat[];
}
declare const MethodDefinition: MessageFns$1<MethodDefinition>;
interface MountFile {
    filename: string;
    /** SHA-256 checksum of the file. */
    sha256Hex: string;
    /** Size of the file in bytes — ignored in MountBuild(). */
    size?: number | undefined;
    /** Unix file permission bits `st_mode`. */
    mode?: number | undefined;
}
declare const MountFile: MessageFns$1<MountFile>;
interface MountGetOrCreateRequest {
    deploymentName: string;
    namespace: DeploymentNamespace;
    environmentName: string;
    objectCreationType: ObjectCreationType;
    files: MountFile[];
    /** only used with OBJECT_CREATION_TYPE_ANONYMOUS_OWNED_BY_APP */
    appId: string;
}
declare const MountGetOrCreateRequest: MessageFns$1<MountGetOrCreateRequest>;
interface MountGetOrCreateResponse {
    mountId: string;
    handleMetadata: MountHandleMetadata | undefined;
}
declare const MountGetOrCreateResponse: MessageFns$1<MountGetOrCreateResponse>;
interface MountHandleMetadata {
    contentChecksumSha256Hex: string;
}
declare const MountHandleMetadata: MessageFns$1<MountHandleMetadata>;
interface MountPutFileRequest {
    sha256Hex: string;
    data?: Uint8Array | undefined;
    dataBlobId?: string | undefined;
}
declare const MountPutFileRequest: MessageFns$1<MountPutFileRequest>;
interface MountPutFileResponse {
    exists: boolean;
}
declare const MountPutFileResponse: MessageFns$1<MountPutFileResponse>;
interface MultiPartUpload {
    /** split upload based on this part length - all except the last part must have this length */
    partLength: number;
    uploadUrls: string[];
    completionUrl: string;
}
declare const MultiPartUpload: MessageFns$1<MultiPartUpload>;
interface MultiPartUploadList {
    items: MultiPartUpload[];
}
declare const MultiPartUploadList: MessageFns$1<MultiPartUploadList>;
interface NetworkAccess {
    networkAccessType: NetworkAccess_NetworkAccessType;
    allowedCidrs: string[];
    allowedDomains: string[];
}
declare const NetworkAccess: MessageFns$1<NetworkAccess>;
interface NotebookKernelPublishResultsRequest {
    notebookId: string;
    results: NotebookKernelPublishResultsRequest_CellResult[];
}
declare const NotebookKernelPublishResultsRequest: MessageFns$1<NotebookKernelPublishResultsRequest>;
/**
 * See kernelshim.py for the differences between this and `ExecuteResult`.
 * https://jupyter-client.readthedocs.io/en/stable/messaging.html#execution-results
 */
interface NotebookKernelPublishResultsRequest_ExecuteReply {
    status: string;
    executionCount: number;
    duration: number;
}
declare const NotebookKernelPublishResultsRequest_ExecuteReply: MessageFns$1<NotebookKernelPublishResultsRequest_ExecuteReply>;
/** IOPub message or reply received from the kernel for a cell. */
interface NotebookKernelPublishResultsRequest_CellResult {
    cellId: string;
    /** Persistent output that is saved in the notebook. */
    output?: NotebookOutput | undefined;
    /** Clear all previous outputs of the cell. */
    clearOutput?: boolean | undefined;
    /** Cell has finished executing, return the kernel's execute_reply. */
    executeReply?: NotebookKernelPublishResultsRequest_ExecuteReply | undefined;
}
declare const NotebookKernelPublishResultsRequest_CellResult: MessageFns$1<NotebookKernelPublishResultsRequest_CellResult>;
/**
 * A single output from a notebook. When you execute a cell, it produces an
 * array of these outputs as the code runs.
 *
 * https://github.com/jupyter/nbformat/blob/v5.10.4/nbformat/v4/nbformat.v4.schema.json#L301-L309
 */
interface NotebookOutput {
    executeResult?: NotebookOutput_ExecuteResult | undefined;
    displayData?: NotebookOutput_DisplayData | undefined;
    stream?: NotebookOutput_Stream | undefined;
    error?: NotebookOutput_Error | undefined;
}
declare const NotebookOutput: MessageFns$1<NotebookOutput>;
/** Result of executing a code cell. */
interface NotebookOutput_ExecuteResult {
    executionCount: number;
    /** mimebundle */
    data: {
        [key: string]: any;
    } | undefined;
    metadata: {
        [key: string]: any;
    } | undefined;
}
declare const NotebookOutput_ExecuteResult: MessageFns$1<NotebookOutput_ExecuteResult>;
/** Data displayed as a result of code cell execution. */
interface NotebookOutput_DisplayData {
    /** mimebundle */
    data: {
        [key: string]: any;
    } | undefined;
    metadata: {
        [key: string]: any;
    } | undefined;
    /** This should not be included in saved notebook. */
    transientDisplayId?: string | undefined;
}
declare const NotebookOutput_DisplayData: MessageFns$1<NotebookOutput_DisplayData>;
/** Stream output from a code cell (stdout / stderr). */
interface NotebookOutput_Stream {
    /** stdout | stderr */
    name: string;
    /** multiline_string */
    text: string;
}
declare const NotebookOutput_Stream: MessageFns$1<NotebookOutput_Stream>;
/** Output of an error that occurred during code cell execution. */
interface NotebookOutput_Error {
    ename: string;
    evalue: string;
    traceback: string[];
}
declare const NotebookOutput_Error: MessageFns$1<NotebookOutput_Error>;
interface Object_ {
    objectId: string;
    functionHandleMetadata?: FunctionHandleMetadata | undefined;
    mountHandleMetadata?: MountHandleMetadata | undefined;
    classHandleMetadata?: ClassHandleMetadata | undefined;
    sandboxHandleMetadata?: SandboxHandleMetadata | undefined;
    volumeMetadata?: VolumeMetadata | undefined;
}
declare const Object_: MessageFns$1<Object_>;
interface ObjectDependency {
    objectId: string;
}
declare const ObjectDependency: MessageFns$1<ObjectDependency>;
interface PTYInfo {
    /** Soon deprecated */
    enabled: boolean;
    winszRows: number;
    winszCols: number;
    envTerm: string;
    envColorterm: string;
    envTermProgram: string;
    ptyType: PTYInfo_PTYType;
    noTerminateOnIdleStdin: boolean;
}
declare const PTYInfo: MessageFns$1<PTYInfo>;
interface PortSpec {
    port: number;
    unencrypted: boolean;
    tunnelType?: TunnelType | undefined;
}
declare const PortSpec: MessageFns$1<PortSpec>;
interface PortSpecs {
    ports: PortSpec[];
}
declare const PortSpecs: MessageFns$1<PortSpecs>;
interface Probe$1 {
    tcpPort?: number | undefined;
    execCommand?: Probe_ExecCommand | undefined;
    intervalMs?: number | undefined;
}
declare const Probe$1: MessageFns$1<Probe$1>;
interface Probe_ExecCommand {
    /** Command and args to execute directly (argv form, not shell-parsed). */
    argv: string[];
}
declare const Probe_ExecCommand: MessageFns$1<Probe_ExecCommand>;
interface Proxy$1 {
    name: string;
    createdAt: number;
    environmentName: string;
    proxyIps: ProxyIp[];
    proxyId: string;
    region: string;
}
declare const Proxy$1: MessageFns$1<Proxy$1>;
interface ProxyAddIpRequest {
    proxyId: string;
}
declare const ProxyAddIpRequest: MessageFns$1<ProxyAddIpRequest>;
interface ProxyAddIpResponse {
    proxyIp: ProxyIp | undefined;
}
declare const ProxyAddIpResponse: MessageFns$1<ProxyAddIpResponse>;
interface ProxyCreateRequest {
    name: string;
    environmentName: string;
    region: string;
}
declare const ProxyCreateRequest: MessageFns$1<ProxyCreateRequest>;
interface ProxyCreateResponse {
    proxy: Proxy$1 | undefined;
}
declare const ProxyCreateResponse: MessageFns$1<ProxyCreateResponse>;
interface ProxyDeleteRequest {
    proxyId: string;
}
declare const ProxyDeleteRequest: MessageFns$1<ProxyDeleteRequest>;
interface ProxyGetOrCreateRequest {
    deploymentName: string;
    environmentName: string;
    /** must be UNSPECIFIED */
    objectCreationType: ObjectCreationType;
}
declare const ProxyGetOrCreateRequest: MessageFns$1<ProxyGetOrCreateRequest>;
interface ProxyGetOrCreateResponse {
    proxyId: string;
}
declare const ProxyGetOrCreateResponse: MessageFns$1<ProxyGetOrCreateResponse>;
interface ProxyGetRequest {
    name: string;
    environmentName: string;
}
declare const ProxyGetRequest: MessageFns$1<ProxyGetRequest>;
interface ProxyGetResponse {
    proxy: Proxy$1 | undefined;
}
declare const ProxyGetResponse: MessageFns$1<ProxyGetResponse>;
interface ProxyIp {
    proxyIp: string;
    status: ProxyIpStatus;
    createdAt: number;
    environmentName: string;
}
declare const ProxyIp: MessageFns$1<ProxyIp>;
interface ProxyListResponse {
    proxies: Proxy$1[];
}
declare const ProxyListResponse: MessageFns$1<ProxyListResponse>;
interface ProxyRemoveIpRequest {
    proxyIp: string;
}
declare const ProxyRemoveIpRequest: MessageFns$1<ProxyRemoveIpRequest>;
interface QueueClearRequest {
    queueId: string;
    partitionKey: Uint8Array;
    allPartitions: boolean;
}
declare const QueueClearRequest: MessageFns$1<QueueClearRequest>;
interface QueueDeleteRequest {
    queueId: string;
}
declare const QueueDeleteRequest: MessageFns$1<QueueDeleteRequest>;
interface QueueGetByIdRequest {
    queueId: string;
}
declare const QueueGetByIdRequest: MessageFns$1<QueueGetByIdRequest>;
interface QueueGetByIdResponse {
    queueId: string;
    metadata: QueueMetadata | undefined;
}
declare const QueueGetByIdResponse: MessageFns$1<QueueGetByIdResponse>;
interface QueueGetOrCreateRequest {
    deploymentName: string;
    environmentName: string;
    objectCreationType: ObjectCreationType;
}
declare const QueueGetOrCreateRequest: MessageFns$1<QueueGetOrCreateRequest>;
interface QueueGetOrCreateResponse {
    queueId: string;
    metadata: QueueMetadata | undefined;
}
declare const QueueGetOrCreateResponse: MessageFns$1<QueueGetOrCreateResponse>;
interface QueueGetRequest {
    queueId: string;
    timeout: number;
    nValues: number;
    partitionKey: Uint8Array;
}
declare const QueueGetRequest: MessageFns$1<QueueGetRequest>;
interface QueueGetResponse {
    values: Uint8Array[];
}
declare const QueueGetResponse: MessageFns$1<QueueGetResponse>;
interface QueueHeartbeatRequest {
    queueId: string;
}
declare const QueueHeartbeatRequest: MessageFns$1<QueueHeartbeatRequest>;
interface QueueItem {
    value: Uint8Array;
    entryId: string;
}
declare const QueueItem: MessageFns$1<QueueItem>;
interface QueueLenRequest {
    queueId: string;
    partitionKey: Uint8Array;
    total: boolean;
}
declare const QueueLenRequest: MessageFns$1<QueueLenRequest>;
interface QueueLenResponse {
    len: number;
}
declare const QueueLenResponse: MessageFns$1<QueueLenResponse>;
interface QueueListRequest {
    environmentName: string;
    /** Limit on "number of partitions" reported, since checking them is costly */
    totalSizeLimit: number;
    pagination: ListPagination | undefined;
}
declare const QueueListRequest: MessageFns$1<QueueListRequest>;
interface QueueListResponse {
    queues: QueueListResponse_QueueInfo[];
    environmentName: string;
}
declare const QueueListResponse: MessageFns$1<QueueListResponse>;
interface QueueListResponse_QueueInfo {
    name: string;
    /** Superseded by metadata, used by clients up to 1.1.2 */
    createdAt: number;
    numPartitions: number;
    totalSize: number;
    queueId: string;
    metadata: QueueMetadata | undefined;
}
declare const QueueListResponse_QueueInfo: MessageFns$1<QueueListResponse_QueueInfo>;
interface QueueMetadata {
    name: string;
    creationInfo: CreationInfo | undefined;
}
declare const QueueMetadata: MessageFns$1<QueueMetadata>;
interface QueueNextItemsRequest {
    queueId: string;
    partitionKey: Uint8Array;
    lastEntryId: string;
    /** seconds */
    itemPollTimeout: number;
}
declare const QueueNextItemsRequest: MessageFns$1<QueueNextItemsRequest>;
interface QueueNextItemsResponse {
    items: QueueItem[];
}
declare const QueueNextItemsResponse: MessageFns$1<QueueNextItemsResponse>;
interface QueuePutRequest {
    queueId: string;
    values: Uint8Array[];
    partitionKey: Uint8Array;
    partitionTtlSeconds: number;
}
declare const QueuePutRequest: MessageFns$1<QueuePutRequest>;
interface RateLimit {
    limit: number;
    interval: RateLimitInterval;
}
declare const RateLimit: MessageFns$1<RateLimit>;
interface ResourceInfo {
    /** MiB */
    memoryMb: ResourceInfo_ResourceValue | undefined;
    /** milli CPU cores */
    milliCpu: ResourceInfo_ResourceValue | undefined;
    gpuType: string;
    /** MiB */
    memoryMbMax: number;
    /** MiB */
    ephemeralDiskMb: number;
    /** milli CPU cores */
    milliCpuMax: number;
}
declare const ResourceInfo: MessageFns$1<ResourceInfo>;
interface ResourceInfo_ResourceValue {
    value: number;
    isDefault: boolean;
}
declare const ResourceInfo_ResourceValue: MessageFns$1<ResourceInfo_ResourceValue>;
interface Resources {
    /** MiB */
    memoryMb: number;
    /** milli CPU cores */
    milliCpu: number;
    gpuConfig: GPUConfig | undefined;
    /** MiB */
    memoryMbMax: number;
    /** MiB */
    ephemeralDiskMb: number;
    /** milli CPU cores */
    milliCpuMax: number;
    /** Whether to use RDMA interfaces */
    rdma: boolean;
}
declare const Resources: MessageFns$1<Resources>;
interface RuntimeInputMessage {
    message: Uint8Array;
    messageIndex: number;
    eof: boolean;
}
declare const RuntimeInputMessage: MessageFns$1<RuntimeInputMessage>;
interface RuntimeOutputBatch {
    items: RuntimeOutputMessage[];
    batchIndex: number;
    /** if an exit code is given, this is the final message that will be sent. */
    exitCode?: number | undefined;
    stdout: RuntimeOutputMessage[];
    stderr: RuntimeOutputMessage[];
    info: RuntimeOutputMessage[];
}
declare const RuntimeOutputBatch: MessageFns$1<RuntimeOutputBatch>;
/** Used for `modal container exec`, `modal shell`, and Sandboxes */
interface RuntimeOutputMessage {
    /** only stdout / stderr is used */
    fileDescriptor: FileDescriptor;
    message: string;
    messageBytes: Uint8Array;
}
declare const RuntimeOutputMessage: MessageFns$1<RuntimeOutputMessage>;
interface S3Mount {
    bucketName: string;
    mountPath: string;
    credentialsSecretId: string;
    readOnly: boolean;
}
declare const S3Mount: MessageFns$1<S3Mount>;
interface Sandbox$1 {
    entrypointArgs: string[];
    mountIds: string[];
    imageId: string;
    secretIds: string[];
    resources: Resources | undefined;
    /** Deprecated at some point */
    cloudProvider: CloudProvider;
    /** The max lifetime of a sandbox in seconds. */
    timeoutSecs: number;
    workdir?: string | undefined;
    nfsMounts: SharedVolumeMount[];
    /** For internal debugging use only. */
    runtimeDebug: boolean;
    /** deprecated, use network_access instead */
    blockNetwork: boolean;
    s3Mounts: S3Mount[];
    cloudBucketMounts: CloudBucketMount$1[];
    volumeMounts: VolumeMount[];
    ptyInfo: PTYInfo | undefined;
    schedulerPlacement?: SchedulerPlacement | undefined;
    /** for internal debugging use only */
    workerId: string;
    openPorts?: PortSpecs | undefined;
    i6pnEnabled: boolean;
    /** Network access configuration beyond simple allow/block. */
    networkAccess: NetworkAccess | undefined;
    proxyId?: string | undefined;
    /**
     * Enable snapshotting the sandbox (both memory and filesystem).
     * This doesn't need to be enabled to save the filesystem as an image (i.e. a filesystem-only snapshot).
     */
    enableSnapshot: boolean;
    /**
     * Used to pin gVisor version for memory-snapshottable sandboxes.
     * This field is set by the server, not the client.
     */
    snapshotVersion?: number | undefined;
    /** Supersedes cloud_provider */
    cloudProviderStr: string;
    /**
     * Specifies container runtime behavior for sandboxes which are restored from a snapshot.
     * Set by the backend at snapshot creation time.
     */
    runscRuntimeVersion?: string | undefined;
    /** If set, overrides the runtime used by the function, either "runc" or "gvisor". */
    runtime?: string | undefined;
    /** If set, the sandbox will be created with verbose logging enabled. */
    verbose: boolean;
    /** If set, the sandbox will be created with a name. */
    name?: string | undefined;
    /**
     * Deprecated: use experimental_options_v2 instead.
     *
     * @deprecated
     */
    experimentalOptions: {
        [key: string]: boolean;
    };
    /** Experimental options */
    experimentalOptionsV2: {
        [key: string]: string;
    };
    /** Internal use only. */
    preloadPathPrefixes: string[];
    /** Optional idle timeout in seconds. If set, the sandbox will be terminated after being idle for this duration. */
    idleTimeoutSecs?: number | undefined;
    /**
     * Deprecated: direct sandbox commands are always enabled.
     *
     * @deprecated
     */
    directSandboxCommandsEnabled: boolean;
    /**
     * Internal: restricts sandbox to run on this specific instance type.
     * Set by server during SandboxRestore to ensure the restored sandbox runs
     * on the same instance type as the original snapshot.
     */
    RestoreInstanceType: string;
    /** If set, connections to this sandbox will be subdomains of this domain rather than the default. */
    customDomain: string;
    /**
     * If set, the sandbox will receive a MODAL_IDENTITY_TOKEN env var,
     * similar to how modal Function containers do. This can be used
     * for OIDC-based authentication (e.g. to AWS, GCP).
     */
    includeOidcIdentityToken: boolean;
    /** Probe used to determine when the sandbox has become ready. */
    readinessProbe?: Probe$1 | undefined;
    /**
     * If set, only connections from these CIDRs will be allowed to connect to the sandbox
     * (tunnels and auth proxy).
     */
    inboundCidrAllowlist: string[];
    environmentVariables: StringMap | undefined;
}
declare const Sandbox$1: MessageFns$1<Sandbox$1>;
interface SandboxCreateConnectTokenRequest {
    sandboxId: string;
    userMetadata: string;
    /** Uses port 8080 if unspecified. */
    port?: number | undefined;
}
declare const SandboxCreateConnectTokenRequest: MessageFns$1<SandboxCreateConnectTokenRequest>;
interface SandboxCreateConnectTokenResponse {
    url: string;
    token: string;
}
declare const SandboxCreateConnectTokenResponse: MessageFns$1<SandboxCreateConnectTokenResponse>;
interface SandboxCreateRequest {
    appId: string;
    definition: Sandbox$1 | undefined;
    /** DEPRECATED* 7/16/2025 */
    environmentName: string;
    tags: SandboxTag[];
}
declare const SandboxCreateRequest: MessageFns$1<SandboxCreateRequest>;
interface SandboxCreateResponse {
    sandboxId: string;
}
declare const SandboxCreateResponse: MessageFns$1<SandboxCreateResponse>;
interface SandboxCreateV2Request {
    appId: string;
    definition: Sandbox$1 | undefined;
}
declare const SandboxCreateV2Request: MessageFns$1<SandboxCreateV2Request>;
interface SandboxCreateV2Response {
    sandboxId: string;
    tunnels: TunnelData[];
    taskId: string;
}
declare const SandboxCreateV2Response: MessageFns$1<SandboxCreateV2Response>;
/**
 * Used by the sandbox controller to get command router access for V2 sandboxes.
 * For all other use cases, use TaskGetCommandRouterAccess instead.
 */
interface SandboxGetCommandRouterAccessRequest {
    sandboxId: string;
}
declare const SandboxGetCommandRouterAccessRequest: MessageFns$1<SandboxGetCommandRouterAccessRequest>;
interface SandboxGetCommandRouterAccessResponse {
    jwt: string;
    url: string;
    /**
     * Worker's public IPv4 address. When set, clients should connect directly
     * to this IP while still using the URL's hostname for TLS SNI and the
     * HTTP/2 :authority header.
     */
    workerIpv4Address: string;
}
declare const SandboxGetCommandRouterAccessResponse: MessageFns$1<SandboxGetCommandRouterAccessResponse>;
interface SandboxGetFromNameRequest {
    sandboxName: string;
    environmentName: string;
    appName: string;
}
declare const SandboxGetFromNameRequest: MessageFns$1<SandboxGetFromNameRequest>;
interface SandboxGetFromNameResponse {
    sandboxId: string;
}
declare const SandboxGetFromNameResponse: MessageFns$1<SandboxGetFromNameResponse>;
interface SandboxGetLogsRequest {
    sandboxId: string;
    fileDescriptor: FileDescriptor;
    timeout: number;
    lastEntryId: string;
}
declare const SandboxGetLogsRequest: MessageFns$1<SandboxGetLogsRequest>;
interface SandboxGetResourceUsageRequest {
    sandboxId: string;
}
declare const SandboxGetResourceUsageRequest: MessageFns$1<SandboxGetResourceUsageRequest>;
interface SandboxGetResourceUsageResponse {
    cpuCoreNanosecs: number;
    memGibNanosecs: number;
    gpuNanosecs: number;
    gpuType?: string | undefined;
}
declare const SandboxGetResourceUsageResponse: MessageFns$1<SandboxGetResourceUsageResponse>;
interface SandboxGetTaskIdRequest {
    sandboxId: string;
    /** Legacy clients do not provide a timeout. New clients must always provide a timeout. */
    timeout?: number | undefined;
    /** If true, waits until the container's postStart hook has been run before returning. Useful for detecting init failures. */
    waitUntilReady: boolean;
}
declare const SandboxGetTaskIdRequest: MessageFns$1<SandboxGetTaskIdRequest>;
interface SandboxGetTaskIdResponse {
    /** This is None if the sandbox was terminated before a task could be scheduled. */
    taskId?: string | undefined;
    /** If the task has already exited, this is the result. */
    taskResult?: GenericResult | undefined;
}
declare const SandboxGetTaskIdResponse: MessageFns$1<SandboxGetTaskIdResponse>;
interface SandboxGetTunnelsRequest {
    sandboxId: string;
    timeout: number;
}
declare const SandboxGetTunnelsRequest: MessageFns$1<SandboxGetTunnelsRequest>;
interface SandboxGetTunnelsResponse {
    result: GenericResult | undefined;
    tunnels: TunnelData[];
}
declare const SandboxGetTunnelsResponse: MessageFns$1<SandboxGetTunnelsResponse>;
interface SandboxHandleMetadata {
    result: GenericResult | undefined;
}
declare const SandboxHandleMetadata: MessageFns$1<SandboxHandleMetadata>;
interface SandboxInfo {
    id: string;
    createdAt: number;
    taskInfo: TaskInfo | undefined;
    appId: string;
    /** TODO: Not yet exposed in client library. */
    tags: SandboxTag[];
    name: string;
    imageId: string;
    resourceInfo: ResourceInfo | undefined;
    regions: string[];
    timeoutSecs: number;
    idleTimeoutSecs?: number | undefined;
    readyAt?: number | undefined;
    readinessProbe?: Probe$1 | undefined;
    tunnels: TunnelData[];
}
declare const SandboxInfo: MessageFns$1<SandboxInfo>;
interface SandboxListRequest {
    appId: string;
    beforeTimestamp: number;
    environmentName: string;
    includeFinished: boolean;
    tags: SandboxTag[];
}
declare const SandboxListRequest: MessageFns$1<SandboxListRequest>;
interface SandboxListResponse {
    sandboxes: SandboxInfo[];
}
declare const SandboxListResponse: MessageFns$1<SandboxListResponse>;
interface SandboxRestoreRequest {
    snapshotId: string;
    sandboxNameOverride: string;
    sandboxNameOverrideType: SandboxRestoreRequest_SandboxNameOverrideType;
    /** For internal debugging use only. */
    workerId: string;
}
declare const SandboxRestoreRequest: MessageFns$1<SandboxRestoreRequest>;
interface SandboxRestoreResponse {
    sandboxId: string;
}
declare const SandboxRestoreResponse: MessageFns$1<SandboxRestoreResponse>;
interface SandboxSnapshotFsAsyncGetRequest {
    imageId: string;
    timeout: number;
}
declare const SandboxSnapshotFsAsyncGetRequest: MessageFns$1<SandboxSnapshotFsAsyncGetRequest>;
interface SandboxSnapshotFsAsyncRequest {
    sandboxId: string;
}
declare const SandboxSnapshotFsAsyncRequest: MessageFns$1<SandboxSnapshotFsAsyncRequest>;
interface SandboxSnapshotFsAsyncResponse {
    imageId: string;
}
declare const SandboxSnapshotFsAsyncResponse: MessageFns$1<SandboxSnapshotFsAsyncResponse>;
interface SandboxSnapshotFsRequest {
    sandboxId: string;
    timeout: number;
}
declare const SandboxSnapshotFsRequest: MessageFns$1<SandboxSnapshotFsRequest>;
interface SandboxSnapshotFsResponse {
    imageId: string;
    result: GenericResult | undefined;
    /** Metadata may be empty since we may skip it for performance reasons. */
    imageMetadata: ImageMetadata | undefined;
}
declare const SandboxSnapshotFsResponse: MessageFns$1<SandboxSnapshotFsResponse>;
interface SandboxSnapshotGetRequest {
    snapshotId: string;
}
declare const SandboxSnapshotGetRequest: MessageFns$1<SandboxSnapshotGetRequest>;
interface SandboxSnapshotGetResponse {
    snapshotId: string;
}
declare const SandboxSnapshotGetResponse: MessageFns$1<SandboxSnapshotGetResponse>;
interface SandboxSnapshotRequest {
    sandboxId: string;
}
declare const SandboxSnapshotRequest: MessageFns$1<SandboxSnapshotRequest>;
interface SandboxSnapshotResponse {
    snapshotId: string;
}
declare const SandboxSnapshotResponse: MessageFns$1<SandboxSnapshotResponse>;
interface SandboxSnapshotWaitRequest {
    snapshotId: string;
    timeout: number;
}
declare const SandboxSnapshotWaitRequest: MessageFns$1<SandboxSnapshotWaitRequest>;
interface SandboxSnapshotWaitResponse {
    result: GenericResult | undefined;
}
declare const SandboxSnapshotWaitResponse: MessageFns$1<SandboxSnapshotWaitResponse>;
interface SandboxStdinWriteRequest {
    sandboxId: string;
    input: Uint8Array;
    index: number;
    eof: boolean;
}
declare const SandboxStdinWriteRequest: MessageFns$1<SandboxStdinWriteRequest>;
interface SandboxStdinWriteResponse {
}
declare const SandboxStdinWriteResponse: MessageFns$1<SandboxStdinWriteResponse>;
interface SandboxTag {
    tagName: string;
    tagValue: string;
}
declare const SandboxTag: MessageFns$1<SandboxTag>;
interface SandboxTagsGetRequest {
    sandboxId: string;
}
declare const SandboxTagsGetRequest: MessageFns$1<SandboxTagsGetRequest>;
interface SandboxTagsGetResponse {
    tags: SandboxTag[];
}
declare const SandboxTagsGetResponse: MessageFns$1<SandboxTagsGetResponse>;
interface SandboxTagsSetRequest {
    environmentName: string;
    sandboxId: string;
    tags: SandboxTag[];
}
declare const SandboxTagsSetRequest: MessageFns$1<SandboxTagsSetRequest>;
interface SandboxTerminateRequest {
    sandboxId: string;
}
declare const SandboxTerminateRequest: MessageFns$1<SandboxTerminateRequest>;
interface SandboxTerminateResponse {
    existingResult: GenericResult | undefined;
}
declare const SandboxTerminateResponse: MessageFns$1<SandboxTerminateResponse>;
interface SandboxWaitRequest {
    sandboxId: string;
    timeout: number;
}
declare const SandboxWaitRequest: MessageFns$1<SandboxWaitRequest>;
interface SandboxWaitResponse {
    result: GenericResult | undefined;
}
declare const SandboxWaitResponse: MessageFns$1<SandboxWaitResponse>;
interface SandboxWaitUntilReadyRequest {
    sandboxId: string;
    timeout: number;
}
declare const SandboxWaitUntilReadyRequest: MessageFns$1<SandboxWaitUntilReadyRequest>;
interface SandboxWaitUntilReadyResponse {
    readyAt: number;
}
declare const SandboxWaitUntilReadyResponse: MessageFns$1<SandboxWaitUntilReadyResponse>;
interface Schedule {
    cron?: Schedule_Cron | undefined;
    period?: Schedule_Period | undefined;
}
declare const Schedule: MessageFns$1<Schedule>;
interface Schedule_Cron {
    cronString: string;
    timezone: string;
}
declare const Schedule_Cron: MessageFns$1<Schedule_Cron>;
interface Schedule_Period {
    years: number;
    months: number;
    weeks: number;
    days: number;
    hours: number;
    minutes: number;
    seconds: number;
}
declare const Schedule_Period: MessageFns$1<Schedule_Period>;
/** Scheduling constraints for Functions and Sandboxes. */
interface SchedulerPlacement {
    regions: string[];
    /** @deprecated */
    Zone?: string | undefined;
    /** @deprecated */
    Lifecycle?: string | undefined;
    /** @deprecated */
    InstanceTypes: string[];
    /** Functions only */
    nonpreemptible: boolean;
}
declare const SchedulerPlacement: MessageFns$1<SchedulerPlacement>;
interface SecretDeleteRequest {
    secretId: string;
}
declare const SecretDeleteRequest: MessageFns$1<SecretDeleteRequest>;
interface SecretGetOrCreateRequest {
    deploymentName: string;
    environmentName: string;
    /** Not used atm */
    objectCreationType: ObjectCreationType;
    envDict: {
        [key: string]: string;
    };
    /** only used with OBJECT_CREATION_TYPE_ANONYMOUS_OWNED_BY_APP */
    appId: string;
    requiredKeys: string[];
}
declare const SecretGetOrCreateRequest: MessageFns$1<SecretGetOrCreateRequest>;
interface SecretGetOrCreateResponse {
    secretId: string;
    metadata: SecretMetadata | undefined;
}
declare const SecretGetOrCreateResponse: MessageFns$1<SecretGetOrCreateResponse>;
interface SecretListItem {
    label: string;
    /** Superseded by metadata, used by clients up to 1.1.2 */
    createdAt: number;
    lastUsedAt: number;
    /** Unused by client */
    environmentName: string;
    secretId: string;
    metadata: SecretMetadata | undefined;
}
declare const SecretListItem: MessageFns$1<SecretListItem>;
interface SecretListRequest {
    environmentName: string;
    pagination: ListPagination | undefined;
}
declare const SecretListRequest: MessageFns$1<SecretListRequest>;
interface SecretListResponse {
    items: SecretListItem[];
    environmentName: string;
}
declare const SecretListResponse: MessageFns$1<SecretListResponse>;
interface SecretMetadata {
    name: string;
    creationInfo: CreationInfo | undefined;
}
declare const SecretMetadata: MessageFns$1<SecretMetadata>;
interface SecretUpdateRequest {
    secretId: string;
    updates: SecretUpdateRequest_Update[];
}
declare const SecretUpdateRequest: MessageFns$1<SecretUpdateRequest>;
interface SecretUpdateRequest_Update {
    key: string;
    /** If not set, the key is removed. */
    value?: string | undefined;
}
declare const SecretUpdateRequest_Update: MessageFns$1<SecretUpdateRequest_Update>;
interface ServiceUser {
    name: string;
    tokenId: string;
    createdBy: string;
    createdAt: number;
    lastUsedAt: number;
    createdByAvatarUrl: string;
    serviceUserId: string;
}
declare const ServiceUser: MessageFns$1<ServiceUser>;
interface ServiceUserIdentity {
    serviceUserId: string;
    serviceUserName: string;
    createdBy: UserIdentity | undefined;
}
declare const ServiceUserIdentity: MessageFns$1<ServiceUserIdentity>;
interface ServiceUserListResponse {
    serviceUsers: ServiceUser[];
}
declare const ServiceUserListResponse: MessageFns$1<ServiceUserListResponse>;
interface SharedVolumeDeleteRequest {
    sharedVolumeId: string;
}
declare const SharedVolumeDeleteRequest: MessageFns$1<SharedVolumeDeleteRequest>;
interface SharedVolumeGetFileRequest {
    sharedVolumeId: string;
    path: string;
}
declare const SharedVolumeGetFileRequest: MessageFns$1<SharedVolumeGetFileRequest>;
interface SharedVolumeGetFileResponse {
    data?: Uint8Array | undefined;
    dataBlobId?: string | undefined;
}
declare const SharedVolumeGetFileResponse: MessageFns$1<SharedVolumeGetFileResponse>;
interface SharedVolumeGetOrCreateRequest {
    deploymentName: string;
    environmentName: string;
    objectCreationType: ObjectCreationType;
    /** only used with OBJECT_CREATION_TYPE_ANONYMOUS_OWNED_BY_APP */
    appId: string;
}
declare const SharedVolumeGetOrCreateRequest: MessageFns$1<SharedVolumeGetOrCreateRequest>;
interface SharedVolumeGetOrCreateResponse {
    sharedVolumeId: string;
}
declare const SharedVolumeGetOrCreateResponse: MessageFns$1<SharedVolumeGetOrCreateResponse>;
interface SharedVolumeHeartbeatRequest {
    sharedVolumeId: string;
}
declare const SharedVolumeHeartbeatRequest: MessageFns$1<SharedVolumeHeartbeatRequest>;
interface SharedVolumeListFilesRequest {
    sharedVolumeId: string;
    path: string;
}
declare const SharedVolumeListFilesRequest: MessageFns$1<SharedVolumeListFilesRequest>;
interface SharedVolumeListFilesResponse {
    entries: FileEntry[];
}
declare const SharedVolumeListFilesResponse: MessageFns$1<SharedVolumeListFilesResponse>;
interface SharedVolumeListItem {
    /** app name of object entity app */
    label: string;
    sharedVolumeId: string;
    createdAt: number;
    cloudProvider: CloudProvider;
}
declare const SharedVolumeListItem: MessageFns$1<SharedVolumeListItem>;
interface SharedVolumeListRequest {
    environmentName: string;
}
declare const SharedVolumeListRequest: MessageFns$1<SharedVolumeListRequest>;
interface SharedVolumeListResponse {
    items: SharedVolumeListItem[];
    environmentName: string;
}
declare const SharedVolumeListResponse: MessageFns$1<SharedVolumeListResponse>;
interface SharedVolumeMount {
    mountPath: string;
    sharedVolumeId: string;
    cloudProvider: CloudProvider;
}
declare const SharedVolumeMount: MessageFns$1<SharedVolumeMount>;
interface SharedVolumePutFileRequest {
    sharedVolumeId: string;
    path: string;
    sha256Hex: string;
    data?: Uint8Array | undefined;
    dataBlobId?: string | undefined;
    /** remove when required client version >= 47 */
    resumable: boolean;
}
declare const SharedVolumePutFileRequest: MessageFns$1<SharedVolumePutFileRequest>;
interface SharedVolumePutFileResponse {
    exists: boolean;
}
declare const SharedVolumePutFileResponse: MessageFns$1<SharedVolumePutFileResponse>;
interface SharedVolumeRemoveFileRequest {
    sharedVolumeId: string;
    path: string;
    recursive: boolean;
}
declare const SharedVolumeRemoveFileRequest: MessageFns$1<SharedVolumeRemoveFileRequest>;
interface StringMap {
    contents: {
        [key: string]: string;
    };
}
declare const StringMap: MessageFns$1<StringMap>;
interface SystemErrorMessage {
    errorCode: SystemErrorCode;
    errorMessage: string;
}
declare const SystemErrorMessage: MessageFns$1<SystemErrorMessage>;
interface TaskClusterHelloRequest {
    taskId: string;
    containerIp: string;
}
declare const TaskClusterHelloRequest: MessageFns$1<TaskClusterHelloRequest>;
interface TaskClusterHelloResponse {
    clusterId: string;
    clusterRank: number;
    /** All IPv6 addresses in cluster, ordered by cluster rank */
    containerIps: string[];
    containerIpv4Ips: string[];
}
declare const TaskClusterHelloResponse: MessageFns$1<TaskClusterHelloResponse>;
interface TaskCurrentInputsResponse {
    inputIds: string[];
}
declare const TaskCurrentInputsResponse: MessageFns$1<TaskCurrentInputsResponse>;
/**
 * Used to get a JWT and URL for direct access to a task command router
 * running on the modal-worker, so the client can issue exec commands (and other
 * operations as they become available) directly to the worker.
 */
interface TaskGetCommandRouterAccessRequest {
    taskId: string;
}
declare const TaskGetCommandRouterAccessRequest: MessageFns$1<TaskGetCommandRouterAccessRequest>;
interface TaskGetCommandRouterAccessResponse {
    jwt: string;
    url: string;
}
declare const TaskGetCommandRouterAccessResponse: MessageFns$1<TaskGetCommandRouterAccessResponse>;
interface TaskGetInfoRequest {
    taskId: string;
}
declare const TaskGetInfoRequest: MessageFns$1<TaskGetInfoRequest>;
interface TaskGetInfoResponse {
    appId: string;
    info: TaskInfo | undefined;
}
declare const TaskGetInfoResponse: MessageFns$1<TaskGetInfoResponse>;
interface TaskInfo {
    id: string;
    startedAt: number;
    finishedAt: number;
    result: GenericResult | undefined;
    enqueuedAt: number;
    gpuType: string;
    sandboxId: string;
    snapshotBehavior: TaskSnapshotBehavior;
    gpuConfig: GPUConfig | undefined;
}
declare const TaskInfo: MessageFns$1<TaskInfo>;
interface TaskListRequest {
    environmentName: string;
    appId: string;
}
declare const TaskListRequest: MessageFns$1<TaskListRequest>;
interface TaskListResponse {
    tasks: TaskStats[];
}
declare const TaskListResponse: MessageFns$1<TaskListResponse>;
interface TaskLogs {
    data: string;
    taskState: TaskState;
    timestamp: number;
    fileDescriptor: FileDescriptor;
    taskProgress: TaskProgress | undefined;
    functionCallId: string;
    inputId: string;
    timestampNs: number;
    containerId: string;
    containerName: string;
}
declare const TaskLogs: MessageFns$1<TaskLogs>;
interface TaskLogsBatch {
    taskId: string;
    items: TaskLogs[];
    entryId: string;
    appDone: boolean;
    functionId: string;
    inputId: string;
    /** Used for image logs */
    imageId: string;
    eof: boolean;
    /** Used for interactive functions */
    ptyExecId: string;
    rootFunctionId: string;
    ttlDays: number;
}
declare const TaskLogsBatch: MessageFns$1<TaskLogsBatch>;
interface TaskProgress {
    len: number;
    pos: number;
    progressType: ProgressType;
    description: string;
}
declare const TaskProgress: MessageFns$1<TaskProgress>;
interface TaskResultRequest {
    result: GenericResult | undefined;
}
declare const TaskResultRequest: MessageFns$1<TaskResultRequest>;
interface TaskStats {
    taskId: string;
    appId: string;
    appDescription: string;
    startedAt: number;
    enqueuedAt: number;
}
declare const TaskStats: MessageFns$1<TaskStats>;
interface TaskTemplate {
    rank: number;
    resources: Resources | undefined;
    targetConcurrentInputs: number;
    maxConcurrentInputs: number;
    /**
     * TODO(irfansharif): Just move this into a column in the task table instead?
     * Deprecate all above fields and get rid of this message altogether
     */
    index: number;
}
declare const TaskTemplate: MessageFns$1<TaskTemplate>;
interface TemplateListRequest {
}
declare const TemplateListRequest: MessageFns$1<TemplateListRequest>;
interface TemplateListResponse {
    items: TemplateListResponse_TemplateListItem[];
}
declare const TemplateListResponse: MessageFns$1<TemplateListResponse>;
interface TemplateListResponse_TemplateListItem {
    name: string;
    repo: string;
    ref: string;
}
declare const TemplateListResponse_TemplateListItem: MessageFns$1<TemplateListResponse_TemplateListItem>;
interface TokenFlowCreateRequest {
    utmSource: string;
    localhostPort: number;
    nextUrl: string;
}
declare const TokenFlowCreateRequest: MessageFns$1<TokenFlowCreateRequest>;
interface TokenFlowCreateResponse {
    tokenFlowId: string;
    webUrl: string;
    code: string;
    waitSecret: string;
}
declare const TokenFlowCreateResponse: MessageFns$1<TokenFlowCreateResponse>;
interface TokenFlowWaitRequest {
    timeout: number;
    tokenFlowId: string;
    waitSecret: string;
}
declare const TokenFlowWaitRequest: MessageFns$1<TokenFlowWaitRequest>;
interface TokenFlowWaitResponse {
    tokenId: string;
    tokenSecret: string;
    timeout: boolean;
    workspaceUsername: string;
}
declare const TokenFlowWaitResponse: MessageFns$1<TokenFlowWaitResponse>;
interface TokenInfoGetRequest {
}
declare const TokenInfoGetRequest: MessageFns$1<TokenInfoGetRequest>;
interface TokenInfoGetResponse {
    tokenId: string;
    workspaceId: string;
    workspaceName: string;
    userIdentity?: UserIdentity | undefined;
    serviceUserIdentity?: ServiceUserIdentity | undefined;
    /** Token metadata */
    createdAt: Date | undefined;
    expiresAt: Date | undefined;
    tokenName: string;
}
declare const TokenInfoGetResponse: MessageFns$1<TokenInfoGetResponse>;
interface TunnelData {
    host: string;
    port: number;
    unencryptedHost?: string | undefined;
    unencryptedPort?: number | undefined;
    containerPort: number;
}
declare const TunnelData: MessageFns$1<TunnelData>;
interface TunnelStartRequest {
    port: number;
    unencrypted: boolean;
    tunnelType?: TunnelType | undefined;
}
declare const TunnelStartRequest: MessageFns$1<TunnelStartRequest>;
interface TunnelStartResponse {
    host: string;
    port: number;
    unencryptedHost?: string | undefined;
    unencryptedPort?: number | undefined;
}
declare const TunnelStartResponse: MessageFns$1<TunnelStartResponse>;
interface TunnelStopRequest {
    port: number;
}
declare const TunnelStopRequest: MessageFns$1<TunnelStopRequest>;
interface TunnelStopResponse {
    exists: boolean;
}
declare const TunnelStopResponse: MessageFns$1<TunnelStopResponse>;
interface UploadUrlList {
    items: string[];
}
declare const UploadUrlList: MessageFns$1<UploadUrlList>;
interface UserIdentity {
    userId: string;
    username: string;
}
declare const UserIdentity: MessageFns$1<UserIdentity>;
interface VolumeCommitRequest {
    /**
     * NOTE(staffan): Mounting a volume in multiple locations is not supported, so volume_id alone uniquely identifies
     * a volume mount.
     */
    volumeId: string;
}
declare const VolumeCommitRequest: MessageFns$1<VolumeCommitRequest>;
interface VolumeCommitResponse {
    skipReload: boolean;
}
declare const VolumeCommitResponse: MessageFns$1<VolumeCommitResponse>;
interface VolumeCopyFiles2Request {
    volumeId: string;
    srcPaths: string[];
    dstPath: string;
    recursive: boolean;
}
declare const VolumeCopyFiles2Request: MessageFns$1<VolumeCopyFiles2Request>;
interface VolumeCopyFilesRequest {
    volumeId: string;
    srcPaths: string[];
    dstPath: string;
    recursive: boolean;
}
declare const VolumeCopyFilesRequest: MessageFns$1<VolumeCopyFilesRequest>;
interface VolumeDeleteRequest {
    volumeId: string;
    /** @deprecated */
    environmentName: string;
}
declare const VolumeDeleteRequest: MessageFns$1<VolumeDeleteRequest>;
interface VolumeGetByIdRequest {
    volumeId: string;
}
declare const VolumeGetByIdRequest: MessageFns$1<VolumeGetByIdRequest>;
interface VolumeGetByIdResponse {
    volumeId: string;
    metadata: VolumeMetadata | undefined;
}
declare const VolumeGetByIdResponse: MessageFns$1<VolumeGetByIdResponse>;
interface VolumeGetFile2Request {
    volumeId: string;
    path: string;
    start: number;
    /** 0 is interpreted as 'read to end' */
    len: number;
}
declare const VolumeGetFile2Request: MessageFns$1<VolumeGetFile2Request>;
interface VolumeGetFile2Response {
    getUrls: string[];
    /** total file size */
    size: number;
    /** file position of first byte returned */
    start: number;
    /** number of bytes returned */
    len: number;
}
declare const VolumeGetFile2Response: MessageFns$1<VolumeGetFile2Response>;
interface VolumeGetFileRequest {
    volumeId: string;
    path: string;
    start: number;
    /** 0 is interpreted as 'read to end' */
    len: number;
}
declare const VolumeGetFileRequest: MessageFns$1<VolumeGetFileRequest>;
interface VolumeGetFileResponse {
    data?: Uint8Array | undefined;
    dataBlobId?: string | undefined;
    /** total file size */
    size: number;
    /** file position of first byte returned */
    start: number;
    /** number of bytes returned */
    len: number;
}
declare const VolumeGetFileResponse: MessageFns$1<VolumeGetFileResponse>;
interface VolumeGetOrCreateRequest {
    deploymentName: string;
    environmentName: string;
    objectCreationType: ObjectCreationType;
    /** only used with OBJECT_CREATION_TYPE_ANONYMOUS_OWNED_BY_APP */
    appId: string;
    version: VolumeFsVersion;
}
declare const VolumeGetOrCreateRequest: MessageFns$1<VolumeGetOrCreateRequest>;
interface VolumeGetOrCreateResponse {
    volumeId: string;
    /** Not used directly; version is part of the metadata */
    version: VolumeFsVersion;
    metadata: VolumeMetadata | undefined;
}
declare const VolumeGetOrCreateResponse: MessageFns$1<VolumeGetOrCreateResponse>;
interface VolumeHeartbeatRequest {
    volumeId: string;
}
declare const VolumeHeartbeatRequest: MessageFns$1<VolumeHeartbeatRequest>;
interface VolumeListFiles2Request {
    volumeId: string;
    path: string;
    recursive: boolean;
    maxEntries?: number | undefined;
}
declare const VolumeListFiles2Request: MessageFns$1<VolumeListFiles2Request>;
interface VolumeListFiles2Response {
    entries: FileEntry[];
}
declare const VolumeListFiles2Response: MessageFns$1<VolumeListFiles2Response>;
interface VolumeListFilesRequest {
    volumeId: string;
    path: string;
    recursive: boolean;
    maxEntries?: number | undefined;
}
declare const VolumeListFilesRequest: MessageFns$1<VolumeListFilesRequest>;
interface VolumeListFilesResponse {
    entries: FileEntry[];
}
declare const VolumeListFilesResponse: MessageFns$1<VolumeListFilesResponse>;
interface VolumeListItem {
    /** app name of object entity app */
    label: string;
    volumeId: string;
    /** Superseded by metadata, used by clients up to 1.1.2 */
    createdAt: number;
    metadata: VolumeMetadata | undefined;
}
declare const VolumeListItem: MessageFns$1<VolumeListItem>;
interface VolumeListRequest {
    environmentName: string;
    pagination: ListPagination | undefined;
}
declare const VolumeListRequest: MessageFns$1<VolumeListRequest>;
interface VolumeListResponse {
    items: VolumeListItem[];
    environmentName: string;
}
declare const VolumeListResponse: MessageFns$1<VolumeListResponse>;
interface VolumeMetadata {
    version: VolumeFsVersion;
    name: string;
    creationInfo: CreationInfo | undefined;
}
declare const VolumeMetadata: MessageFns$1<VolumeMetadata>;
interface VolumeMount {
    volumeId: string;
    mountPath: string;
    allowBackgroundCommits: boolean;
    readOnly: boolean;
    subPath?: string | undefined;
}
declare const VolumeMount: MessageFns$1<VolumeMount>;
interface VolumePutFiles2Request {
    /** The ID of the volume to put/upload files into. */
    volumeId: string;
    /** List of files to put/upload. */
    files: VolumePutFiles2Request_File[];
    /**
     * If set to true, prevent overwriting existing files. (Note that we don't
     * allow overwriting existing directories with uploaded files regardless.)
     */
    disallowOverwriteExistingFiles: boolean;
}
declare const VolumePutFiles2Request: MessageFns$1<VolumePutFiles2Request>;
interface VolumePutFiles2Request_File {
    /**
     * Destination path of the file to be uploaded, including any parent dirs
     * etc.; for example "foo/bar/baz.txt"
     */
    path: string;
    /** The total size of the file, in bytes. */
    size: number;
    /** The blocks, in units of 8MiB, that this file consists of. */
    blocks: VolumePutFiles2Request_Block[];
    /** Unix file permission bits `st_mode`. */
    mode?: number | undefined;
}
declare const VolumePutFiles2Request_File: MessageFns$1<VolumePutFiles2Request_File>;
interface VolumePutFiles2Request_Block {
    /**
     * The SHA256 digest of the contents of this block, in raw (ie. 32 bytes)
     * form for compactness.
     */
    contentsSha256: Uint8Array;
    /**
     * From a previous call to `VolumePutFiles2`, we might have gotten a
     * response indicating that this block was missing.
     *
     * For such a block, this field contains the raw bytes of the body that
     * was returned from the HTTP PUT request when the client made a request
     * for the `put_url` returned in the previous `VolumePutFiles2Response`.
     */
    putResponse?: Uint8Array | undefined;
}
declare const VolumePutFiles2Request_Block: MessageFns$1<VolumePutFiles2Request_Block>;
interface VolumePutFiles2Response {
    /**
     * Blocks that are currently missing in the volume, because the file did not
     * exist, or because the block checksum from `blocks_sha256` in the request
     * did not match the current contents of the file.
     *
     * Values will be returned sorted by `(file_index, block_index)`.
     *
     * If this field is empty, it means that the files were uploaded successfully
     * and/or that the request was an idempotent no-op.
     */
    missingBlocks: VolumePutFiles2Response_MissingBlock[];
}
declare const VolumePutFiles2Response: MessageFns$1<VolumePutFiles2Response>;
interface VolumePutFiles2Response_MissingBlock {
    /** Index of the file in the original `files` field of the request. */
    fileIndex: number;
    /**
     * The index of the block in the original `files[file_index].blocks` of the
     * request.
     */
    blockIndex: number;
    /**
     * Make a HTTP PUT request to this endpoint with the blocks' contents as
     * the body.
     */
    putUrl: string;
}
declare const VolumePutFiles2Response_MissingBlock: MessageFns$1<VolumePutFiles2Response_MissingBlock>;
interface VolumePutFilesRequest {
    volumeId: string;
    /** TODO(staffan): This is obviously unfortunately named, but provides what we need - consider renaming. */
    files: MountFile[];
    /**
     * If set to true, prevent overwriting existing files. (Note that we don't allow overwriting
     * existing directories with uploaded files regardless.)
     */
    disallowOverwriteExistingFiles: boolean;
}
declare const VolumePutFilesRequest: MessageFns$1<VolumePutFilesRequest>;
interface VolumeReloadRequest {
    /**
     * NOTE(staffan): Mounting a volume in multiple locations is not supported, so volume_id alone uniquely identifies
     * a volume mount.
     */
    volumeId: string;
}
declare const VolumeReloadRequest: MessageFns$1<VolumeReloadRequest>;
interface VolumeRemoveFile2Request {
    volumeId: string;
    path: string;
    recursive: boolean;
}
declare const VolumeRemoveFile2Request: MessageFns$1<VolumeRemoveFile2Request>;
interface VolumeRemoveFileRequest {
    volumeId: string;
    path: string;
    recursive: boolean;
}
declare const VolumeRemoveFileRequest: MessageFns$1<VolumeRemoveFileRequest>;
interface VolumeRenameRequest {
    volumeId: string;
    name: string;
}
declare const VolumeRenameRequest: MessageFns$1<VolumeRenameRequest>;
interface Warning {
    type: Warning_WarningType;
    message: string;
}
declare const Warning: MessageFns$1<Warning>;
interface WebUrlInfo {
    truncated: boolean;
    /** @deprecated */
    hasUniqueHash: boolean;
    labelStolen: boolean;
}
declare const WebUrlInfo: MessageFns$1<WebUrlInfo>;
interface WebhookConfig {
    type: WebhookType;
    method: string;
    /** User-supplied "label" component of URL */
    requestedSuffix: string;
    asyncMode: WebhookAsyncMode;
    customDomains: CustomDomainConfig[];
    webServerPort: number;
    webServerStartupTimeout: number;
    webEndpointDocs: boolean;
    requiresProxyAuth: boolean;
    /** Additional URL suffix added for ephemeral Apps */
    ephemeralSuffix: string;
}
declare const WebhookConfig: MessageFns$1<WebhookConfig>;
interface WorkspaceBillingReportItem {
    objectId: string;
    description: string;
    environmentName: string;
    interval: Date | undefined;
    cost: string;
    tags: {
        [key: string]: string;
    };
}
declare const WorkspaceBillingReportItem: MessageFns$1<WorkspaceBillingReportItem>;
interface WorkspaceBillingReportRequest {
    /** Workspace ID will be implicit in the request metadata */
    startTimestamp: Date | undefined;
    endTimestamp: Date | undefined;
    /** e.g. 'd' or 'h'; server defines what we accept */
    resolution: string;
    tagNames: string[];
}
declare const WorkspaceBillingReportRequest: MessageFns$1<WorkspaceBillingReportRequest>;
interface WorkspaceDashboardUrlRequest {
    environmentName: string;
}
declare const WorkspaceDashboardUrlRequest: MessageFns$1<WorkspaceDashboardUrlRequest>;
interface WorkspaceDashboardUrlResponse {
    url: string;
}
declare const WorkspaceDashboardUrlResponse: MessageFns$1<WorkspaceDashboardUrlResponse>;
interface WorkspaceMembersListItem {
    memberId: string;
    memberDisplayname: string;
    memberRole: MemberRole;
    joinedAt: number;
    lastActiveAt: number;
    deletedAt: number;
    userId: string;
    identityProviderType: IdentityProviderType;
    email: string;
    avatarUrl: string;
    idpExternalId: string;
}
declare const WorkspaceMembersListItem: MessageFns$1<WorkspaceMembersListItem>;
interface WorkspaceMembersListResponse {
    members: WorkspaceMembersListItem[];
}
declare const WorkspaceMembersListResponse: MessageFns$1<WorkspaceMembersListResponse>;
interface WorkspaceNameLookupResponse {
    /** @deprecated */
    workspaceName: string;
    username: string;
}
declare const WorkspaceNameLookupResponse: MessageFns$1<WorkspaceNameLookupResponse>;
type ModalClientDefinition = typeof ModalClientDefinition;
declare const ModalClientDefinition: {
    readonly name: "ModalClient";
    readonly fullName: "modal.client.ModalClient";
    readonly methods: {
        /** Apps */
        readonly appClientDisconnect: {
            readonly name: "AppClientDisconnect";
            readonly requestType: MessageFns$1<AppClientDisconnectRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appCountLogs: {
            readonly name: "AppCountLogs";
            readonly requestType: MessageFns$1<AppCountLogsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppCountLogsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appCreate: {
            readonly name: "AppCreate";
            readonly requestType: MessageFns$1<AppCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appDeploy: {
            readonly name: "AppDeploy";
            readonly requestType: MessageFns$1<AppDeployRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppDeployResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appDeploymentHistory: {
            readonly name: "AppDeploymentHistory";
            readonly requestType: MessageFns$1<AppDeploymentHistoryRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppDeploymentHistoryResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appFetchLogs: {
            readonly name: "AppFetchLogs";
            readonly requestType: MessageFns$1<AppFetchLogsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppFetchLogsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appGetByDeploymentName: {
            readonly name: "AppGetByDeploymentName";
            readonly requestType: MessageFns$1<AppGetByDeploymentNameRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppGetByDeploymentNameResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appGetLayout: {
            readonly name: "AppGetLayout";
            readonly requestType: MessageFns$1<AppGetLayoutRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppGetLayoutResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appGetLifecycle: {
            readonly name: "AppGetLifecycle";
            readonly requestType: MessageFns$1<AppGetLifecycleRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppGetLifecycleResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appGetLogs: {
            readonly name: "AppGetLogs";
            readonly requestType: MessageFns$1<AppGetLogsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<TaskLogsBatch>;
            readonly responseStream: true;
            readonly options: {};
        };
        readonly appGetObjects: {
            readonly name: "AppGetObjects";
            readonly requestType: MessageFns$1<AppGetObjectsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppGetObjectsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appGetOrCreate: {
            readonly name: "AppGetOrCreate";
            readonly requestType: MessageFns$1<AppGetOrCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppGetOrCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appGetTags: {
            readonly name: "AppGetTags";
            readonly requestType: MessageFns$1<AppGetTagsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppGetTagsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appHeartbeat: {
            readonly name: "AppHeartbeat";
            readonly requestType: MessageFns$1<AppHeartbeatRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appList: {
            readonly name: "AppList";
            readonly requestType: MessageFns$1<AppListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appLookup: {
            readonly name: "AppLookup";
            readonly requestType: MessageFns$1<AppLookupRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppLookupResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appPublish: {
            readonly name: "AppPublish";
            readonly requestType: MessageFns$1<AppPublishRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppPublishResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appRollback: {
            readonly name: "AppRollback";
            readonly requestType: MessageFns$1<AppRollbackRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appRollover: {
            readonly name: "AppRollover";
            readonly requestType: MessageFns$1<AppRolloverRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AppRolloverResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appSetObjects: {
            readonly name: "AppSetObjects";
            readonly requestType: MessageFns$1<AppSetObjectsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appSetTags: {
            readonly name: "AppSetTags";
            readonly requestType: MessageFns$1<AppSetTagsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly appStop: {
            readonly name: "AppStop";
            readonly requestType: MessageFns$1<AppStopRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Input Plane */
        readonly attemptAwait: {
            readonly name: "AttemptAwait";
            readonly requestType: MessageFns$1<AttemptAwaitRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AttemptAwaitResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly attemptRetry: {
            readonly name: "AttemptRetry";
            readonly requestType: MessageFns$1<AttemptRetryRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AttemptRetryResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly attemptStart: {
            readonly name: "AttemptStart";
            readonly requestType: MessageFns$1<AttemptStartRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AttemptStartResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Auth Token */
        readonly authTokenGet: {
            readonly name: "AuthTokenGet";
            readonly requestType: MessageFns$1<AuthTokenGetRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<AuthTokenGetResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Blobs */
        readonly blobCreate: {
            readonly name: "BlobCreate";
            readonly requestType: MessageFns$1<BlobCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<BlobCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly blobGet: {
            readonly name: "BlobGet";
            readonly requestType: MessageFns$1<BlobGetRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<BlobGetResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Classes */
        readonly classCreate: {
            readonly name: "ClassCreate";
            readonly requestType: MessageFns$1<ClassCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ClassCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly classGet: {
            readonly name: "ClassGet";
            readonly requestType: MessageFns$1<ClassGetRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ClassGetResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Clients */
        readonly clientHello: {
            readonly name: "ClientHello";
            readonly requestType: MessageFns$2<Empty>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ClientHelloResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Clusters */
        readonly clusterGet: {
            readonly name: "ClusterGet";
            readonly requestType: MessageFns$1<ClusterGetRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ClusterGetResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly clusterList: {
            readonly name: "ClusterList";
            readonly requestType: MessageFns$1<ClusterListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ClusterListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Container */
        readonly containerCheckpoint: {
            readonly name: "ContainerCheckpoint";
            readonly requestType: MessageFns$1<ContainerCheckpointRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly containerExec: {
            readonly name: "ContainerExec";
            readonly requestType: MessageFns$1<ContainerExecRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ContainerExecResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly containerExecGetOutput: {
            readonly name: "ContainerExecGetOutput";
            readonly requestType: MessageFns$1<ContainerExecGetOutputRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<RuntimeOutputBatch>;
            readonly responseStream: true;
            readonly options: {};
        };
        readonly containerExecPutInput: {
            readonly name: "ContainerExecPutInput";
            readonly requestType: MessageFns$1<ContainerExecPutInputRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly containerExecWait: {
            readonly name: "ContainerExecWait";
            readonly requestType: MessageFns$1<ContainerExecWaitRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ContainerExecWaitResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly containerFilesystemExec: {
            readonly name: "ContainerFilesystemExec";
            readonly requestType: MessageFns$1<ContainerFilesystemExecRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ContainerFilesystemExecResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly containerFilesystemExecGetOutput: {
            readonly name: "ContainerFilesystemExecGetOutput";
            readonly requestType: MessageFns$1<ContainerFilesystemExecGetOutputRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FilesystemRuntimeOutputBatch>;
            readonly responseStream: true;
            readonly options: {};
        };
        readonly containerHeartbeat: {
            readonly name: "ContainerHeartbeat";
            readonly requestType: MessageFns$1<ContainerHeartbeatRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ContainerHeartbeatResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly containerHello: {
            readonly name: "ContainerHello";
            readonly requestType: MessageFns$2<Empty>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly containerLog: {
            readonly name: "ContainerLog";
            readonly requestType: MessageFns$1<ContainerLogRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly containerReloadVolumes: {
            readonly name: "ContainerReloadVolumes";
            readonly requestType: MessageFns$1<ContainerReloadVolumesRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ContainerReloadVolumesResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly containerStop: {
            readonly name: "ContainerStop";
            readonly requestType: MessageFns$1<ContainerStopRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ContainerStopResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Dicts */
        readonly dictClear: {
            readonly name: "DictClear";
            readonly requestType: MessageFns$1<DictClearRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly dictContains: {
            readonly name: "DictContains";
            readonly requestType: MessageFns$1<DictContainsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<DictContainsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly dictContents: {
            readonly name: "DictContents";
            readonly requestType: MessageFns$1<DictContentsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<DictEntry>;
            readonly responseStream: true;
            readonly options: {};
        };
        readonly dictDelete: {
            readonly name: "DictDelete";
            readonly requestType: MessageFns$1<DictDeleteRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly dictGet: {
            readonly name: "DictGet";
            readonly requestType: MessageFns$1<DictGetRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<DictGetResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly dictGetById: {
            readonly name: "DictGetById";
            readonly requestType: MessageFns$1<DictGetByIdRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<DictGetByIdResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly dictGetOrCreate: {
            readonly name: "DictGetOrCreate";
            readonly requestType: MessageFns$1<DictGetOrCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<DictGetOrCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly dictHeartbeat: {
            readonly name: "DictHeartbeat";
            readonly requestType: MessageFns$1<DictHeartbeatRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly dictLen: {
            readonly name: "DictLen";
            readonly requestType: MessageFns$1<DictLenRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<DictLenResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly dictList: {
            readonly name: "DictList";
            readonly requestType: MessageFns$1<DictListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<DictListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly dictPop: {
            readonly name: "DictPop";
            readonly requestType: MessageFns$1<DictPopRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<DictPopResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly dictUpdate: {
            readonly name: "DictUpdate";
            readonly requestType: MessageFns$1<DictUpdateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<DictUpdateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Domains */
        readonly domainCertificateVerify: {
            readonly name: "DomainCertificateVerify";
            readonly requestType: MessageFns$1<DomainCertificateVerifyRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<DomainCertificateVerifyResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly domainCreate: {
            readonly name: "DomainCreate";
            readonly requestType: MessageFns$1<DomainCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<DomainCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly domainList: {
            readonly name: "DomainList";
            readonly requestType: MessageFns$1<DomainListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<DomainListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Endpoints */
        readonly endpointCreate: {
            readonly name: "EndpointCreate";
            readonly requestType: MessageFns$1<EndpointCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<EndpointCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly endpointList: {
            readonly name: "EndpointList";
            readonly requestType: MessageFns$1<EndpointListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<EndpointListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly endpointStop: {
            readonly name: "EndpointStop";
            readonly requestType: MessageFns$1<EndpointStopRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<EndpointStopResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Environments */
        readonly environmentCreate: {
            readonly name: "EnvironmentCreate";
            readonly requestType: MessageFns$1<EnvironmentCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly environmentDelete: {
            readonly name: "EnvironmentDelete";
            readonly requestType: MessageFns$1<EnvironmentDeleteRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly environmentGetManaged: {
            readonly name: "EnvironmentGetManaged";
            readonly requestType: MessageFns$1<EnvironmentGetManagedRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<EnvironmentGetManagedResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly environmentGetOrCreate: {
            readonly name: "EnvironmentGetOrCreate";
            readonly requestType: MessageFns$1<EnvironmentGetOrCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<EnvironmentGetOrCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly environmentList: {
            readonly name: "EnvironmentList";
            readonly requestType: MessageFns$2<Empty>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<EnvironmentListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly environmentRoleSet: {
            readonly name: "EnvironmentRoleSet";
            readonly requestType: MessageFns$1<EnvironmentRoleSetRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly environmentSetManaged: {
            readonly name: "EnvironmentSetManaged";
            readonly requestType: MessageFns$1<EnvironmentSetManagedRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly environmentUpdate: {
            readonly name: "EnvironmentUpdate";
            readonly requestType: MessageFns$1<EnvironmentUpdateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<EnvironmentListItem>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Modal Flash (experimental) */
        readonly flashContainerDeregister: {
            readonly name: "FlashContainerDeregister";
            readonly requestType: MessageFns$1<FlashContainerDeregisterRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly flashContainerList: {
            readonly name: "FlashContainerList";
            readonly requestType: MessageFns$1<FlashContainerListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FlashContainerListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly flashContainerRegister: {
            readonly name: "FlashContainerRegister";
            readonly requestType: MessageFns$1<FlashContainerRegisterRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FlashContainerRegisterResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly flashSetTargetSlotsMetrics: {
            readonly name: "FlashSetTargetSlotsMetrics";
            readonly requestType: MessageFns$1<FlashSetTargetSlotsMetricsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FlashSetTargetSlotsMetricsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Functions */
        readonly functionAsyncInvoke: {
            readonly name: "FunctionAsyncInvoke";
            readonly requestType: MessageFns$1<FunctionAsyncInvokeRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionAsyncInvokeResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionBindParams: {
            readonly name: "FunctionBindParams";
            readonly requestType: MessageFns$1<FunctionBindParamsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionBindParamsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionCallCancel: {
            readonly name: "FunctionCallCancel";
            readonly requestType: MessageFns$1<FunctionCallCancelRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionCallFromId: {
            readonly name: "FunctionCallFromId";
            readonly requestType: MessageFns$1<FunctionCallFromIdRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionCallFromIdResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionCallGetDataIn: {
            readonly name: "FunctionCallGetDataIn";
            readonly requestType: MessageFns$1<FunctionCallGetDataRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<DataChunk>;
            readonly responseStream: true;
            readonly options: {};
        };
        readonly functionCallGetDataOut: {
            readonly name: "FunctionCallGetDataOut";
            readonly requestType: MessageFns$1<FunctionCallGetDataRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<DataChunk>;
            readonly responseStream: true;
            readonly options: {};
        };
        readonly functionCallList: {
            readonly name: "FunctionCallList";
            readonly requestType: MessageFns$1<FunctionCallListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionCallListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionCallPutDataOut: {
            readonly name: "FunctionCallPutDataOut";
            readonly requestType: MessageFns$1<FunctionCallPutDataRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionCreate: {
            readonly name: "FunctionCreate";
            readonly requestType: MessageFns$1<FunctionCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** For map RPCs, to signal that all inputs have been sent */
        readonly functionFinishInputs: {
            readonly name: "FunctionFinishInputs";
            readonly requestType: MessageFns$1<FunctionFinishInputsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionGet: {
            readonly name: "FunctionGet";
            readonly requestType: MessageFns$1<FunctionGetRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionGetResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionGetCallGraph: {
            readonly name: "FunctionGetCallGraph";
            readonly requestType: MessageFns$1<FunctionGetCallGraphRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionGetCallGraphResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionGetCurrentStats: {
            readonly name: "FunctionGetCurrentStats";
            readonly requestType: MessageFns$1<FunctionGetCurrentStatsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionStats$1>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionGetDynamicConcurrency: {
            readonly name: "FunctionGetDynamicConcurrency";
            readonly requestType: MessageFns$1<FunctionGetDynamicConcurrencyRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionGetDynamicConcurrencyResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** For containers to request next call */
        readonly functionGetInputs: {
            readonly name: "FunctionGetInputs";
            readonly requestType: MessageFns$1<FunctionGetInputsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionGetInputsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Returns the next result(s) for an entire function call (FunctionMap) */
        readonly functionGetOutputs: {
            readonly name: "FunctionGetOutputs";
            readonly requestType: MessageFns$1<FunctionGetOutputsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionGetOutputsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionGetSerialized: {
            readonly name: "FunctionGetSerialized";
            readonly requestType: MessageFns$1<FunctionGetSerializedRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionGetSerializedResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionMap: {
            readonly name: "FunctionMap";
            readonly requestType: MessageFns$1<FunctionMapRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionMapResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionPrecreate: {
            readonly name: "FunctionPrecreate";
            readonly requestType: MessageFns$1<FunctionPrecreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionPrecreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionPutInputs: {
            readonly name: "FunctionPutInputs";
            readonly requestType: MessageFns$1<FunctionPutInputsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionPutInputsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** For containers to return result */
        readonly functionPutOutputs: {
            readonly name: "FunctionPutOutputs";
            readonly requestType: MessageFns$1<FunctionPutOutputsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionRetryInputs: {
            readonly name: "FunctionRetryInputs";
            readonly requestType: MessageFns$1<FunctionRetryInputsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionRetryInputsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionStartPtyShell: {
            readonly name: "FunctionStartPtyShell";
            readonly requestType: MessageFns$2<Empty>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly functionUpdateSchedulingParams: {
            readonly name: "FunctionUpdateSchedulingParams";
            readonly requestType: MessageFns$1<FunctionUpdateSchedulingParamsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<FunctionUpdateSchedulingParamsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Images */
        readonly imageDelete: {
            readonly name: "ImageDelete";
            readonly requestType: MessageFns$1<ImageDeleteRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly imageFromId: {
            readonly name: "ImageFromId";
            readonly requestType: MessageFns$1<ImageFromIdRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ImageFromIdResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly imageGetByTag: {
            readonly name: "ImageGetByTag";
            readonly requestType: MessageFns$1<ImageGetByTagRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ImageGetByTagResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly imageGetOrCreate: {
            readonly name: "ImageGetOrCreate";
            readonly requestType: MessageFns$1<ImageGetOrCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ImageGetOrCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly imageJoinStreaming: {
            readonly name: "ImageJoinStreaming";
            readonly requestType: MessageFns$1<ImageJoinStreamingRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ImageJoinStreamingResponse>;
            readonly responseStream: true;
            readonly options: {};
        };
        readonly imageListTags: {
            readonly name: "ImageListTags";
            readonly requestType: MessageFns$1<ImageListTagsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ImageListTagsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly imagePublish: {
            readonly name: "ImagePublish";
            readonly requestType: MessageFns$1<ImagePublishRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ImagePublishResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly imageTagRevisions: {
            readonly name: "ImageTagRevisions";
            readonly requestType: MessageFns$1<ImageTagRevisionsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ImageTagRevisionsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Input Plane Map */
        readonly mapAwait: {
            readonly name: "MapAwait";
            readonly requestType: MessageFns$1<MapAwaitRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<MapAwaitResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly mapCheckInputs: {
            readonly name: "MapCheckInputs";
            readonly requestType: MessageFns$1<MapCheckInputsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<MapCheckInputsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly mapStartOrContinue: {
            readonly name: "MapStartOrContinue";
            readonly requestType: MessageFns$1<MapStartOrContinueRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<MapStartOrContinueResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Mounts */
        readonly mountGetOrCreate: {
            readonly name: "MountGetOrCreate";
            readonly requestType: MessageFns$1<MountGetOrCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<MountGetOrCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly mountPutFile: {
            readonly name: "MountPutFile";
            readonly requestType: MessageFns$1<MountPutFileRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<MountPutFileResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Notebooks */
        readonly notebookKernelPublishResults: {
            readonly name: "NotebookKernelPublishResults";
            readonly requestType: MessageFns$1<NotebookKernelPublishResultsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Proxies */
        readonly proxyAddIp: {
            readonly name: "ProxyAddIp";
            readonly requestType: MessageFns$1<ProxyAddIpRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ProxyAddIpResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly proxyCreate: {
            readonly name: "ProxyCreate";
            readonly requestType: MessageFns$1<ProxyCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ProxyCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly proxyDelete: {
            readonly name: "ProxyDelete";
            readonly requestType: MessageFns$1<ProxyDeleteRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly proxyGet: {
            readonly name: "ProxyGet";
            readonly requestType: MessageFns$1<ProxyGetRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ProxyGetResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly proxyGetOrCreate: {
            readonly name: "ProxyGetOrCreate";
            readonly requestType: MessageFns$1<ProxyGetOrCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ProxyGetOrCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly proxyList: {
            readonly name: "ProxyList";
            readonly requestType: MessageFns$2<Empty>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ProxyListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly proxyRemoveIp: {
            readonly name: "ProxyRemoveIp";
            readonly requestType: MessageFns$1<ProxyRemoveIpRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Queues */
        readonly queueClear: {
            readonly name: "QueueClear";
            readonly requestType: MessageFns$1<QueueClearRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly queueDelete: {
            readonly name: "QueueDelete";
            readonly requestType: MessageFns$1<QueueDeleteRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly queueGet: {
            readonly name: "QueueGet";
            readonly requestType: MessageFns$1<QueueGetRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<QueueGetResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly queueGetById: {
            readonly name: "QueueGetById";
            readonly requestType: MessageFns$1<QueueGetByIdRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<QueueGetByIdResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly queueGetOrCreate: {
            readonly name: "QueueGetOrCreate";
            readonly requestType: MessageFns$1<QueueGetOrCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<QueueGetOrCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly queueHeartbeat: {
            readonly name: "QueueHeartbeat";
            readonly requestType: MessageFns$1<QueueHeartbeatRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly queueLen: {
            readonly name: "QueueLen";
            readonly requestType: MessageFns$1<QueueLenRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<QueueLenResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly queueList: {
            readonly name: "QueueList";
            readonly requestType: MessageFns$1<QueueListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<QueueListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly queueNextItems: {
            readonly name: "QueueNextItems";
            readonly requestType: MessageFns$1<QueueNextItemsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<QueueNextItemsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly queuePut: {
            readonly name: "QueuePut";
            readonly requestType: MessageFns$1<QueuePutRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Sandboxes */
        readonly sandboxCreate: {
            readonly name: "SandboxCreate";
            readonly requestType: MessageFns$1<SandboxCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxCreateConnectToken: {
            readonly name: "SandboxCreateConnectToken";
            readonly requestType: MessageFns$1<SandboxCreateConnectTokenRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxCreateConnectTokenResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxCreateV2: {
            readonly name: "SandboxCreateV2";
            readonly requestType: MessageFns$1<SandboxCreateV2Request>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxCreateV2Response>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxGetCommandRouterAccess: {
            readonly name: "SandboxGetCommandRouterAccess";
            readonly requestType: MessageFns$1<SandboxGetCommandRouterAccessRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxGetCommandRouterAccessResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxGetFromName: {
            readonly name: "SandboxGetFromName";
            readonly requestType: MessageFns$1<SandboxGetFromNameRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxGetFromNameResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxGetLogs: {
            readonly name: "SandboxGetLogs";
            readonly requestType: MessageFns$1<SandboxGetLogsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<TaskLogsBatch>;
            readonly responseStream: true;
            readonly options: {};
        };
        readonly sandboxGetResourceUsage: {
            readonly name: "SandboxGetResourceUsage";
            readonly requestType: MessageFns$1<SandboxGetResourceUsageRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxGetResourceUsageResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** needed for modal container exec */
        readonly sandboxGetTaskId: {
            readonly name: "SandboxGetTaskId";
            readonly requestType: MessageFns$1<SandboxGetTaskIdRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxGetTaskIdResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxGetTaskIdV2: {
            readonly name: "SandboxGetTaskIdV2";
            readonly requestType: MessageFns$1<SandboxGetTaskIdRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxGetTaskIdResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxGetTunnels: {
            readonly name: "SandboxGetTunnels";
            readonly requestType: MessageFns$1<SandboxGetTunnelsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxGetTunnelsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxGetTunnelsV2: {
            readonly name: "SandboxGetTunnelsV2";
            readonly requestType: MessageFns$1<SandboxGetTunnelsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxGetTunnelsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxList: {
            readonly name: "SandboxList";
            readonly requestType: MessageFns$1<SandboxListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxListV2: {
            readonly name: "SandboxListV2";
            readonly requestType: MessageFns$1<SandboxListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxRestore: {
            readonly name: "SandboxRestore";
            readonly requestType: MessageFns$1<SandboxRestoreRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxRestoreResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxSnapshot: {
            readonly name: "SandboxSnapshot";
            readonly requestType: MessageFns$1<SandboxSnapshotRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxSnapshotResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxSnapshotFs: {
            readonly name: "SandboxSnapshotFs";
            readonly requestType: MessageFns$1<SandboxSnapshotFsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxSnapshotFsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxSnapshotFsAsync: {
            readonly name: "SandboxSnapshotFsAsync";
            readonly requestType: MessageFns$1<SandboxSnapshotFsAsyncRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxSnapshotFsAsyncResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxSnapshotFsAsyncGet: {
            readonly name: "SandboxSnapshotFsAsyncGet";
            readonly requestType: MessageFns$1<SandboxSnapshotFsAsyncGetRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxSnapshotFsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxSnapshotGet: {
            readonly name: "SandboxSnapshotGet";
            readonly requestType: MessageFns$1<SandboxSnapshotGetRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxSnapshotGetResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxSnapshotWait: {
            readonly name: "SandboxSnapshotWait";
            readonly requestType: MessageFns$1<SandboxSnapshotWaitRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxSnapshotWaitResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxStdinWrite: {
            readonly name: "SandboxStdinWrite";
            readonly requestType: MessageFns$1<SandboxStdinWriteRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxStdinWriteResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxTagsGet: {
            readonly name: "SandboxTagsGet";
            readonly requestType: MessageFns$1<SandboxTagsGetRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxTagsGetResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxTagsSet: {
            readonly name: "SandboxTagsSet";
            readonly requestType: MessageFns$1<SandboxTagsSetRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxTerminate: {
            readonly name: "SandboxTerminate";
            readonly requestType: MessageFns$1<SandboxTerminateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxTerminateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxTerminateV2: {
            readonly name: "SandboxTerminateV2";
            readonly requestType: MessageFns$1<SandboxTerminateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxTerminateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxWait: {
            readonly name: "SandboxWait";
            readonly requestType: MessageFns$1<SandboxWaitRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxWaitResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxWaitUntilReady: {
            readonly name: "SandboxWaitUntilReady";
            readonly requestType: MessageFns$1<SandboxWaitUntilReadyRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxWaitUntilReadyResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sandboxWaitV2: {
            readonly name: "SandboxWaitV2";
            readonly requestType: MessageFns$1<SandboxWaitRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SandboxWaitResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Secrets */
        readonly secretDelete: {
            readonly name: "SecretDelete";
            readonly requestType: MessageFns$1<SecretDeleteRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly secretGetOrCreate: {
            readonly name: "SecretGetOrCreate";
            readonly requestType: MessageFns$1<SecretGetOrCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SecretGetOrCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly secretList: {
            readonly name: "SecretList";
            readonly requestType: MessageFns$1<SecretListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SecretListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly secretUpdate: {
            readonly name: "SecretUpdate";
            readonly requestType: MessageFns$1<SecretUpdateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Service users */
        readonly serviceUserList: {
            readonly name: "ServiceUserList";
            readonly requestType: MessageFns$2<Empty>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<ServiceUserListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** SharedVolumes */
        readonly sharedVolumeDelete: {
            readonly name: "SharedVolumeDelete";
            readonly requestType: MessageFns$1<SharedVolumeDeleteRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sharedVolumeGetFile: {
            readonly name: "SharedVolumeGetFile";
            readonly requestType: MessageFns$1<SharedVolumeGetFileRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SharedVolumeGetFileResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sharedVolumeGetOrCreate: {
            readonly name: "SharedVolumeGetOrCreate";
            readonly requestType: MessageFns$1<SharedVolumeGetOrCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SharedVolumeGetOrCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sharedVolumeHeartbeat: {
            readonly name: "SharedVolumeHeartbeat";
            readonly requestType: MessageFns$1<SharedVolumeHeartbeatRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sharedVolumeList: {
            readonly name: "SharedVolumeList";
            readonly requestType: MessageFns$1<SharedVolumeListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SharedVolumeListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sharedVolumeListFiles: {
            readonly name: "SharedVolumeListFiles";
            readonly requestType: MessageFns$1<SharedVolumeListFilesRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SharedVolumeListFilesResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sharedVolumeListFilesStream: {
            readonly name: "SharedVolumeListFilesStream";
            readonly requestType: MessageFns$1<SharedVolumeListFilesRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SharedVolumeListFilesResponse>;
            readonly responseStream: true;
            readonly options: {};
        };
        readonly sharedVolumePutFile: {
            readonly name: "SharedVolumePutFile";
            readonly requestType: MessageFns$1<SharedVolumePutFileRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<SharedVolumePutFileResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly sharedVolumeRemoveFile: {
            readonly name: "SharedVolumeRemoveFile";
            readonly requestType: MessageFns$1<SharedVolumeRemoveFileRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Tasks */
        readonly taskClusterHello: {
            readonly name: "TaskClusterHello";
            readonly requestType: MessageFns$1<TaskClusterHelloRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<TaskClusterHelloResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly taskCurrentInputs: {
            readonly name: "TaskCurrentInputs";
            readonly requestType: MessageFns$2<Empty>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<TaskCurrentInputsResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly taskGetCommandRouterAccess: {
            readonly name: "TaskGetCommandRouterAccess";
            readonly requestType: MessageFns$1<TaskGetCommandRouterAccessRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<TaskGetCommandRouterAccessResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly taskGetInfo: {
            readonly name: "TaskGetInfo";
            readonly requestType: MessageFns$1<TaskGetInfoRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<TaskGetInfoResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly taskList: {
            readonly name: "TaskList";
            readonly requestType: MessageFns$1<TaskListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<TaskListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly taskResult: {
            readonly name: "TaskResult";
            readonly requestType: MessageFns$1<TaskResultRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Templates */
        readonly templateList: {
            readonly name: "TemplateList";
            readonly requestType: MessageFns$1<TemplateListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<TemplateListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Tokens (web auth flow) */
        readonly tokenFlowCreate: {
            readonly name: "TokenFlowCreate";
            readonly requestType: MessageFns$1<TokenFlowCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<TokenFlowCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly tokenFlowWait: {
            readonly name: "TokenFlowWait";
            readonly requestType: MessageFns$1<TokenFlowWaitRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<TokenFlowWaitResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly tokenInfoGet: {
            readonly name: "TokenInfoGet";
            readonly requestType: MessageFns$1<TokenInfoGetRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<TokenInfoGetResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Tunnels */
        readonly tunnelStart: {
            readonly name: "TunnelStart";
            readonly requestType: MessageFns$1<TunnelStartRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<TunnelStartResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly tunnelStop: {
            readonly name: "TunnelStop";
            readonly requestType: MessageFns$1<TunnelStopRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<TunnelStopResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Volumes */
        readonly volumeCommit: {
            readonly name: "VolumeCommit";
            readonly requestType: MessageFns$1<VolumeCommitRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<VolumeCommitResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumeCopyFiles: {
            readonly name: "VolumeCopyFiles";
            readonly requestType: MessageFns$1<VolumeCopyFilesRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumeCopyFiles2: {
            readonly name: "VolumeCopyFiles2";
            readonly requestType: MessageFns$1<VolumeCopyFiles2Request>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumeDelete: {
            readonly name: "VolumeDelete";
            readonly requestType: MessageFns$1<VolumeDeleteRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumeGetById: {
            readonly name: "VolumeGetById";
            readonly requestType: MessageFns$1<VolumeGetByIdRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<VolumeGetByIdResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumeGetFile: {
            readonly name: "VolumeGetFile";
            readonly requestType: MessageFns$1<VolumeGetFileRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<VolumeGetFileResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumeGetFile2: {
            readonly name: "VolumeGetFile2";
            readonly requestType: MessageFns$1<VolumeGetFile2Request>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<VolumeGetFile2Response>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumeGetOrCreate: {
            readonly name: "VolumeGetOrCreate";
            readonly requestType: MessageFns$1<VolumeGetOrCreateRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<VolumeGetOrCreateResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumeHeartbeat: {
            readonly name: "VolumeHeartbeat";
            readonly requestType: MessageFns$1<VolumeHeartbeatRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumeList: {
            readonly name: "VolumeList";
            readonly requestType: MessageFns$1<VolumeListRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<VolumeListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumeListFiles: {
            readonly name: "VolumeListFiles";
            readonly requestType: MessageFns$1<VolumeListFilesRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<VolumeListFilesResponse>;
            readonly responseStream: true;
            readonly options: {};
        };
        readonly volumeListFiles2: {
            readonly name: "VolumeListFiles2";
            readonly requestType: MessageFns$1<VolumeListFiles2Request>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<VolumeListFiles2Response>;
            readonly responseStream: true;
            readonly options: {};
        };
        readonly volumePutFiles: {
            readonly name: "VolumePutFiles";
            readonly requestType: MessageFns$1<VolumePutFilesRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumePutFiles2: {
            readonly name: "VolumePutFiles2";
            readonly requestType: MessageFns$1<VolumePutFiles2Request>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<VolumePutFiles2Response>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumeReload: {
            readonly name: "VolumeReload";
            readonly requestType: MessageFns$1<VolumeReloadRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumeRemoveFile: {
            readonly name: "VolumeRemoveFile";
            readonly requestType: MessageFns$1<VolumeRemoveFileRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumeRemoveFile2: {
            readonly name: "VolumeRemoveFile2";
            readonly requestType: MessageFns$1<VolumeRemoveFile2Request>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly volumeRename: {
            readonly name: "VolumeRename";
            readonly requestType: MessageFns$1<VolumeRenameRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$2<Empty>;
            readonly responseStream: false;
            readonly options: {};
        };
        /** Workspaces */
        readonly workspaceBillingReport: {
            readonly name: "WorkspaceBillingReport";
            readonly requestType: MessageFns$1<WorkspaceBillingReportRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<WorkspaceBillingReportItem>;
            readonly responseStream: true;
            readonly options: {};
        };
        readonly workspaceDashboardUrlGet: {
            readonly name: "WorkspaceDashboardUrlGet";
            readonly requestType: MessageFns$1<WorkspaceDashboardUrlRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<WorkspaceDashboardUrlResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly workspaceMembersList: {
            readonly name: "WorkspaceMembersList";
            readonly requestType: MessageFns$2<Empty>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<WorkspaceMembersListResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly workspaceNameLookup: {
            readonly name: "WorkspaceNameLookup";
            readonly requestType: MessageFns$2<Empty>;
            readonly requestStream: false;
            readonly responseType: MessageFns$1<WorkspaceNameLookupResponse>;
            readonly responseStream: false;
            readonly options: {};
        };
    };
};
type Builtin$1 = Date | Function | Uint8Array | string | number | boolean | undefined;
type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$1<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$1<U>> : T extends {} ? {
    [K in keyof T]?: DeepPartial$1<T[K]>;
} : Partial<T>;
interface MessageFns$1<T> {
    encode(message: T, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): T;
    fromJSON(object: any): T;
    toJSON(message: T): unknown;
    create(base?: DeepPartial$1<T>): T;
    fromPartial(object: DeepPartial$1<T>): T;
}

/** Optional parameters for {@link SecretService#fromName client.secrets.fromName()}. */
type SecretFromNameParams = {
    environment?: string;
    requiredKeys?: string[];
};
/** Optional parameters for {@link SecretService#fromObject client.secrets.fromObject()}. */
type SecretFromObjectParams = {
    environment?: string;
};
/** Optional parameters for {@link SecretService#delete client.secrets.delete()}. */
type SecretDeleteParams = {
    environment?: string;
    allowMissing?: boolean;
};
/**
 * Service for managing {@link Secret Secrets}.
 *
 * Normally only ever accessed via the client as:
 * ```typescript
 * const modal = new ModalClient();
 * const secret = await modal.secrets.fromName("my-secret");
 * ```
 */
declare class SecretService {
    #private;
    constructor(client: ModalClient);
    /** Reference a {@link Secret} by its name. */
    fromName(name: string, params?: SecretFromNameParams): Promise<Secret>;
    /** Create a {@link Secret} from a plain object of key-value pairs. */
    fromObject(entries: Record<string, string>, params?: SecretFromObjectParams): Promise<Secret>;
    /**
     * Delete a named {@link Secret}.
     *
     * Warning: Deletion is irreversible and will affect any Apps currently using the Secret.
     */
    delete(name: string, params?: SecretDeleteParams): Promise<void>;
}
/** Secrets provide a dictionary of environment variables for {@link Image}s. */
declare class Secret {
    readonly secretId: string;
    readonly name?: string;
    /** @ignore */
    constructor(secretId: string, name?: string);
}

declare class CloudBucketMountService {
    #private;
    constructor(client: ModalClient);
    create(bucketName: string, params?: {
        secret?: Secret;
        readOnly?: boolean;
        requesterPays?: boolean;
        bucketEndpointUrl?: string;
        keyPrefix?: string;
        oidcAuthRoleArn?: string;
    }): CloudBucketMount;
}
/** Cloud Bucket Mounts provide access to cloud storage buckets within Modal Functions. */
declare class CloudBucketMount {
    #private;
    readonly bucketName: string;
    readonly secret?: Secret;
    readonly readOnly: boolean;
    readonly requesterPays: boolean;
    readonly bucketEndpointUrl?: string;
    readonly keyPrefix?: string;
    readonly oidcAuthRoleArn?: string;
    /** @ignore */
    constructor(bucketName: string, secret: Secret | undefined, readOnly: boolean, requesterPays: boolean, bucketEndpointUrl: string | undefined, keyPrefix: string | undefined, oidcAuthRoleArn: string | undefined, bucketType: CloudBucketMount_BucketType);
    /** @ignore */
    toProto(mountPath: string): CloudBucketMount$1;
}

/**
 * Service for managing {@link FunctionCall}s.
 *
 * Normally only ever accessed via the client as:
 *
 * ```typescript
 * const modal = new ModalClient();
 * const functionCall = await modal.functionCalls.fromId("123");
 * ```
 */
declare class FunctionCallService {
    #private;
    constructor(client: ModalClient);
    /**
     * Create a new {@link FunctionCall} from ID.
     */
    fromId(functionCallId: string): Promise<FunctionCall>;
}
/** Optional parameters for {@link FunctionCall#get FunctionCall.get()}. */
type FunctionCallGetParams = {
    timeoutMs?: number;
};
/** Optional parameters for {@link FunctionCall#cancel FunctionCall.cancel()}. */
type FunctionCallCancelParams = {
    terminateContainers?: boolean;
};
/**
 * Represents a Modal FunctionCall. FunctionCalls are {@link Function_ Function} invocations with
 * a given input. They can be consumed asynchronously (see {@link FunctionCall#get FunctionCall.get()}) or cancelled
 * (see {@link FunctionCall#cancel FunctionCall.cancel()}).
 */
declare class FunctionCall {
    #private;
    readonly functionCallId: string;
    /** @ignore */
    constructor(client: ModalClient, functionCallId: string);
    /** Get the result of a FunctionCall, optionally waiting with a timeout. */
    get(params?: FunctionCallGetParams): Promise<any>;
    /** Cancel a running FunctionCall. */
    cancel(params?: FunctionCallCancelParams): Promise<void>;
}

type HeartbeatFunction = () => Promise<any>;
declare class EphemeralHeartbeatManager {
    private readonly heartbeatFn;
    private readonly abortController;
    constructor(heartbeatFn: HeartbeatFunction);
    private start;
    stop(): void;
}

/** Optional parameters for {@link VolumeService#fromName client.volumes.fromName()}. */
type VolumeFromNameParams = {
    environment?: string;
    createIfMissing?: boolean;
};
/** Optional parameters for {@link VolumeService#ephemeral client.volumes.ephemeral()}. */
type VolumeEphemeralParams = {
    environment?: string;
};
/** Optional parameters for {@link VolumeService#delete client.volumes.delete()}. */
type VolumeDeleteParams = {
    environment?: string;
    allowMissing?: boolean;
};
/**
 * Service for managing {@link Volume}s.
 *
 * Normally only ever accessed via the client as:
 * ```typescript
 * const modal = new ModalClient();
 * const volume = await modal.volumes.fromName("my-volume");
 * ```
 */
declare class VolumeService {
    #private;
    constructor(client: ModalClient);
    /**
     * Reference a {@link Volume} by its name.
     */
    fromName(name: string, params?: VolumeFromNameParams): Promise<Volume>;
    /**
     * Create a nameless, temporary {@link Volume}.
     * It persists until closeEphemeral() is called, or the process exits.
     */
    ephemeral(params?: VolumeEphemeralParams): Promise<Volume>;
    /**
     * Delete a named {@link Volume}.
     *
     * Warning: Deletion is irreversible and will affect any Apps currently using the Volume.
     */
    delete(name: string, params?: VolumeDeleteParams): Promise<void>;
}
/**
 * Resolved mount configuration stored on a Volume. `subPath: undefined` means "mount the
 * whole volume" (no sub-path set on the resulting VolumeMount proto).
 */
type ResolvedMountOptions = {
    readOnly: boolean;
    subPath: string | undefined;
};
/** Volumes provide persistent storage that can be mounted in Modal {@link Function_ Function}s. */
declare class Volume {
    #private;
    readonly volumeId: string;
    readonly name?: string;
    /**
     * @hidden
     * @internal
     */
    readonly _mountOptions: ResolvedMountOptions;
    /** @ignore */
    constructor(volumeId: string, name?: string, mountOptions?: ResolvedMountOptions, ephemeralHbManager?: EphemeralHeartbeatManager);
    /**
     * Configure options used when mounting this Volume. Fields left undefined preserve their value
     * from any previous withMountOptions call on the same Volume (stacking).
     */
    withMountOptions(params?: VolumeMountOptions): Volume;
    /** Delete the ephemeral Volume. Only usable with emphemeral Volumes. */
    closeEphemeral(): void;
}
/** Options for mounting a {@link Volume}. */
type VolumeMountOptions = {
    readOnly?: boolean;
    subPath?: string;
};

/** Retry policy configuration for a Modal Function/Cls. */
declare class Retries {
    readonly maxRetries: number;
    readonly backoffCoefficient: number;
    readonly initialDelayMs: number;
    readonly maxDelayMs: number;
    constructor(params: {
        maxRetries: number;
        backoffCoefficient?: number;
        initialDelayMs?: number;
        maxDelayMs?: number;
    });
}

/** Optional parameters for `client.functions.fromName()`. */
type FunctionFromNameParams = {
    environment?: string;
    createIfMissing?: boolean;
};
/**
 * Service for managing {@link Function_ Function}s.
 *
 * Normally only ever accessed via the client as:
 * ```typescript
 * const modal = new ModalClient();
 * const function = await modal.functions.fromName("my-app", "my-function");
 * ```
 */
declare class FunctionService {
    #private;
    constructor(client: ModalClient);
    /**
     * Reference a {@link Function_ Function} by its name in an App.
     */
    fromName(appName: string, name: string, params?: FunctionFromNameParams): Promise<Function_>;
}
/** Simple data structure storing stats for a running {@link Function_ Function}. */
interface FunctionStats {
    backlog: number;
    numTotalRunners: number;
}
/** Optional parameters for {@link Function_#updateAutoscaler Function_.updateAutoscaler()}. */
interface FunctionUpdateAutoscalerParams {
    minContainers?: number;
    maxContainers?: number;
    bufferContainers?: number;
    scaledownWindowMs?: number;
}
/** Configuration options for {@link Function_#withOptions Function_.withOptions()}. */
type FunctionWithOptionsParams = {
    cpu?: number;
    cpuLimit?: number;
    memoryMiB?: number;
    memoryLimitMiB?: number;
    gpu?: string;
    env?: Record<string, string>;
    secrets?: Secret[];
    volumes?: Record<string, Volume>;
    retries?: number | Retries;
    maxContainers?: number;
    bufferContainers?: number;
    scaledownWindowMs?: number;
    timeoutMs?: number;
};
/** Configuration options for {@link Function_#withConcurrency Function_.withConcurrency()}. */
type FunctionWithConcurrencyParams = {
    maxInputs: number;
    targetInputs?: number;
};
/** Configuration options for {@link Function_#withBatching Function_.withBatching()}. */
type FunctionWithBatchingParams = {
    maxBatchSize: number;
    waitMs: number;
};
/** Internal data structure holding configuration options for {@link Function_ Function}. */
type FunctionOptions = FunctionWithOptionsParams & {
    maxConcurrentInputs?: number;
    targetConcurrentInputs?: number;
    batchMaxSize?: number;
    batchWaitMs?: number;
};
/** Represents a deployed Modal Function, which can be invoked remotely. */
declare class Function_ {
    #private;
    readonly functionId: string;
    readonly methodName?: string;
    /** @ignore */
    constructor(client: ModalClient, functionId: string, methodName?: string, functionHandleMetadata?: FunctionHandleMetadata, options?: FunctionOptions);
    /** Override the static Function configuration at runtime. */
    withOptions(options: FunctionWithOptionsParams): Function_;
    /** Override the static Function concurrency configuration at runtime. */
    withConcurrency(params: FunctionWithConcurrencyParams): Function_;
    /** Override the static Function batching configuration at runtime. */
    withBatching(params: FunctionWithBatchingParams): Function_;
    /** Create an instance of the Function with configuration specified by
     * {@link Function_#withOptions withOptions}, {@link Function_#withConcurrency withConcurrency},
     * and/or {@link Function_#withBatching withBatching}. */
    instance(): Promise<Function_>;
    remote(args?: any[], kwargs?: Record<string, any>): Promise<any>;
    spawn(args?: any[], kwargs?: Record<string, any>): Promise<FunctionCall>;
    getCurrentStats(): Promise<FunctionStats>;
    updateAutoscaler(params: FunctionUpdateAutoscalerParams): Promise<void>;
    /**
     * URL for addressing the Web Function via HTTP.
     * @returns The web URL, or undefined if this is not a Web Function
     */
    getWebUrl(): Promise<string | undefined>;
}

/** Optional parameters for {@link ClsService#fromName client.cls.fromName()}. */
type ClsFromNameParams = {
    environment?: string;
    createIfMissing?: boolean;
};
/**
 * Service for managing {@link Cls}.
 *
 * Normally only ever accessed via the client as:
 * ```typescript
 * const modal = new ModalClient();
 * const cls = await modal.cls.fromName("my-app", "MyCls");
 * ```
 */
declare class ClsService {
    #private;
    constructor(client: ModalClient);
    /**
     * Reference a {@link Cls} from a deployed {@link App} by its name.
     */
    fromName(appName: string, name: string, params?: ClsFromNameParams): Promise<Cls>;
}
type ClsWithOptionsParams = FunctionWithOptionsParams;
type ClsWithConcurrencyParams = FunctionWithConcurrencyParams;
type ClsWithBatchingParams = FunctionWithBatchingParams;
/** Represents a deployed Modal Cls. */
declare class Cls {
    #private;
    /** @ignore */
    constructor(client: ModalClient, serviceFunctionId: string, serviceFunctionMetadata: FunctionHandleMetadata, options?: FunctionOptions);
    /** Create a new instance of the Cls with parameters and/or runtime options. */
    instance(parameters?: Record<string, any>): Promise<ClsInstance>;
    /** Override the static Function configuration at runtime. */
    withOptions(options: ClsWithOptionsParams): Cls;
    /** Create an instance of the Cls with input concurrency enabled or overridden with new values. */
    withConcurrency(params: ClsWithConcurrencyParams): Cls;
    /** Create an instance of the Cls with dynamic batching enabled or overridden with new values. */
    withBatching(params: ClsWithBatchingParams): Cls;
}
/** Represents an instance of a deployed Modal {@link Cls}, optionally with parameters. */
declare class ClsInstance {
    #private;
    constructor(methods: Map<string, Function_>);
    method(name: string): Function_;
}

/** Optional parameters for {@link ImageService#fromName client.images.fromName()}. */
type ImageFromNameParams = {
    /** Modal Environment to resolve the named Image in. */
    environment?: string;
};
/**
 * Service for managing {@link Image}s.
 *
 * Normally only ever accessed via the client as:
 * ```typescript
 * const modal = new ModalClient();
 * const image = await modal.images.fromRegistry("alpine");
 * ```
 */
declare class ImageService {
    #private;
    constructor(client: ModalClient);
    /**
     * Creates an {@link Image} from an Image ID
     *
     * @param imageId - Image ID.
     */
    fromId(imageId: string): Promise<Image>;
    /**
     * Reference a named {@link Image} that was previously published.
     *
     * @param name - Name of the published Image, optionally including a tag as `name:tag`.
     * If no tag is included, `:latest` is used.
     * @param params - Optional environment.
     */
    fromName(name: string, params?: ImageFromNameParams): Promise<Image>;
    /**
     * Creates an {@link Image} from a raw registry tag, optionally using a {@link Secret} for authentication.
     *
     * @param tag - The registry tag for the Image.
     * @param secret - Optional. A Secret containing credentials for registry authentication.
     */
    fromRegistry(tag: string, secret?: Secret): Image;
    /**
     * Creates an {@link Image} from a raw registry tag, optionally using a {@link Secret} for authentication.
     *
     * @param tag - The registry tag for the Image.
     * @param secret - A Secret containing credentials for registry authentication.
     */
    fromAwsEcr(tag: string, secret: Secret): Image;
    /**
     * Creates an {@link Image} from a raw registry tag, optionally using a {@link Secret} for authentication.
     *
     * @param tag - The registry tag for the Image.
     * @param secret - A Secret containing credentials for registry authentication.
     */
    fromGcpArtifactRegistry(tag: string, secret: Secret): Image;
    /**
     * Delete an {@link Image} by ID.
     *
     * Deletion is irreversible and will prevent Functions/Sandboxes from using the Image.
     *
     * Note: When building an Image, each chained method call will create an
     * intermediate Image layer, each with its own ID. Deleting an Image will not
     * delete any of its intermediate layers, only the image identified by the
     * provided ID.
     */
    delete(imageId: string, _?: ImageDeleteParams): Promise<void>;
}
/** Optional parameters for {@link ImageService#delete client.images.delete()}. */
type ImageDeleteParams = Record<never, never>;
/** Optional parameters for {@link Image#publish Image.publish()}. */
type ImagePublishParams = {
    /** Modal Environment to publish the named Image in. */
    environment?: string;
};
/** Optional parameters for {@link Image#dockerfileCommands Image.dockerfileCommands()}. */
type ImageDockerfileCommandsParams = {
    /** Environment variables to set in the build environment. */
    env?: Record<string, string>;
    /** {@link Secret}s 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?: boolean;
};
/** Represents a single image layer with its build configuration. */
type Layer = {
    commands: string[];
    env?: Record<string, string>;
    secrets?: Secret[];
    gpuConfig?: GPUConfig;
    forceBuild?: boolean;
};
/** A container image, used for starting {@link Sandbox}es. */
declare class Image {
    #private;
    /** @ignore */
    constructor(client: ModalClient, imageId: string, tag: string, imageRegistryConfig?: ImageRegistryConfig, layers?: Layer[], baseImageId?: string);
    get imageId(): string;
    private static validateDockerfileCommands;
    /**
     * Extend an image with arbitrary Dockerfile-like commands.
     *
     * Each call creates a new Image layer that will be built sequentially.
     * The provided options apply only to this layer.
     *
     * @param commands - Array of Dockerfile commands as strings
     * @param params - Optional configuration for this layer's build
     * @returns A new Image instance
     */
    dockerfileCommands(commands: string[], params?: ImageDockerfileCommandsParams): Image;
    /**
     * Eagerly builds an Image on Modal.
     *
     * @param app - App to use to build the Image.
     */
    build(app: App): Promise<Image>;
    /**
     * Publish this built Image under a stable name and tag.
     *
     * @param name - Name to publish the Image under, optionally including a tag as `name:tag`.
     * If no tag is included, `:latest` is used.
     * @param params - Optional environment.
     */
    publish(name: string, params?: ImagePublishParams): Promise<void>;
}

/**
 * Service for managing {@link Proxy Proxies}.
 */
declare class ProxyService {
    #private;
    constructor(client: ModalClient);
    /**
     * Reference a {@link Proxy} by its name.
     *
     * Normally only ever accessed via the client as:
     * ```typescript
     * const modal = new ModalClient();
     * const proxy = await modal.proxies.fromName("my-proxy");
     * ```
     */
    fromName(name: string, params?: ProxyFromNameParams): Promise<Proxy>;
}
/** Optional parameters for {@link ProxyService#fromName client.proxies.fromName()}. */
type ProxyFromNameParams = {
    environment?: string;
};
/** Proxy objects give your Modal containers a static outbound IP address. */
declare class Proxy {
    readonly proxyId: string;
    /** @ignore */
    constructor(proxyId: string);
}

/** Optional parameters for {@link QueueService#fromName client.queues.fromName()}. */
type QueueFromNameParams = {
    environment?: string;
    createIfMissing?: boolean;
};
/** Optional parameters for {@link QueueService#delete client.queues.delete()}. */
type QueueDeleteParams = {
    environment?: string;
    allowMissing?: boolean;
};
/** Optional parameters for {@link QueueService#ephemeral client.queues.ephemeral()}. */
type QueueEphemeralParams = {
    environment?: string;
};
/**
 * Service for managing {@link Queue}s.
 *
 * Normally only ever accessed via the client as:
 * ```typescript
 * const modal = new ModalClient();
 * const queue = await modal.queues.fromName("my-queue");
 * ```
 */
declare class QueueService {
    #private;
    constructor(client: ModalClient);
    /**
     * Create a nameless, temporary {@link Queue}.
     * You will need to call {@link Queue#closeEphemeral Queue.closeEphemeral()} to delete the Queue.
     */
    ephemeral(params?: QueueEphemeralParams): Promise<Queue>;
    /**
     * Reference a {@link Queue} by name.
     */
    fromName(name: string, params?: QueueFromNameParams): Promise<Queue>;
    /**
     * Delete a {@link Queue} by name.
     *
     * Warning: Deletion is irreversible and will affect any Apps currently using the Queue.
     */
    delete(name: string, params?: QueueDeleteParams): Promise<void>;
}
/** Optional parameters for {@link Queue#clear Queue.clear()}. */
type QueueClearParams = {
    /** Partition to clear, uses default partition if not set. */
    partition?: string;
    /** Set to clear all Queue partitions. */
    all?: boolean;
};
/** Optional parameters for {@link Queue#get Queue.get()}. */
type QueueGetParams = {
    /** How long to wait if the Queue is empty in milliseconds (default: indefinite). */
    timeoutMs?: number;
    /** Partition to fetch values from, uses default partition if not set. */
    partition?: string;
};
/** Optional parameters for {@link Queue#getMany Queue.getMany()}. */
type QueueGetManyParams = QueueGetParams;
/** Optional parameters for {@link Queue#put Queue.put()}. */
type QueuePutParams = {
    /** How long to wait if the Queue is full in milliseconds (default: indefinite). */
    timeoutMs?: number;
    /** Partition to add items to, uses default partition if not set. */
    partition?: string;
    /** TTL for the partition in milliseconds (default: 1 day). */
    partitionTtlMs?: number;
};
/** Optional parameters for {@link Queue#putMany Queue.putMany()}. */
type QueuePutManyParams = QueuePutParams;
/** Optional parameters for {@link Queue#len Queue.len()}. */
type QueueLenParams = {
    /** Partition to compute length, uses default partition if not set. */
    partition?: string;
    /** Return the total length across all partitions. */
    total?: boolean;
};
/** Optional parameters for {@link Queue#iterate Queue.iterate()}. */
type QueueIterateParams = {
    /** How long to wait between successive items before exiting iteration in milliseconds (default: 0). */
    itemPollTimeoutMs?: number;
    /** Partition to iterate, uses default partition if not set. */
    partition?: string;
};
/**
 * Distributed, FIFO queue for data flow in Modal {@link App Apps}.
 */
declare class Queue {
    #private;
    readonly queueId: string;
    readonly name?: string;
    /** @ignore */
    constructor(client: ModalClient, queueId: string, name?: string, ephemeralHbManager?: EphemeralHeartbeatManager);
    /** Delete the ephemeral Queue. Only usable with ephemeral Queues. */
    closeEphemeral(): void;
    /**
     * Remove all objects from a Queue partition.
     */
    clear(params?: QueueClearParams): Promise<void>;
    /**
     * Remove and return the next object from the Queue.
     *
     * By default, this will wait until at least one item is present in the Queue.
     * If `timeoutMs` is set, raises `QueueEmptyError` if no items are available
     * within that timeout in milliseconds.
     */
    get(params?: QueueGetParams): Promise<any | null>;
    /**
     * Remove and return up to `n` objects from the Queue.
     *
     * By default, this will wait until at least one item is present in the Queue.
     * If `timeoutMs` is set, raises `QueueEmptyError` if no items are available
     * within that timeout in milliseconds.
     */
    getMany(n: number, params?: QueueGetManyParams): Promise<any[]>;
    /**
     * Add an item to the end of the Queue.
     *
     * If the Queue is full, this will retry with exponential backoff until the
     * provided `timeoutMs` is reached, or indefinitely if `timeoutMs` is not set.
     * Raises {@link QueueFullError} if the Queue is still full after the timeout.
     */
    put(v: any, params?: QueuePutParams): Promise<void>;
    /**
     * Add several items to the end of the Queue.
     *
     * If the Queue is full, this will retry with exponential backoff until the
     * provided `timeoutMs` is reached, or indefinitely if `timeoutMs` is not set.
     * Raises {@link QueueFullError} if the Queue is still full after the timeout.
     */
    putMany(values: any[], params?: QueuePutManyParams): Promise<void>;
    /** Return the number of objects in the Queue. */
    len(params?: QueueLenParams): Promise<number>;
    /** Iterate through items in a Queue without mutation. */
    iterate(params?: QueueIterateParams): AsyncGenerator<any, void, unknown>;
}

declare enum TaskExecStderrConfig {
    /** TASK_EXEC_STDERR_CONFIG_DEVNULL - The output will be discarded. */
    TASK_EXEC_STDERR_CONFIG_DEVNULL = 0,
    /** TASK_EXEC_STDERR_CONFIG_PIPE - The output will be streamed to the client. */
    TASK_EXEC_STDERR_CONFIG_PIPE = 1,
    /**
     * TASK_EXEC_STDERR_CONFIG_STDOUT - A special value that can be used to indicate that the stderr stream should
     * be merged with the stdout stream.
     */
    TASK_EXEC_STDERR_CONFIG_STDOUT = 2,
    UNRECOGNIZED = -1
}
declare enum TaskExecStdoutConfig {
    /** TASK_EXEC_STDOUT_CONFIG_DEVNULL - The output will be discarded. */
    TASK_EXEC_STDOUT_CONFIG_DEVNULL = 0,
    /** TASK_EXEC_STDOUT_CONFIG_PIPE - The output will be streamed to the client. */
    TASK_EXEC_STDOUT_CONFIG_PIPE = 1,
    UNRECOGNIZED = -1
}
interface TaskContainerCreateRequest {
    taskId: string;
    /** Logical container name. */
    containerName: string;
    imageId: string;
    args: string[];
    env: {
        [key: string]: string;
    };
    workdir: string;
    /** Secret IDs to inject into the container as environment variables. */
    secretIds: string[];
}
declare const TaskContainerCreateRequest: MessageFns<TaskContainerCreateRequest>;
interface TaskContainerCreateResponse {
    /** Fully qualified container ID (for example, ctr-<ulid>). */
    containerId: string;
    /** Logical container name associated with this container. */
    containerName: string;
}
declare const TaskContainerCreateResponse: MessageFns<TaskContainerCreateResponse>;
interface TaskContainerGetRequest {
    taskId: string;
    containerName: string;
    /** Include the latest terminated container if the name is no longer active. */
    includeTerminated: boolean;
}
declare const TaskContainerGetRequest: MessageFns<TaskContainerGetRequest>;
interface TaskContainerGetResponse {
    container: TaskContainerInfo | undefined;
}
declare const TaskContainerGetResponse: MessageFns<TaskContainerGetResponse>;
interface TaskContainerInfo {
    containerId: string;
    containerName: string;
    status: string;
    result: GenericResult | undefined;
}
declare const TaskContainerInfo: MessageFns<TaskContainerInfo>;
interface TaskContainerListRequest {
    taskId: string;
    /** Include all tracked terminated containers in addition to active ones. */
    includeTerminated: boolean;
}
declare const TaskContainerListRequest: MessageFns<TaskContainerListRequest>;
interface TaskContainerListResponse {
    containers: TaskContainerInfo[];
}
declare const TaskContainerListResponse: MessageFns<TaskContainerListResponse>;
interface TaskContainerTerminateRequest {
    taskId: string;
    containerId: string;
}
declare const TaskContainerTerminateRequest: MessageFns<TaskContainerTerminateRequest>;
interface TaskContainerWaitRequest {
    taskId: string;
    containerId: string;
    timeout: number;
}
declare const TaskContainerWaitRequest: MessageFns<TaskContainerWaitRequest>;
interface TaskContainerWaitResponse {
    result: GenericResult | undefined;
}
declare const TaskContainerWaitResponse: MessageFns<TaskContainerWaitResponse>;
/**
 * The response to a TaskExecPollRequest. If the exec'd command has not
 * completed, exit_status will be unset.
 */
interface TaskExecPollResponse {
    /** The exit code of the command. */
    code?: number | undefined;
    /** The signal that terminated the command. */
    signal?: number | undefined;
}
declare const TaskExecPollResponse: MessageFns<TaskExecPollResponse>;
interface TaskExecStartRequest {
    /** The ID of the task to execute the command in. */
    taskId: string;
    /**
     * Execution ID. This ID will be used to identify the execution for other
     * requests and ensure exec commands are idempotent.
     */
    execId: string;
    /** Command arguments to execute. */
    commandArgs: string[];
    /** Configures how the stdout of the command will be handled. */
    stdoutConfig: TaskExecStdoutConfig;
    /** Configures how the stderr of the command will be handled. */
    stderrConfig: TaskExecStderrConfig;
    /**
     * Timeout in seconds for the exec'd command to exit. If the command does not
     * exit within this duration, the command will be killed. This is NOT the
     * timeout for the ExecStartRequest RPC to complete.
     */
    timeoutSecs?: number | undefined;
    /** Working directory for the command. */
    workdir?: string | undefined;
    /** Secret IDs to mount into the task. */
    secretIds: string[];
    /** PTY info for the command. */
    ptyInfo?: PTYInfo | undefined;
    /**
     * Enable debugging capabilities on the container runtime. Used only for
     * internal debugging.
     */
    runtimeDebug: boolean;
    /** Fully qualified target container ID. Empty targets the main container. */
    containerId: string;
    /** Environment variables to set directly for the exec'd command. */
    env: {
        [key: string]: string;
    };
}
declare const TaskExecStartRequest: MessageFns<TaskExecStartRequest>;
interface TaskExecStartResponse {
}
declare const TaskExecStartResponse: MessageFns<TaskExecStartResponse>;
interface TaskExecStdinWriteResponse {
}
declare const TaskExecStdinWriteResponse: MessageFns<TaskExecStdinWriteResponse>;
interface TaskExecStdioReadResponse {
    /** The data read from the file descriptor. */
    data: Uint8Array;
}
declare const TaskExecStdioReadResponse: MessageFns<TaskExecStdioReadResponse>;
interface TaskExecWaitResponse {
    /** The exit code of the command. */
    code?: number | undefined;
    /** The signal that terminated the command. */
    signal?: number | undefined;
}
declare const TaskExecWaitResponse: MessageFns<TaskExecWaitResponse>;
interface TaskMountDirectoryRequest {
    taskId: string;
    path: Uint8Array;
    imageId: string;
    /**
     * Customer-supplied encryption key used to decrypt CSEK-encrypted image metadata keys.
     * This key is not persisted by Modal.
     */
    customerSuppliedEncryptionKey?: Uint8Array | undefined;
}
declare const TaskMountDirectoryRequest: MessageFns<TaskMountDirectoryRequest>;
interface TaskSnapshotDirectoryRequest {
    taskId: string;
    path: Uint8Array;
    /** A unique ID to ensure idempotency of directory snapshot requests. */
    snapshotId: string;
    /**
     * Lifetime for the resulting image, in seconds. When set, the
     * image's expires_at is a hard cutoff: it is fixed at creation time
     * and is not extended on use.
     *
     * When unset, the resulting image gets the legacy retention policy:
     * a 30-day TTL that is bumped forward by 30 days on every use, so
     * active images effectively never expire.
     *
     * Sentinel: -1 means "no expiry" (the image never expires).
     * 0 and other negative values are invalid and rejected by the
     * server.
     */
    ttlSeconds?: number | undefined;
    /**
     * Customer-supplied encryption key used to encrypt the resulting image's data and tree
     * metadata keys. This key is not persisted by Modal.
     */
    customerSuppliedEncryptionKey?: Uint8Array | undefined;
}
declare const TaskSnapshotDirectoryRequest: MessageFns<TaskSnapshotDirectoryRequest>;
interface TaskSnapshotDirectoryResponse {
    imageId: string;
}
declare const TaskSnapshotDirectoryResponse: MessageFns<TaskSnapshotDirectoryResponse>;
interface TaskSnapshotFilesystemRequest {
    taskId: string;
    /** A unique ID to ensure idempotency of filesystem snapshot requests. */
    snapshotId: string;
    /**
     * Lifetime for the resulting image, in seconds. Must be set. When positive,
     * the image expiry is a hard cutoff: it is fixed at creation time and is
     * not extended on use.
     *
     * Sentinel: -1 means "no expiry" (the image never expires).
     * 0 and other negative values are invalid and rejected by the
     * server.
     */
    ttlSeconds?: number | undefined;
    /**
     * Customer-supplied encryption key used to encrypt the resulting image's data and tree
     * metadata keys. This key is not persisted by Modal.
     */
    customerSuppliedEncryptionKey?: Uint8Array | undefined;
}
declare const TaskSnapshotFilesystemRequest: MessageFns<TaskSnapshotFilesystemRequest>;
interface TaskSnapshotFilesystemResponse {
    imageId: string;
}
declare const TaskSnapshotFilesystemResponse: MessageFns<TaskSnapshotFilesystemResponse>;
interface TaskUnmountDirectoryRequest {
    taskId: string;
    path: Uint8Array;
}
declare const TaskUnmountDirectoryRequest: MessageFns<TaskUnmountDirectoryRequest>;
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : Partial<T>;
interface MessageFns<T> {
    encode(message: T, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): T;
    fromJSON(object: any): T;
    toJSON(message: T): unknown;
    create(base?: DeepPartial<T>): T;
    fromPartial(object: DeepPartial<T>): T;
}

type LogLevel = "debug" | "info" | "warn" | "error";
interface Logger {
    debug(message: string, ...args: any[]): void;
    info(message: string, ...args: any[]): void;
    warn(message: string, ...args: any[]): void;
    error(message: string, ...args: any[]): void;
}

/** Resolved configuration object from `Config` and environment variables. */
interface Profile {
    serverUrl: string;
    tokenId?: string;
    tokenSecret?: string;
    environment?: string;
    imageBuilderVersion?: string;
    logLevel?: string;
    /** Parsed from MODAL_MAX_THROTTLE_WAIT. null means unlimited. */
    maxThrottleWaitSecs?: number;
}

/** @ignore */
declare class TaskCommandRouterClientImpl {
    private stub;
    private channel;
    private serverClient;
    private taskId;
    private sandboxId;
    private isV2;
    private serverUrl;
    private jwt;
    private jwtExp;
    private jwtRefreshLock;
    private logger;
    private closed;
    static tryInit(serverClient: ModalGrpcClient, taskId: string, sandboxId: string, isV2: boolean, logger: Logger, profile: Profile): Promise<TaskCommandRouterClientImpl | null>;
    private constructor();
    close(): void;
    /** Run a unary RPC against the command router with the default retry policy. */
    private callUnary;
    execStart(request: TaskExecStartRequest): Promise<TaskExecStartResponse>;
    containerCreate(request: TaskContainerCreateRequest): Promise<TaskContainerCreateResponse>;
    containerGet(request: TaskContainerGetRequest): Promise<TaskContainerGetResponse>;
    containerList(request: TaskContainerListRequest): Promise<TaskContainerListResponse>;
    containerTerminate(request: TaskContainerTerminateRequest): Promise<void>;
    containerWait(request: TaskContainerWaitRequest): Promise<TaskContainerWaitResponse>;
    execStdioRead(taskId: string, execId: string, fileDescriptor: FileDescriptor, deadline?: number | null): AsyncGenerator<TaskExecStdioReadResponse>;
    execStdinWrite(taskId: string, execId: string, offset: number, data: Uint8Array, eof: boolean): Promise<TaskExecStdinWriteResponse>;
    execPoll(taskId: string, execId: string, deadline?: number | null): Promise<TaskExecPollResponse>;
    execWait(taskId: string, execId: string, deadline?: number | null): Promise<TaskExecWaitResponse>;
    mountDirectory(request: TaskMountDirectoryRequest): Promise<void>;
    snapshotDirectory(request: TaskSnapshotDirectoryRequest, options?: TimeoutOptions): Promise<TaskSnapshotDirectoryResponse>;
    snapshotFilesystem(request: TaskSnapshotFilesystemRequest, options?: TimeoutOptions): Promise<TaskSnapshotFilesystemResponse>;
    unmountDirectory(request: TaskUnmountDirectoryRequest): Promise<void>;
    private refreshJwt;
    private callWithAuthRetry;
    private streamStdio;
}

/** Type of a filesystem entry. */
type FileType = "file" | "directory" | "symlink";
/** Metadata for a file or directory entry in a Sandbox. */
interface FileInfo {
    readonly name: string;
    readonly path: string;
    readonly type: FileType;
    readonly size: number;
    readonly mode: number;
    readonly permissions: string;
    readonly owner: string;
    readonly group: string;
    /** Unix epoch seconds. */
    readonly modifiedTime: number;
    readonly symlinkTarget: string | null;
}
/** Namespace for Sandbox filesystem APIs. */
declare class SandboxFilesystem {
    private readonly exec;
    /** @ignore */
    constructor(exec: (command: string[], params?: SandboxExecParams) => Promise<ContainerProcess>);
    /**
     * Copy a local file into the Sandbox.
     *
     * `remotePath` must be an absolute path to a file in the Sandbox.
     * Parent directories are created if needed. The remote file is overwritten
     * if it already exists.
     *
     * @throws {SandboxFilesystemNotADirectoryError} a parent component of `remotePath` is not a directory.
     * @throws {SandboxFilesystemIsADirectoryError} `remotePath` points to a directory.
     * @throws {SandboxFilesystemPermissionError} write permission is denied in the Sandbox.
     * @throws {SandboxFilesystemError} the command fails for any other reason.
     * @throws {Error} `localPath` does not exist, is a directory, or cannot be read (`ENOENT`, `EISDIR`, `EACCES`).
     */
    copyFromLocal(localPath: string, remotePath: string): Promise<void>;
    /**
     * Copy a file from the Sandbox to a local path.
     *
     * `remotePath` must be an absolute path to a file in the Sandbox.
     * Parent directories for `localPath` are created if needed. The local file
     * is overwritten if it already exists.
     *
     * @throws {SandboxFilesystemNotFoundError} the remote path does not exist.
     * @throws {SandboxFilesystemIsADirectoryError} the remote path points to a directory.
     * @throws {SandboxFilesystemFileTooLargeError} the file exceeds the read size limit.
     * @throws {SandboxFilesystemPermissionError} read permission is denied in the Sandbox.
     * @throws {SandboxFilesystemError} the command fails for any other reason.
     * @throws {Error} `localPath` points to a directory, or writing it is not permitted.
     */
    copyToLocal(remotePath: string, localPath: string): Promise<void>;
    /**
     * List files and directories in a Sandbox directory.
     *
     * `remotePath` must be an absolute path to a directory in the Sandbox.
     * Returns an array of {@link FileInfo} objects sorted by name.
     *
     * @throws {SandboxFilesystemNotFoundError} the path does not exist.
     * @throws {SandboxFilesystemNotADirectoryError} the path is not a directory.
     * @throws {SandboxFilesystemPermissionError} read permission is denied.
     * @throws {SandboxFilesystemError} the command fails for any other reason.
     */
    listFiles(remotePath: string): Promise<FileInfo[]>;
    /**
     * Create a new directory in the Sandbox.
     *
     * `remotePath` must be an absolute path in the Sandbox.
     *
     * When `createParents` is `true` (the default), any missing parent
     * directories are created and the call is idempotent (succeeds if the
     * directory already exists). When `createParents` is `false`, the immediate
     * parent must already exist and the path must not already exist.
     *
     * @throws {SandboxFilesystemNotFoundError} the parent does not exist and `createParents` is `false`.
     * @throws {SandboxFilesystemPathAlreadyExistsError} the path already exists and `createParents` is `false`.
     * @throws {SandboxFilesystemNotADirectoryError} a path component is not a directory.
     * @throws {SandboxFilesystemPermissionError} creation is not permitted.
     * @throws {InvalidError} the operation is not supported by the mount.
     * @throws {SandboxFilesystemError} the command fails for any other reason.
     */
    makeDirectory(remotePath: string, options?: {
        createParents?: boolean;
    }): Promise<void>;
    /**
     * Read a file from the Sandbox and return its contents as bytes.
     *
     * `remotePath` must be an absolute path to a file in the Sandbox.
     *
     * @throws {SandboxFilesystemNotFoundError} the path does not exist.
     * @throws {SandboxFilesystemIsADirectoryError} the path points to a directory.
     * @throws {SandboxFilesystemFileTooLargeError} the file exceeds the read size limit.
     * @throws {SandboxFilesystemPermissionError} read permission is denied.
     * @throws {SandboxFilesystemError} the command fails for any other reason.
     */
    readBytes(remotePath: string): Promise<Uint8Array>;
    /**
     * Read a file from the Sandbox and return its contents as a UTF-8 string.
     *
     * `remotePath` must be an absolute path to a file in the Sandbox.
     *
     * @throws {SandboxFilesystemNotFoundError} the path does not exist.
     * @throws {SandboxFilesystemIsADirectoryError} the path points to a directory.
     * @throws {SandboxFilesystemFileTooLargeError} the file exceeds the read size limit.
     * @throws {SandboxFilesystemPermissionError} read permission is denied.
     * @throws {SandboxFilesystemError} the command fails for any other reason.
     */
    readText(remotePath: string): Promise<string>;
    /**
     * Remove a file or directory in the Sandbox.
     *
     * `remotePath` must be an absolute path in the Sandbox. When `remotePath`
     * is a directory and `recursive` is `false` (the default), it is removed
     * only if empty. When `recursive` is `true`, the directory and all its
     * contents are removed. Recursive removal is not supported on all mounts —
     * `CloudBucketMount` does not support it.
     *
     * @throws {SandboxFilesystemNotFoundError} the path does not exist.
     * @throws {SandboxFilesystemDirectoryNotEmptyError} `recursive` is `false` and the directory is not empty.
     * @throws {SandboxFilesystemPermissionError} removal is not permitted.
     * @throws {InvalidError} the operation is not supported by the mount.
     * @throws {SandboxFilesystemError} the command fails for any other reason.
     */
    remove(remotePath: string, options?: {
        recursive?: boolean;
    }): Promise<void>;
    /**
     * Return metadata for a single file, directory, or symlink in the Sandbox.
     *
     * `remotePath` must be an absolute path in the Sandbox. If `remotePath` is
     * a symlink, the returned {@link FileInfo} describes the symlink itself, not
     * the target it points to.
     *
     * @throws {SandboxFilesystemNotFoundError} the path does not exist.
     * @throws {SandboxFilesystemNotADirectoryError} a non-leaf component of the path is not a directory.
     * @throws {SandboxFilesystemPermissionError} a path component is not searchable.
     * @throws {SandboxFilesystemError} the command fails for any other reason.
     */
    stat(remotePath: string): Promise<FileInfo>;
    /**
     * Write binary content to a file in the Sandbox.
     *
     * `remotePath` must be an absolute path to a file in the Sandbox.
     * Parent directories are created if needed. The remote file is overwritten
     * if it already exists.
     *
     * @throws {TypeError} `data` is not a `Uint8Array`, `ArrayBuffer`, or `Buffer`.
     * @throws {SandboxFilesystemNotADirectoryError} a parent component of `remotePath` is not a directory.
     * @throws {SandboxFilesystemIsADirectoryError} `remotePath` points to a directory.
     * @throws {SandboxFilesystemPermissionError} write permission is denied.
     * @throws {SandboxFilesystemError} the command fails for any other reason.
     */
    writeBytes(data: Uint8Array | ArrayBuffer | Buffer, remotePath: string): Promise<void>;
    /**
     * Write UTF-8 text to a file in the Sandbox.
     *
     * `remotePath` must be an absolute path to a file in the Sandbox.
     * Parent directories are created if needed. The remote file is overwritten
     * if it already exists.
     *
     * @throws {TypeError} `data` is not a string.
     * @throws {SandboxFilesystemNotADirectoryError} a parent component of `remotePath` is not a directory.
     * @throws {SandboxFilesystemIsADirectoryError} `remotePath` points to a directory.
     * @throws {SandboxFilesystemPermissionError} write permission is denied.
     * @throws {SandboxFilesystemError} the command fails for any other reason.
     */
    writeText(data: string, remotePath: string): Promise<void>;
}

type SandboxSidecarCommandRouter = Pick<TaskCommandRouterClientImpl, "containerCreate" | "containerGet" | "containerList" | "containerTerminate" | "containerWait">;
type SandboxSidecarAccess = {
    exec(command: string[], params: SandboxExecParams | undefined, containerId: string): Promise<ContainerProcess>;
    commandRouter(): Promise<[string, SandboxSidecarCommandRouter]>;
};
/** Options for {@link SidecarService#create SidecarService.create()}. */
type SidecarCreateParams = {
    /** Command to run in the sidecar container on startup. */
    command?: string[];
    /** Environment variables to set in the sidecar container. */
    env?: Record<string, string>;
    /** {@link Secret}s to inject into the sidecar container as environment variables. */
    secrets?: Secret[];
    /** Working directory of the sidecar container. */
    workdir?: string;
};
/** Options for {@link SidecarService#get SidecarService.get()}. */
type SidecarGetParams = {
    /** If true, return the latest container with the name even if it has terminated. */
    includeTerminated?: boolean;
};
/** Options for {@link SidecarService#list SidecarService.list()}. */
type SidecarListParams = {
    /** If true, include terminated containers. */
    includeTerminated?: boolean;
};
/** Options for {@link SidecarContainer#exec SidecarContainer.exec()}. */
type SidecarExecParams = SandboxExecParams;
/** Options for {@link SidecarContainer#terminate SidecarContainer.terminate()}. */
type SidecarTerminateParams = {
    /** If true, wait for the sidecar container to terminate. */
    wait?: boolean;
};
/**
 * Creates and manages sidecar containers inside a Sandbox.
 *
 * EXPERIMENTAL: the API is subject to change.
 */
declare class SidecarService {
    #private;
    /** @internal @hidden */
    constructor(access: SandboxSidecarAccess);
    /**
     * Start a new sidecar container in the Sandbox. The {@link Image} must
     * already be built by calling {@link Image#build Image.build()} before it is
     * passed to `create`.
     */
    create(name: string, image: Image, params?: SidecarCreateParams): Promise<SidecarContainer>;
    /** Return a sidecar container by name. */
    get(name: string, params?: SidecarGetParams): Promise<SidecarContainer>;
    /** Return all sidecar containers (not including the main container). */
    list(params?: SidecarListParams): Promise<SidecarContainer[]>;
}
/**
 * A handle to a sidecar container running in a Sandbox.
 *
 * EXPERIMENTAL: the API is subject to change.
 */
declare class SidecarContainer {
    #private;
    /** The fully qualified container ID. */
    readonly containerId: string;
    /** The logical name of the container within the Sandbox. */
    readonly containerName: string;
    /** @internal @hidden */
    constructor(access: SandboxSidecarAccess, containerId: string, containerName: string, result?: GenericResult);
    exec(command: string[], params?: SidecarExecParams & {
        mode?: "text";
    }): Promise<ContainerProcess<string>>;
    exec(command: string[], params: SidecarExecParams & {
        mode: "binary";
    }): Promise<ContainerProcess<Uint8Array>>;
    /** Namespace for filesystem APIs scoped to this sidecar container. */
    get filesystem(): SandboxFilesystem;
    /** Block until the sidecar container exits, and return its exit code. */
    wait(): Promise<number>;
    /**
     * Check if the sidecar container has finished running.
     *
     * Returns `null` if the container is still running, else the exit code.
     */
    poll(): Promise<number | null>;
    terminate(): Promise<void>;
    terminate(params: {
        wait: true;
    }): Promise<number>;
}

/**
 * Wrapper around `ReadableStream` with convenience functions.
 *
 * The Stream API is a modern standard for asynchronous data streams across
 * network and process boundaries. It allows you to read data in chunks, pipe
 * and transform it, and handle backpressure.
 *
 * This wrapper adds some extra functions like `.readText()` to read the entire
 * stream as a string, or `readBytes()` to read binary data.
 *
 * Background: https://developer.mozilla.org/en-US/docs/Web/API/Streams_API
 */
interface ModalReadStream<R = any> extends ReadableStream<R> {
    /** Read the entire stream as a string. */
    readText(): Promise<string>;
    /** Read the entire stream as a byte array. */
    readBytes(): Promise<Uint8Array>;
}
/**
 * Wrapper around `WritableStream` with convenience functions.
 *
 * The Stream API is a modern standard for asynchronous data streams across
 * network and process boundaries. It allows you to read data in chunks, pipe
 * and transform it, and handle backpressure.
 *
 * This wrapper adds some extra functions like `.writeText()` to write a string
 * to the stream, or `writeBytes()` to write binary data.
 *
 * Background: https://developer.mozilla.org/en-US/docs/Web/API/Streams_API
 */
interface ModalWriteStream<R = any> extends WritableStream<R> {
    /** Write a string to the stream. Only if this is a text stream. */
    writeText(text: string): Promise<void>;
    /** Write a byte array to the stream. Only if this is a byte stream. */
    writeBytes(bytes: Uint8Array): Promise<void>;
}

/**
 * Stdin is always present, but this option allow you to drop stdout or stderr
 * if you don't need them. The default is "pipe", matching Node.js behavior.
 *
 * If behavior is set to "ignore", the output streams will be empty.
 */
type StdioBehavior = "pipe" | "ignore";
/**
 * Specifies the type of data that will be read from the Sandbox or container
 * process. "text" means the data will be read as UTF-8 text, while "binary"
 * means the data will be read as raw bytes (Uint8Array).
 */
type StreamMode = "text" | "binary";
/** Optional parameters for {@link Probe.withTcp} and {@link Probe.withExec}. */
type ProbeParams = {
    intervalMs: number;
};
/** Probe configuration for sandbox readiness checks. */
declare class Probe {
    #private;
    private constructor();
    static withTcp(port: number, params?: ProbeParams): Probe;
    static withExec(argv: string[], params?: ProbeParams): Probe;
    /** @ignore */
    toProto(): Probe$1;
}
/** Optional parameters for {@link SandboxService#create client.sandboxes.create()}. */
type SandboxCreateParams = {
    /** Reservation of physical CPU cores for the Sandbox, can be fractional. */
    cpu?: number;
    /** Hard limit of physical CPU cores for the Sandbox, can be fractional. */
    cpuLimit?: number;
    /** Reservation of memory in MiB. */
    memoryMiB?: number;
    /** Hard limit of memory in MiB. */
    memoryLimitMiB?: number;
    /** GPU reservation for the Sandbox (e.g. "A100", "T4:2", "A100-80GB:4"). */
    gpu?: string;
    /** Maximum lifetime of the Sandbox in milliseconds. Defaults to 5 minutes. */
    timeoutMs?: number;
    /** The amount of time in milliseconds that a Sandbox can be idle before being terminated. */
    idleTimeoutMs?: number;
    /** Working directory of the Sandbox. */
    workdir?: string;
    /**
     * Sequence of program arguments for the main process.
     * Default behavior is to sleep indefinitely until timeout or termination.
     */
    command?: string[];
    /** Environment variables to set in the Sandbox. */
    env?: Record<string, string>;
    /** {@link Secret}s to inject into the Sandbox as environment variables. */
    secrets?: Secret[];
    /** Mount points for Modal {@link Volume}s. */
    volumes?: Record<string, Volume>;
    /** Mount points for {@link CloudBucketMount}s. */
    cloudBucketMounts?: Record<string, CloudBucketMount>;
    /** Enable a PTY for the Sandbox entrypoint command. When enabled, all output (stdout and
     * stderr from the process) is multiplexed into stdout, and the stderr stream is effectively empty. */
    pty?: boolean;
    /** List of ports to tunnel into the Sandbox. Encrypted ports are tunneled with TLS. */
    encryptedPorts?: number[];
    /** List of encrypted ports to tunnel into the Sandbox, using HTTP/2. */
    h2Ports?: number[];
    /** List of ports to tunnel into the Sandbox without encryption. */
    unencryptedPorts?: number[];
    /** Whether to block all network access from the Sandbox. */
    blockNetwork?: boolean;
    /** List of CIDRs the Sandbox is allowed to access. If not set, all CIDRs are allowed. Cannot be used with blockNetwork. */
    outboundCidrAllowlist?: string[];
    /** List of domain names the Sandbox is allowed to access. Supports wildcard prefixes (`*.example.com`). Cannot be used with blockNetwork. */
    outboundDomainAllowlist?: string[];
    /** List of CIDRs allowed to connect inbound to the Sandbox (tunnels and connection tokens). If not set, all IPs are allowed. Cannot be used with blockNetwork. */
    inboundCidrAllowlist?: string[];
    /** Cloud provider to run the Sandbox on. */
    cloud?: string;
    /** Region(s) to run the Sandbox on. */
    regions?: string[];
    /** Enable verbose logging. */
    verbose?: boolean;
    /** Reference to a Modal {@link Proxy} to use in front of this Sandbox. */
    proxy?: Proxy;
    /** Probe used to determine when the Sandbox has become ready. */
    readinessProbe?: Probe;
    /** Optional name for the Sandbox. Unique within an App. */
    name?: string;
    /** Tags to attach to the Sandbox. Filterable via {@link SandboxService#list client.sandboxes.list}. */
    tags?: Record<string, string>;
    /** Optional experimental options. */
    experimentalOptions?: Record<string, any>;
    /** If set, connections to this Sandbox will be subdomains of this domain rather than the default.
     * This requires prior manual setup by Modal and is only available for Enterprise customers.
     */
    customDomain?: string;
    /** If true, the sandbox will receive a MODAL_IDENTITY_TOKEN env var for OIDC-based auth (e.g. to AWS, GCP). */
    includeOidcIdentityToken?: boolean;
};
/**
 * Service for managing {@link Sandbox}es.
 *
 * Normally only ever accessed via the client as:
 * ```typescript
 * const modal = new ModalClient();
 * const sb = await modal.sandboxes.create(app, image);
 * ```
 */
declare class SandboxService {
    #private;
    constructor(client: ModalClient);
    /**
     * Create a new {@link Sandbox} in the {@link App} with the specified {@link Image} and options.
     */
    create(app: App, image: Image, params?: SandboxCreateParams): Promise<Sandbox>;
    /**
     * Create a new {@link Sandbox} using the experimental V2 backend.
     *
     * Supported features include exec, encrypted tunnels, wait/poll/terminate,
     * CPU and memory configuration, region placement, volumes, cloud bucket
     * mounts (with static credentials via {@link Secret}), and filesystem
     * snapshots.
     *
     * Features like tags, memory snapshots, GPUs, custom domains, OIDC identity
     * tokens (including `oidcAuthRoleArn` on a {@link CloudBucketMount}),
     * proxies, and readiness probes are not supported.
     *
     * V2 sandboxes created with this method are not currently returned by
     * {@link SandboxService#list client.sandboxes.list()} and cannot be looked up
     * with {@link SandboxService#fromName client.sandboxes.fromName()}. Store
     * {@link Sandbox#sandboxId sandbox.sandboxId} if you need to retrieve the
     * sandbox later, and use {@link SandboxService#fromId client.sandboxes.fromId()}
     * to reattach.
     */
    experimentalCreate(app: App, image: Image, params?: SandboxCreateParams): Promise<Sandbox>;
    /** Returns a running {@link Sandbox} object from an ID.
     *
     * @returns Sandbox with ID
     */
    fromId(sandboxId: string): Promise<Sandbox>;
    /** Get a running {@link Sandbox} by name from a deployed {@link App}.
     *
     * Raises a {@link NotFoundError} if no running Sandbox is found with the given name.
     * A Sandbox's name is the `name` argument passed to {@link SandboxService#create sandboxes.create()}.
     *
     * @param appName - Name of the deployed App
     * @param name - Name of the Sandbox
     * @param params - Optional parameters for getting the Sandbox
     * @returns Promise that resolves to a Sandbox
     */
    fromName(appName: string, name: string, params?: SandboxFromNameParams): Promise<Sandbox>;
    /**
     * List all {@link Sandbox}es for the current Environment or App ID (if specified).
     * If tags are specified, only Sandboxes that have at least those tags are returned.
     */
    list(params?: SandboxListParams): AsyncGenerator<Sandbox, void, unknown>;
}
/** Optional parameters for {@link SandboxService#list client.sandboxes.list()}. */
type SandboxListParams = {
    /** Filter Sandboxes for a specific {@link App}. */
    appId?: string;
    /** Only return Sandboxes that include all specified tags. */
    tags?: Record<string, string>;
    /** Override environment for the request; defaults to current profile. */
    environment?: string;
};
/** Optional parameters for {@link SandboxService#fromName client.sandboxes.fromName()}. */
type SandboxFromNameParams = {
    environment?: string;
};
/** Optional parameters for {@link Sandbox#exec Sandbox.exec()}. */
type SandboxExecParams = {
    /** Specifies text or binary encoding for input and output streams. */
    mode?: StreamMode;
    /** Whether to pipe or ignore standard output. */
    stdout?: StdioBehavior;
    /** Whether to pipe or ignore standard error. */
    stderr?: StdioBehavior;
    /** Working directory to run the command in. */
    workdir?: string;
    /** Timeout for the process in milliseconds. Defaults to 0 (no timeout). */
    timeoutMs?: number;
    /** Environment variables to set for the command. */
    env?: Record<string, string>;
    /** {@link Secret}s to inject as environment variables for the commmand.*/
    secrets?: Secret[];
    /** Enable a PTY for the command. When enabled, all output (stdout and stderr from the
     * process) is multiplexed into stdout, and the stderr stream is effectively empty. */
    pty?: boolean;
};
/** Optional parameters for {@link Sandbox#createConnectToken Sandbox.createConnectToken()}. */
type SandboxTerminateParams = {
    /** If true, wait for the Sandbox to finish and return the exit code. */
    wait?: boolean;
};
/** Optional parameters for {@link Sandbox#snapshotFilesystem Sandbox.snapshotFilesystem()}. */
type SandboxSnapshotFilesystemParams = {
    /**
     * Overall budget for the snapshot call, in milliseconds. Defaults to
     * 55000. If it elapses before a snapshot completes, the call is cancelled
     * and an error is thrown.
     */
    timeoutMs?: number;
    /**
     * Lifetime of the resulting image in milliseconds, as a hard cutoff
     * measured from creation. Defaults to 30 days. Pass `null` to retain
     * the image indefinitely.
     */
    ttlMs?: number | null;
};
/** Optional parameters for {@link Sandbox#snapshotDirectory Sandbox.snapshotDirectory()}. */
type SandboxSnapshotDirectoryParams = {
    /**
     * Overall budget for the snapshot call, in milliseconds. Defaults to
     * 55000. If it elapses before a snapshot completes, the call is cancelled
     * and an error is thrown.
     */
    timeoutMs?: number;
    /**
     * Lifetime of the resulting image in milliseconds, as a hard cutoff
     * measured from creation. Defaults to 30 days. Pass `null` to retain
     * the image indefinitely.
     */
    ttlMs?: number | null;
};
type SandboxCreateConnectTokenParams = {
    /** Optional user-provided metadata string that will be added to the headers by the proxy when forwarding requests to the Sandbox. */
    userMetadata?: string;
};
/** Credentials returned by {@link Sandbox#createConnectToken Sandbox.createConnectToken()}. */
type SandboxCreateConnectCredentials = {
    url: string;
    token: string;
};
/** A port forwarded from within a running Modal {@link Sandbox}. */
declare class Tunnel {
    host: string;
    port: number;
    unencryptedHost?: string | undefined;
    unencryptedPort?: number | undefined;
    /** @ignore */
    constructor(host: string, port: number, unencryptedHost?: string | undefined, unencryptedPort?: number | undefined);
    /** Get the public HTTPS URL of the forwarded port. */
    get url(): string;
    /** Get the public TLS socket as a [host, port] tuple. */
    get tlsSocket(): [string, number];
    /** Get the public TCP socket as a [host, port] tuple. */
    get tcpSocket(): [string, number];
}
/** Sandboxes are secure, isolated containers in Modal that boot in seconds. */
declare class Sandbox {
    #private;
    readonly sandboxId: string;
    /** @ignore */
    constructor(client: ModalClient, sandboxId: string, params?: {
        isV2?: boolean;
        taskId?: string;
        tunnels?: Record<number, Tunnel>;
    });
    get stdin(): ModalWriteStream<string>;
    get stdout(): ModalReadStream<string>;
    get stderr(): ModalReadStream<string>;
    get filesystem(): SandboxFilesystem;
    /**
     * Operations for managing sidecar containers that run alongside the
     * Sandbox's main container.
     *
     * EXPERIMENTAL: the API is subject to change.
     */
    get experimentalSidecars(): SidecarService;
    /** Set tags (key-value pairs) on the Sandbox. Tags can be used to filter results in {@link SandboxService#list client.sandboxes.list}. */
    setTags(tags: Record<string, string>): Promise<void>;
    /** Get tags (key-value pairs) currently attached to this Sandbox from the server. */
    getTags(): Promise<Record<string, string>>;
    exec(command: string[], params?: SandboxExecParams & {
        mode?: "text";
    }): Promise<ContainerProcess<string>>;
    exec(command: string[], params: SandboxExecParams & {
        mode: "binary";
    }): Promise<ContainerProcess<Uint8Array>>;
    /**
     * Create a token for making HTTP connections to the Sandbox.
     */
    createConnectToken(params?: SandboxCreateConnectTokenParams): Promise<SandboxCreateConnectCredentials>;
    terminate(): Promise<void>;
    terminate(params: {
        wait: true;
    }): Promise<number>;
    /**
     * Disconnect from the Sandbox, cleaning up local resources.
     * The Sandbox continues running on Modal's infrastructure.
     * After calling detach(), most operations on this Sandbox object will throw.
     */
    detach(): void;
    wait(): Promise<number>;
    /**
     * Wait until the Sandbox readiness probe reports the Sandbox is ready.
     *
     * This method only works for Sandboxes configured with a readiness probe.
     *
     * @param timeoutMs - Maximum total time to wait, in milliseconds.
     * @returns A promise that resolves once the Sandbox is ready.
     * @throws {@link TimeoutError} If readiness is not reported before `timeoutMs`.
     */
    waitUntilReady(timeoutMs?: number): Promise<void>;
    /** Get {@link Tunnel} metadata for the Sandbox.
     *
     * Raises {@link SandboxTimeoutError} if the tunnels are not available after the timeout.
     *
     * @returns A dictionary of {@link Tunnel} objects which are keyed by the container port.
     */
    tunnels(timeoutMs?: number): Promise<Record<number, Tunnel>>;
    /**
     * Snapshot the filesystem of the Sandbox.
     *
     * Returns an {@link Image} object which can be used to spawn a new Sandbox with the same filesystem.
     *
     * The call has an overall `timeoutMs` budget (default: 55000). If it
     * elapses before a snapshot completes, the call is cancelled and an
     * error is thrown.
     *
     * @param params - Optional parameters; see {@link SandboxSnapshotFilesystemParams}.
     * @returns Promise that resolves to an {@link Image}
     */
    snapshotFilesystem(params?: SandboxSnapshotFilesystemParams): Promise<Image>;
    /**
     * Mount an {@link Image} at a path in the Sandbox filesystem.
     *
     * @param path - The path where the directory should be mounted
     * @param image - Optional {@link Image} to mount. If undefined, mounts an empty directory.
     */
    mountImage(path: string, image?: Image): Promise<void>;
    /**
     * Unmounts an {@link Image} previously mounted at a path in the Sandbox filesystem.
     *
     * @param path - The mount path to unmount
     */
    unmountImage(path: string): Promise<void>;
    /**
     * Snapshots and creates a new {@link Image} from a directory in the running sandbox.
     *
     * The resulting Image is retained for `ttlMs` (default: 30 days),
     * as a hard cutoff measured from creation — usage does not extend
     * the lifetime. Pass `ttlMs: null` to retain indefinitely.
     *
     * The call has an overall `timeoutMs` budget (default: 55000). If it
     * elapses before a snapshot completes, the call is cancelled and an
     * error is thrown.
     *
     * @param path - The path of the directory to snapshot
     * @param params - Optional parameters; see {@link SandboxSnapshotDirectoryParams}.
     * @returns Promise that resolves to an {@link Image}
     */
    snapshotDirectory(path: string, params?: SandboxSnapshotDirectoryParams): Promise<Image>;
    /**
     * Check if the Sandbox has finished running.
     *
     * Returns `null` if the Sandbox is still running, else returns the exit code.
     */
    poll(): Promise<number | null>;
}
declare class ContainerProcess<R extends string | Uint8Array = any> {
    #private;
    stdin: ModalWriteStream<R>;
    stdout: ModalReadStream<R>;
    stderr: ModalReadStream<R>;
    /** @ignore */
    constructor(taskId: string, execId: string, commandRouterClient: TaskCommandRouterClientImpl, params?: SandboxExecParams, deadline?: number | null);
    /**
     * @ignore
     * Send stdin EOF directly, bypassing the WritableStream state machine.
     *
     * Useful for when an stdin write has failed.
     */
    closeStdin(): Promise<void>;
    /** Wait for process completion and return the exit code. */
    wait(): Promise<number>;
}

interface ModalClientParams {
    tokenId?: string;
    tokenSecret?: string;
    environment?: string;
    endpoint?: string;
    timeoutMs?: number;
    maxRetries?: number;
    maxThrottleWaitSecs?: number;
    logger?: Logger;
    logLevel?: LogLevel;
    /**
     * Custom gRPC middleware to be applied to all API calls.
     * These middleware are appended after Modal's built-in middleware
     * (authentication, retry logic, and timeouts), allowing you to add
     * telemetry, tracing, or other observability features.
     *
     * Note that the Modal gRPC API is not considered a public API, and
     * can change without warning.
     */
    grpcMiddleware?: ClientMiddleware[];
    /** @ignore */
    cpClient?: ModalGrpcClient;
}
type ModalGrpcClient = Client<typeof ModalClientDefinition, TimeoutOptions & RetryOptions>;
/**
 * The main client for interacting with Modal's cloud infrastructure.
 *
 * ModalClient provides access to all Modal services through service properties.
 * Create a client instance and use its service properties to manage {@link App}s,
 * {@link Function_ Function}s, * {@link Sandbox}es, and other Modal resources.
 *
 * @example
 * ```typescript
 * import { ModalClient } from "modal";
 *
 * const modal = new ModalClient();
 *
 * const app = await modal.apps.fromName("my-app");
 * const image = modal.images.fromRegistry("python:3.13");
 * const sb = await modal.sandboxes.create(app, image);
 * ```
 */
declare class ModalClient {
    readonly apps: AppService;
    readonly cloudBucketMounts: CloudBucketMountService;
    readonly cls: ClsService;
    readonly functions: FunctionService;
    readonly functionCalls: FunctionCallService;
    readonly images: ImageService;
    readonly proxies: ProxyService;
    readonly queues: QueueService;
    readonly sandboxes: SandboxService;
    readonly secrets: SecretService;
    readonly volumes: VolumeService;
    /** @ignore */
    readonly cpClient: ModalGrpcClient;
    readonly profile: Profile;
    readonly logger: Logger;
    private ipClients;
    private authTokenManager;
    private customMiddleware;
    private environmentManager;
    constructor(params?: ModalClientParams);
    environmentName(environment?: string): string;
    /**
     * Returns the image builder version by querying the server where the local profile takes
     * precedence.
     *
     * The image builder version is an environment-scoped server setting, so pass the environment
     * the image will be built in (e.g. an App's environment) to fetch the correct version. When
     * omitted, the profile's default environment is used.
     */
    getImageBuilderVersion(environmentName?: string): Promise<string>;
    /** @ignore */
    ipClient(serverUrl: string): ModalGrpcClient;
    close(): void;
    version(): string;
    private createClient;
    /** Middleware to retry transient errors and timeouts for unary requests. */
    private retryMiddleware;
    private authMiddleware;
}
type TimeoutOptions = {
    /** Timeout for this call, interpreted as a duration in milliseconds */
    timeoutMs?: number;
};
type RetryOptions = {
    /** Number of retries to take. */
    retries?: number;
    /** Base delay in milliseconds. */
    baseDelay?: number;
    /** Maximum delay in milliseconds. */
    maxDelay?: number;
    /** Exponential factor to multiply successive delays. */
    delayFactor?: number;
    /** Additional status codes to retry. */
    additionalStatusCodes?: Status[];
};

/**
 * Service for managing {@link App}s.
 *
 * Normally only ever accessed via the client as:
 * ```typescript
 * const modal = new ModalClient();
 * const app = await modal.apps.fromName("my-app");
 * ```
 */
declare class AppService {
    #private;
    constructor(client: ModalClient);
    /**
     * Reference a deployed {@link App} by name, or create if it does not exist.
     */
    fromName(name: string, params?: AppFromNameParams): Promise<App>;
}
/** Optional parameters for {@link AppService#fromName client.apps.fromName()}. */
type AppFromNameParams = {
    environment?: string;
    createIfMissing?: boolean;
};
/** Represents a deployed Modal App. */
declare class App {
    readonly appId: string;
    readonly name?: string;
    readonly environmentName?: string;
    /** @ignore */
    constructor(appId: string, name?: string, environmentName?: string);
}

/** An operation exceeds the allowed time limit. */
declare class TimeoutError extends Error {
    constructor(message?: string);
}
/** Function execution exceeds the allowed time limit. */
declare class FunctionTimeoutError extends Error {
    constructor(message: string);
}
/** An error on the Modal server, or a Python exception. */
declare class RemoteError extends Error {
    constructor(message: string);
}
/** A retryable internal error from Modal. */
declare class InternalFailure extends Error {
    constructor(message: string);
}
/** Some resource was not found. */
declare class NotFoundError extends Error {
    constructor(message: string);
}
/** A resource already exists. */
declare class AlreadyExistsError extends Error {
    constructor(message: string);
}
/** A request or other operation was invalid. */
declare class InvalidError extends Error {
    constructor(message: string);
}
/** The Queue is empty. */
declare class QueueEmptyError extends Error {
    constructor(message: string);
}
/** The Queue is full. */
declare class QueueFullError extends Error {
    constructor(message: string);
}
/** Errors from invalid Sandbox FileSystem operations. */
declare class SandboxFilesystemError extends Error {
    constructor(message: string);
}
/** A directory was expected to be empty but is not. */
declare class SandboxFilesystemDirectoryNotEmptyError extends SandboxFilesystemError {
    constructor(message: string);
}
/** A file exceeds the maximum allowed size for a read operation. */
declare class SandboxFilesystemFileTooLargeError extends SandboxFilesystemError {
    constructor(message: string);
}
/** A file operation was attempted on a path that resolves to a directory. */
declare class SandboxFilesystemIsADirectoryError extends SandboxFilesystemError {
    constructor(message: string);
}
/** A directory operation encountered a path component that is not a directory. */
declare class SandboxFilesystemNotADirectoryError extends SandboxFilesystemError {
    constructor(message: string);
}
/** A file or directory is not found. */
declare class SandboxFilesystemNotFoundError extends SandboxFilesystemError {
    constructor(message: string);
}
/** A path already exists and the operation requires it to be absent. */
declare class SandboxFilesystemPathAlreadyExistsError extends SandboxFilesystemError {
    constructor(message: string);
}
/** Permission is denied for a file operation. */
declare class SandboxFilesystemPermissionError extends SandboxFilesystemError {
    constructor(message: string);
}
/** Sandbox operations that exceed the allowed time limit. */
declare class SandboxTimeoutError extends Error {
    constructor(message?: string);
}
/** Thrown when attempting operations on a detached Sandbox. */
declare class ClientClosedError extends Error {
    constructor(message?: string);
}

declare function checkForRenamedParams(params: any, renames: Record<string, string>): void;

export { AlreadyExistsError, App, type AppFromNameParams, AppService, ClientClosedError, CloudBucketMount, CloudBucketMountService, Cls, type ClsFromNameParams, ClsInstance, ClsService, type ClsWithBatchingParams, type ClsWithConcurrencyParams, type ClsWithOptionsParams, ContainerProcess, type FileInfo, type FileType, FunctionCall, type FunctionCallCancelParams, type FunctionCallGetParams, FunctionCallService, type FunctionFromNameParams, FunctionService, type FunctionStats, FunctionTimeoutError, type FunctionUpdateAutoscalerParams, type FunctionWithBatchingParams, type FunctionWithConcurrencyParams, type FunctionWithOptionsParams, Function_, Image, type ImageDeleteParams, type ImageDockerfileCommandsParams, type ImageFromNameParams, type ImagePublishParams, ImageService, InternalFailure, InvalidError, type LogLevel, type Logger, ModalClient, type ModalClientParams, type ModalReadStream, type ModalWriteStream, NotFoundError, Probe, type ProbeParams, type Profile, Proxy, type ProxyFromNameParams, ProxyService, Queue, type QueueClearParams, type QueueDeleteParams, QueueEmptyError, type QueueEphemeralParams, type QueueFromNameParams, QueueFullError, type QueueGetParams, type QueueIterateParams, type QueueLenParams, type QueuePutParams, QueueService, RemoteError, Retries, Sandbox, type SandboxCreateConnectCredentials, type SandboxCreateConnectTokenParams, type SandboxCreateParams, type SandboxExecParams, SandboxFilesystem, SandboxFilesystemDirectoryNotEmptyError, SandboxFilesystemError, SandboxFilesystemFileTooLargeError, SandboxFilesystemIsADirectoryError, SandboxFilesystemNotADirectoryError, SandboxFilesystemNotFoundError, SandboxFilesystemPathAlreadyExistsError, SandboxFilesystemPermissionError, type SandboxFromNameParams, type SandboxListParams, SandboxService, type SandboxSnapshotDirectoryParams, type SandboxSnapshotFilesystemParams, type SandboxTerminateParams, SandboxTimeoutError, Secret, type SecretDeleteParams, type SecretFromNameParams, type SecretFromObjectParams, SecretService, SidecarContainer, type SidecarCreateParams, type SidecarExecParams, type SidecarGetParams, type SidecarListParams, SidecarService, type SidecarTerminateParams, type StdioBehavior, type StreamMode, TimeoutError, Tunnel, Volume, type VolumeDeleteParams, type VolumeEphemeralParams, type VolumeFromNameParams, type VolumeMountOptions, VolumeService, checkForRenamedParams };