@databricks/sdk-jobs 0.1.0-dev.3 → 0.1.0-dev.4

package/dist/v2/model.d.ts

@@ -1,39 +1,42 @@
 import { z } from 'zod';
-export declare enum AuthenticationMethod {
-    OAUTH = "OAUTH",
-    PAT = "PAT"
-}
+export declare const AuthenticationMethod: {
+    readonly OAUTH: "OAUTH";
+    readonly PAT: "PAT";
+};
+export type AuthenticationMethod = (typeof AuthenticationMethod)[keyof typeof AuthenticationMethod] | (string & {});
 /**
  * Availability type used for all subsequent nodes past the `first_on_demand` ones.
  *
  * Note: If `first_on_demand` is zero, this availability type will be used for the entire cluster.
  */
-export declare enum AwsAvailability {
+export declare const AwsAvailability: {
     /** Use spot instances. */
-    SPOT = "SPOT",
+    readonly SPOT: "SPOT";
     /** Use on-demand instances. */
-    ON_DEMAND = "ON_DEMAND",
+    readonly ON_DEMAND: "ON_DEMAND";
     /**
      * Preferably use spot instances, but fall back to on-demand instances if spot instances cannot
      * be acquired (e.g., if AWS spot prices are too high).
      */
-    SPOT_WITH_FALLBACK = "SPOT_WITH_FALLBACK"
-}
+    readonly SPOT_WITH_FALLBACK: "SPOT_WITH_FALLBACK";
+};
+export type AwsAvailability = (typeof AwsAvailability)[keyof typeof AwsAvailability] | (string & {});
 /**
  * Availability type used for all subsequent nodes past the `first_on_demand` ones.
  * Note: If `first_on_demand` is zero, this availability type will be used for the entire cluster.
  */
-export declare enum AzureAvailability {
+export declare const AzureAvailability: {
     /** Use spot instances. */
-    SPOT_AZURE = "SPOT_AZURE",
+    readonly SPOT_AZURE: "SPOT_AZURE";
     /** Use on-demand instances. */
-    ON_DEMAND_AZURE = "ON_DEMAND_AZURE",
+    readonly ON_DEMAND_AZURE: "ON_DEMAND_AZURE";
     /**
      * Preferably use spot instances, but fall back to on-demand instances if spot instances cannot
      * be acquired (e.g., if Azure is out of Quota).
      */
-    SPOT_WITH_FALLBACK_AZURE = "SPOT_WITH_FALLBACK_AZURE"
-}
+    readonly SPOT_WITH_FALLBACK_AZURE: "SPOT_WITH_FALLBACK_AZURE";
+};
+export type AzureAvailability = (typeof AzureAvailability)[keyof typeof AzureAvailability] | (string & {});
 /**
  * The kind of compute described by this compute specification.
  *
@@ -45,21 +48,23 @@ export declare enum AzureAvailability {
  *
  * By using the [simple form](https://docs.databricks.com/compute/simple-form.html), your clusters are automatically using `kind = CLASSIC_PREVIEW`.
  */
-export declare enum ComputeKind {
-    COMPUTE_KIND_UNSPECIFIED = "COMPUTE_KIND_UNSPECIFIED",
-    CLASSIC_PREVIEW = "CLASSIC_PREVIEW"
-}
+export declare const ComputeKind: {
+    readonly COMPUTE_KIND_UNSPECIFIED: "COMPUTE_KIND_UNSPECIFIED";
+    readonly CLASSIC_PREVIEW: "CLASSIC_PREVIEW";
+};
+export type ComputeKind = (typeof ComputeKind)[keyof typeof ComputeKind] | (string & {});
 /**
  * Confidential computing technology for GCP instances.
  * Aligns with gcloud's --confidential-compute-type flag and the REST API's
  * confidentialInstanceConfig.confidentialInstanceType field.
  * See: https://cloud.google.com/confidential-computing/confidential-vm/docs/create-a-confidential-vm-instance
  */
-export declare enum ConfidentialComputeType {
-    CONFIDENTIAL_COMPUTE_TYPE_UNSPECIFIED = "CONFIDENTIAL_COMPUTE_TYPE_UNSPECIFIED",
-    CONFIDENTIAL_COMPUTE_TYPE_NONE = "CONFIDENTIAL_COMPUTE_TYPE_NONE",
-    SEV_SNP = "SEV_SNP"
-}
+export declare const ConfidentialComputeType: {
+    readonly CONFIDENTIAL_COMPUTE_TYPE_UNSPECIFIED: "CONFIDENTIAL_COMPUTE_TYPE_UNSPECIFIED";
+    readonly CONFIDENTIAL_COMPUTE_TYPE_NONE: "CONFIDENTIAL_COMPUTE_TYPE_NONE";
+    readonly SEV_SNP: "SEV_SNP";
+};
+export type ConfidentialComputeType = (typeof ConfidentialComputeType)[keyof typeof ConfidentialComputeType] | (string & {});
 /**
  * Data security mode decides what data governance model to use when accessing data
  * from a cluster.
@@ -81,96 +86,103 @@ export declare enum ConfidentialComputeType {
  * * `LEGACY_SINGLE_USER`: This mode is for users migrating from legacy Passthrough on standard clusters.
  * * `LEGACY_SINGLE_USER_STANDARD`: This mode provides a way that doesn’t have UC nor passthrough enabled.
  */
-export declare enum DataSecurityMode {
+export declare const DataSecurityMode: {
     /**
      * No security isolation for multiple users sharing the cluster. Data governance features
      * are not available in this mode.
      */
-    NONE = "NONE",
+    readonly NONE: "NONE";
     /** Legacy alias for `DATA_SECURITY_MODE_DEDICATED`. */
-    SINGLE_USER = "SINGLE_USER",
+    readonly SINGLE_USER: "SINGLE_USER";
     /** Legacy alias for `DATA_SECURITY_MODE_STANDARD`. */
-    USER_ISOLATION = "USER_ISOLATION",
+    readonly USER_ISOLATION: "USER_ISOLATION";
     /** This mode is for users migrating from legacy Table ACL clusters. */
-    LEGACY_TABLE_ACL = "LEGACY_TABLE_ACL",
+    readonly LEGACY_TABLE_ACL: "LEGACY_TABLE_ACL";
     /** This mode is for users migrating from legacy Passthrough on high concurrency clusters. */
-    LEGACY_PASSTHROUGH = "LEGACY_PASSTHROUGH",
+    readonly LEGACY_PASSTHROUGH: "LEGACY_PASSTHROUGH";
     /** This mode is for users migrating from legacy Passthrough on standard clusters. */
-    LEGACY_SINGLE_USER = "LEGACY_SINGLE_USER",
+    readonly LEGACY_SINGLE_USER: "LEGACY_SINGLE_USER";
     /** This is mode where single user is enforced but no actual security feature enabled. */
-    LEGACY_SINGLE_USER_STANDARD = "LEGACY_SINGLE_USER_STANDARD",
+    readonly LEGACY_SINGLE_USER_STANDARD: "LEGACY_SINGLE_USER_STANDARD";
     /**
      * A secure cluster that can be shared by multiple users. Cluster users are fully isolated
      * so that they cannot see each other's data and credentials. Most data governance features
      * are supported in this mode. But programming languages and cluster features might be limited.
      */
-    DATA_SECURITY_MODE_STANDARD = "DATA_SECURITY_MODE_STANDARD",
+    readonly DATA_SECURITY_MODE_STANDARD: "DATA_SECURITY_MODE_STANDARD";
     /**
      * A secure cluster that can only be exclusively used by a single user specified in
      * `single_user_name`. Most programming languages, cluster features and data governance
      * features are available in this mode.
      */
-    DATA_SECURITY_MODE_DEDICATED = "DATA_SECURITY_MODE_DEDICATED",
+    readonly DATA_SECURITY_MODE_DEDICATED: "DATA_SECURITY_MODE_DEDICATED";
     /**
      * Databricks will choose `DATA_SECURITY_MODE_STANDARD` or `DATA_SECURITY_MODE_DEDICATED`
      * depending on the compute configuration.
      */
-    DATA_SECURITY_MODE_AUTO = "DATA_SECURITY_MODE_AUTO"
-}
+    readonly DATA_SECURITY_MODE_AUTO: "DATA_SECURITY_MODE_AUTO";
+};
+export type DataSecurityMode = (typeof DataSecurityMode)[keyof typeof DataSecurityMode] | (string & {});
 /** Response enumeration from calling the dbt platform API, for inclusion in output */
-export declare enum DbtPlatformRunStatus {
-    DBT_PLATFORM_RUN_STATUS_UNSPECIFIED = "DBT_PLATFORM_RUN_STATUS_UNSPECIFIED",
-    QUEUED = "QUEUED",
-    STARTING = "STARTING",
-    RUNNING = "RUNNING",
-    SUCCESS = "SUCCESS",
-    ERROR = "ERROR",
-    CANCELLED = "CANCELLED"
-}
+export declare const DbtPlatformRunStatus: {
+    readonly DBT_PLATFORM_RUN_STATUS_UNSPECIFIED: "DBT_PLATFORM_RUN_STATUS_UNSPECIFIED";
+    readonly QUEUED: "QUEUED";
+    readonly STARTING: "STARTING";
+    readonly RUNNING: "RUNNING";
+    readonly SUCCESS: "SUCCESS";
+    readonly ERROR: "ERROR";
+    readonly CANCELLED: "CANCELLED";
+};
+export type DbtPlatformRunStatus = (typeof DbtPlatformRunStatus)[keyof typeof DbtPlatformRunStatus] | (string & {});
 /**
  * All EBS volume types that <Databricks> supports.
  * See https://aws.amazon.com/ebs/details/ for details.
  */
-export declare enum EbsVolumeType {
+export declare const EbsVolumeType: {
     /** Provision extra storage using AWS gp2 EBS volumes. */
-    GENERAL_PURPOSE_SSD = "GENERAL_PURPOSE_SSD",
+    readonly GENERAL_PURPOSE_SSD: "GENERAL_PURPOSE_SSD";
     /** Provision extra storage using AWS st1 volumes. */
-    THROUGHPUT_OPTIMIZED_HDD = "THROUGHPUT_OPTIMIZED_HDD"
-}
-export declare enum Format {
-    SINGLE_TASK = "SINGLE_TASK",
-    MULTI_TASK = "MULTI_TASK"
-}
+    readonly THROUGHPUT_OPTIMIZED_HDD: "THROUGHPUT_OPTIMIZED_HDD";
+};
+export type EbsVolumeType = (typeof EbsVolumeType)[keyof typeof EbsVolumeType] | (string & {});
+export declare const Format: {
+    readonly SINGLE_TASK: "SINGLE_TASK";
+    readonly MULTI_TASK: "MULTI_TASK";
+};
+export type Format = (typeof Format)[keyof typeof Format] | (string & {});
 /**
  * This field determines whether the instance pool will contain preemptible
  * VMs, on-demand VMs, or preemptible VMs with a fallback to on-demand VMs if the former is unavailable.
  */
-export declare enum GcpAvailability {
-    PREEMPTIBLE_GCP = "PREEMPTIBLE_GCP",
-    ON_DEMAND_GCP = "ON_DEMAND_GCP",
-    PREEMPTIBLE_WITH_FALLBACK_GCP = "PREEMPTIBLE_WITH_FALLBACK_GCP"
-}
+export declare const GcpAvailability: {
+    readonly PREEMPTIBLE_GCP: "PREEMPTIBLE_GCP";
+    readonly ON_DEMAND_GCP: "ON_DEMAND_GCP";
+    readonly PREEMPTIBLE_WITH_FALLBACK_GCP: "PREEMPTIBLE_WITH_FALLBACK_GCP";
+};
+export type GcpAvailability = (typeof GcpAvailability)[keyof typeof GcpAvailability] | (string & {});
 /**
  * HardwareAcceleratorType: The type of hardware accelerator to use for compute workloads.
  * NOTE: This enum is referenced and is intended to be used by other <Databricks> services
  * that need to specify hardware accelerator requirements for AI compute workloads.
  */
-export declare enum HardwareAcceleratorType {
+export declare const HardwareAcceleratorType: {
     /** GPU_1xA10: Single A10 GPU configuration. */
-    GPU_1X_A10 = "GPU_1xA10",
+    readonly GPU_1X_A10: "GPU_1xA10";
     /** GPU_8xH100: 8x H100 GPU configuration. */
-    GPU_8X_H100 = "GPU_8xH100"
-}
+    readonly GPU_8X_H100: "GPU_8xH100";
+};
+export type HardwareAcceleratorType = (typeof HardwareAcceleratorType)[keyof typeof HardwareAcceleratorType] | (string & {});
 /**
  * Edit mode of the job.
  *
  * * `UI_LOCKED`: The job is in a locked UI state and cannot be modified.
  * * `EDITABLE`: The job is in an editable state and can be modified.
  */
-export declare enum JobEditMode {
-    UI_LOCKED = "UI_LOCKED",
-    EDITABLE = "EDITABLE"
-}
+export declare const JobEditMode: {
+    readonly UI_LOCKED: "UI_LOCKED";
+    readonly EDITABLE: "EDITABLE";
+};
+export type JobEditMode = (typeof JobEditMode)[keyof typeof JobEditMode] | (string & {});
 /**
  * Specifies the health metric that is being evaluated for a particular health rule.
  *
@@ -180,51 +192,57 @@ export declare enum JobEditMode {
  * * `STREAMING_BACKLOG_SECONDS`: An estimate of the maximum consumer delay across all streams. This metric is in Public Preview.
  * * `STREAMING_BACKLOG_FILES`: An estimate of the maximum number of outstanding files across all streams. This metric is in Public Preview.
  */
-export declare enum JobsHealthMetric {
-    RUN_DURATION_SECONDS = "RUN_DURATION_SECONDS",
-    STREAMING_BACKLOG_BYTES = "STREAMING_BACKLOG_BYTES",
-    STREAMING_BACKLOG_RECORDS = "STREAMING_BACKLOG_RECORDS",
-    STREAMING_BACKLOG_SECONDS = "STREAMING_BACKLOG_SECONDS",
-    STREAMING_BACKLOG_FILES = "STREAMING_BACKLOG_FILES"
-}
+export declare const JobsHealthMetric: {
+    readonly RUN_DURATION_SECONDS: "RUN_DURATION_SECONDS";
+    readonly STREAMING_BACKLOG_BYTES: "STREAMING_BACKLOG_BYTES";
+    readonly STREAMING_BACKLOG_RECORDS: "STREAMING_BACKLOG_RECORDS";
+    readonly STREAMING_BACKLOG_SECONDS: "STREAMING_BACKLOG_SECONDS";
+    readonly STREAMING_BACKLOG_FILES: "STREAMING_BACKLOG_FILES";
+};
+export type JobsHealthMetric = (typeof JobsHealthMetric)[keyof typeof JobsHealthMetric] | (string & {});
 /** Specifies the operator used to compare the health metric value with the specified threshold. */
-export declare enum JobsHealthOperator {
-    GREATER_THAN = "GREATER_THAN"
-}
+export declare const JobsHealthOperator: {
+    readonly GREATER_THAN: "GREATER_THAN";
+};
+export type JobsHealthOperator = (typeof JobsHealthOperator)[keyof typeof JobsHealthOperator] | (string & {});
 /**
  * The repair history item type. Indicates whether a run is the original run or
  * a repair run.
  */
-export declare enum RepairType {
-    ORIGINAL = "ORIGINAL",
-    REPAIR = "REPAIR"
-}
+export declare const RepairType: {
+    readonly ORIGINAL: "ORIGINAL";
+    readonly REPAIR: "REPAIR";
+};
+export type RepairType = (typeof RepairType)[keyof typeof RepairType] | (string & {});
 /**
  * The type of a run.
  * * `JOB_RUN`: Normal job run. A run created with :method:jobs/runNow.
  * * `WORKFLOW_RUN`: Workflow run. A run created with [dbutils.notebook.run](/dev-tools/databricks-utils.html#dbutils-workflow).
  * * `SUBMIT_RUN`: Submit run. A run created with :method:jobs/submit.
  */
-export declare enum RunType {
-    JOB_RUN = "JOB_RUN",
-    WORKFLOW_RUN = "WORKFLOW_RUN",
-    SUBMIT_RUN = "SUBMIT_RUN"
-}
-export declare enum RuntimeEngine {
+export declare const RunType: {
+    readonly JOB_RUN: "JOB_RUN";
+    readonly WORKFLOW_RUN: "WORKFLOW_RUN";
+    readonly SUBMIT_RUN: "SUBMIT_RUN";
+};
+export type RunType = (typeof RunType)[keyof typeof RunType] | (string & {});
+export declare const RuntimeEngine: {
     /**
      * Default value. In this case, ignore the RUNTIME_ENGINE
      * parameter and do a spark version lookup entirely on the sparkVersion string.
      */
-    NULL = "NULL",
+    readonly NULL: "NULL";
     /** Use standard engine */
-    STANDARD = "STANDARD",
+    readonly STANDARD: "STANDARD";
     /** Use Photon engine */
-    PHOTON = "PHOTON"
-}
-export declare enum SchedulePauseStatus {
-    UNPAUSED = "UNPAUSED",
-    PAUSED = "PAUSED"
-}
+    readonly PHOTON: "PHOTON";
+};
+export type RuntimeEngine = (typeof RuntimeEngine)[keyof typeof RuntimeEngine] | (string & {});
+export declare const SchedulePauseStatus: {
+    readonly UNPAUSED: "UNPAUSED";
+    readonly PAUSED: "PAUSED";
+};
+export type SchedulePauseStatus = (typeof SchedulePauseStatus)[keyof typeof SchedulePauseStatus] | (string & {});
 /**
  * Optional location type of the SQL file. When set to `WORKSPACE`, the SQL file will be retrieved\
  * from the local <Databricks> workspace. When set to `GIT`, the SQL file will be retrieved from a Git repository
@@ -233,15 +251,17 @@ export declare enum SchedulePauseStatus {
  * * `WORKSPACE`: SQL file is located in <Databricks> workspace.
  * * `GIT`: SQL file is located in cloud Git provider.
  */
-export declare enum Source {
-    WORKSPACE = "WORKSPACE",
-    GIT = "GIT"
-}
-export declare enum StorageMode {
-    DIRECT_QUERY = "DIRECT_QUERY",
-    IMPORT = "IMPORT",
-    DUAL = "DUAL"
-}
+export declare const Source: {
+    readonly WORKSPACE: "WORKSPACE";
+    readonly GIT: "GIT";
+};
+export type Source = (typeof Source)[keyof typeof Source] | (string & {});
+export declare const StorageMode: {
+    readonly DIRECT_QUERY: "DIRECT_QUERY";
+    readonly IMPORT: "IMPORT";
+    readonly DUAL: "DUAL";
+};
+export type StorageMode = (typeof StorageMode)[keyof typeof StorageMode] | (string & {});
 /**
  * An optional value indicating the condition that determines whether the task should be run once its dependencies have been completed. When omitted, defaults to `ALL_SUCCESS`.
  *
@@ -253,24 +273,26 @@ export declare enum StorageMode {
  * * `AT_LEAST_ONE_FAILED`: At least one dependency failed
  * * `ALL_FAILED`: ALl dependencies have failed
  */
-export declare enum TaskDependencyType {
-    ALL_SUCCESS = "ALL_SUCCESS",
-    ALL_DONE = "ALL_DONE",
-    NONE_FAILED = "NONE_FAILED",
-    AT_LEAST_ONE_SUCCESS = "AT_LEAST_ONE_SUCCESS",
-    ALL_FAILED = "ALL_FAILED",
-    AT_LEAST_ONE_FAILED = "AT_LEAST_ONE_FAILED"
-}
+export declare const TaskDependencyType: {
+    readonly ALL_SUCCESS: "ALL_SUCCESS";
+    readonly ALL_DONE: "ALL_DONE";
+    readonly NONE_FAILED: "NONE_FAILED";
+    readonly AT_LEAST_ONE_SUCCESS: "AT_LEAST_ONE_SUCCESS";
+    readonly ALL_FAILED: "ALL_FAILED";
+    readonly AT_LEAST_ONE_FAILED: "AT_LEAST_ONE_FAILED";
+};
+export type TaskDependencyType = (typeof TaskDependencyType)[keyof typeof TaskDependencyType] | (string & {});
 /**
  * task retry mode of the continuous job
  * * NEVER: The failed task will not be retried.
  * * ON_FAILURE: Retry a failed task if at least one other task in the job is still running its first attempt.
  * When this condition is no longer met or the retry limit is reached, the job run is cancelled and a new run is started.
  */
-export declare enum TaskRetryMode {
-    NEVER = "NEVER",
-    ON_FAILURE = "ON_FAILURE"
-}
+export declare const TaskRetryMode: {
+    readonly NEVER: "NEVER";
+    readonly ON_FAILURE: "ON_FAILURE";
+};
+export type TaskRetryMode = (typeof TaskRetryMode)[keyof typeof TaskRetryMode] | (string & {});
 /**
  * The type of trigger that fired this run.
  *
@@ -284,106 +306,115 @@ export declare enum TaskRetryMode {
  * * `CONTINUOUS_RESTART`: Indicates a run created by user to manually restart a continuous job run.
  * * `MODEL`: Indicates a run that is triggered by a model update.
  */
-export declare enum TriggerType {
-    PERIODIC = "PERIODIC",
-    ONE_TIME = "ONE_TIME",
-    RETRY = "RETRY",
-    RUN_JOB_TASK = "RUN_JOB_TASK",
-    FILE_ARRIVAL = "FILE_ARRIVAL",
-    CONTINUOUS = "CONTINUOUS",
-    TABLE = "TABLE",
-    CONTINUOUS_RESTART = "CONTINUOUS_RESTART"
-}
+export declare const TriggerType: {
+    readonly PERIODIC: "PERIODIC";
+    readonly ONE_TIME: "ONE_TIME";
+    readonly RETRY: "RETRY";
+    readonly RUN_JOB_TASK: "RUN_JOB_TASK";
+    readonly FILE_ARRIVAL: "FILE_ARRIVAL";
+    readonly CONTINUOUS: "CONTINUOUS";
+    readonly TABLE: "TABLE";
+    readonly CONTINUOUS_RESTART: "CONTINUOUS_RESTART";
+};
+export type TriggerType = (typeof TriggerType)[keyof typeof TriggerType] | (string & {});
 /**
  * * `NOTEBOOK`: Notebook view item.
  * * `DASHBOARD`: Dashboard view item.
  */
-export declare enum ViewType {
-    NOTEBOOK = "NOTEBOOK",
-    DASHBOARD = "DASHBOARD"
-}
+export declare const ViewType: {
+    readonly NOTEBOOK: "NOTEBOOK";
+    readonly DASHBOARD: "DASHBOARD";
+};
+export type ViewType = (typeof ViewType)[keyof typeof ViewType] | (string & {});
 /**
  * * `CODE`: Code view of the notebook.
  * * `DASHBOARDS`: All dashboard views of the notebook.
  * * `ALL`: All views of the notebook.
  */
-export declare enum ViewsToExport {
-    CODE = "CODE",
-    DASHBOARDS = "DASHBOARDS",
-    ALL = "ALL"
-}
-export declare enum AccessControlRequest_JobPermission {
-    CAN_VIEW = "CAN_VIEW",
-    CAN_MANAGE_RUN = "CAN_MANAGE_RUN",
-    IS_OWNER = "IS_OWNER",
-    CAN_MANAGE = "CAN_MANAGE"
-}
+export declare const ViewsToExport: {
+    readonly CODE: "CODE";
+    readonly DASHBOARDS: "DASHBOARDS";
+    readonly ALL: "ALL";
+};
+export type ViewsToExport = (typeof ViewsToExport)[keyof typeof ViewsToExport] | (string & {});
+export declare const AccessControlRequest_JobPermission: {
+    readonly CAN_VIEW: "CAN_VIEW";
+    readonly CAN_MANAGE_RUN: "CAN_MANAGE_RUN";
+    readonly IS_OWNER: "IS_OWNER";
+    readonly CAN_MANAGE: "CAN_MANAGE";
+};
+export type AccessControlRequest_JobPermission = (typeof AccessControlRequest_JobPermission)[keyof typeof AccessControlRequest_JobPermission] | (string & {});
 /** Same alert evaluation state as in redash-v2/api/proto/alertsv2/alerts.proto */
-export declare enum AlertEvaluationState_AlertEvaluationState {
-    ALERT_EVALUATION_STATE_UNSPECIFIED = "ALERT_EVALUATION_STATE_UNSPECIFIED",
-    UNKNOWN = "UNKNOWN",
-    TRIGGERED = "TRIGGERED",
-    OK = "OK",
-    ERROR = "ERROR"
-}
+export declare const AlertEvaluationState_AlertEvaluationState: {
+    readonly ALERT_EVALUATION_STATE_UNSPECIFIED: "ALERT_EVALUATION_STATE_UNSPECIFIED";
+    readonly UNKNOWN: "UNKNOWN";
+    readonly TRIGGERED: "TRIGGERED";
+    readonly OK: "OK";
+    readonly ERROR: "ERROR";
+};
+export type AlertEvaluationState_AlertEvaluationState = (typeof AlertEvaluationState_AlertEvaluationState)[keyof typeof AlertEvaluationState_AlertEvaluationState] | (string & {});
 /**
  * Copied from elastic-spark-common/api/messages/runs.proto.
  * Using the original definition to remove coupling with jobs API definition
  */
-export declare enum CleanRoomTaskRunLifeCycleState_CleanRoomTaskRunLifeCycleState {
-    RUN_LIFE_CYCLE_STATE_UNSPECIFIED = "RUN_LIFE_CYCLE_STATE_UNSPECIFIED",
-    PENDING = "PENDING",
-    RUNNING = "RUNNING",
-    TERMINATING = "TERMINATING",
-    TERMINATED = "TERMINATED",
-    SKIPPED = "SKIPPED",
-    INTERNAL_ERROR = "INTERNAL_ERROR",
-    BLOCKED = "BLOCKED",
-    WAITING_FOR_RETRY = "WAITING_FOR_RETRY",
-    QUEUED = "QUEUED"
-}
+export declare const CleanRoomTaskRunLifeCycleState_CleanRoomTaskRunLifeCycleState: {
+    readonly RUN_LIFE_CYCLE_STATE_UNSPECIFIED: "RUN_LIFE_CYCLE_STATE_UNSPECIFIED";
+    readonly PENDING: "PENDING";
+    readonly RUNNING: "RUNNING";
+    readonly TERMINATING: "TERMINATING";
+    readonly TERMINATED: "TERMINATED";
+    readonly SKIPPED: "SKIPPED";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    readonly BLOCKED: "BLOCKED";
+    readonly WAITING_FOR_RETRY: "WAITING_FOR_RETRY";
+    readonly QUEUED: "QUEUED";
+};
+export type CleanRoomTaskRunLifeCycleState_CleanRoomTaskRunLifeCycleState = (typeof CleanRoomTaskRunLifeCycleState_CleanRoomTaskRunLifeCycleState)[keyof typeof CleanRoomTaskRunLifeCycleState_CleanRoomTaskRunLifeCycleState] | (string & {});
 /**
  * Copied from elastic-spark-common/api/messages/runs.proto.
  * Using the original definition to avoid cyclic dependency.
  */
-export declare enum CleanRoomTaskRunResultState_CleanRoomTaskRunResultState {
-    RUN_RESULT_STATE_UNSPECIFIED = "RUN_RESULT_STATE_UNSPECIFIED",
-    SUCCESS = "SUCCESS",
-    FAILED = "FAILED",
-    TIMEDOUT = "TIMEDOUT",
-    CANCELED = "CANCELED",
-    MAXIMUM_CONCURRENT_RUNS_REACHED = "MAXIMUM_CONCURRENT_RUNS_REACHED",
-    UPSTREAM_CANCELED = "UPSTREAM_CANCELED",
-    UPSTREAM_FAILED = "UPSTREAM_FAILED",
-    EXCLUDED = "EXCLUDED",
-    EVICTED = "EVICTED",
-    SUCCESS_WITH_FAILURES = "SUCCESS_WITH_FAILURES",
-    UPSTREAM_EVICTED = "UPSTREAM_EVICTED",
+export declare const CleanRoomTaskRunResultState_CleanRoomTaskRunResultState: {
+    readonly RUN_RESULT_STATE_UNSPECIFIED: "RUN_RESULT_STATE_UNSPECIFIED";
+    readonly SUCCESS: "SUCCESS";
+    readonly FAILED: "FAILED";
+    readonly TIMEDOUT: "TIMEDOUT";
+    readonly CANCELED: "CANCELED";
+    readonly MAXIMUM_CONCURRENT_RUNS_REACHED: "MAXIMUM_CONCURRENT_RUNS_REACHED";
+    readonly UPSTREAM_CANCELED: "UPSTREAM_CANCELED";
+    readonly UPSTREAM_FAILED: "UPSTREAM_FAILED";
+    readonly EXCLUDED: "EXCLUDED";
+    readonly EVICTED: "EVICTED";
+    readonly SUCCESS_WITH_FAILURES: "SUCCESS_WITH_FAILURES";
+    readonly UPSTREAM_EVICTED: "UPSTREAM_EVICTED";
     /** 12 is reserved for previously used SUCCESS_WITH_SKIPPED_CELLS */
-    DISABLED = "DISABLED"
-}
+    readonly DISABLED: "DISABLED";
+};
+export type CleanRoomTaskRunResultState_CleanRoomTaskRunResultState = (typeof CleanRoomTaskRunResultState_CleanRoomTaskRunResultState)[keyof typeof CleanRoomTaskRunResultState_CleanRoomTaskRunResultState] | (string & {});
 /**
  * * `EQUAL_TO`, `NOT_EQUAL` operators perform string comparison of their operands. This means that `“12.0” == “12”` will evaluate to `false`.
  * * `GREATER_THAN`, `GREATER_THAN_OR_EQUAL`, `LESS_THAN`, `LESS_THAN_OR_EQUAL` operators perform numeric comparison of their operands. `“12.0” >= “12”` will evaluate to `true`, `“10.0” >= “12”` will evaluate to `false`.
  *
  * The boolean comparison to task values can be implemented with operators `EQUAL_TO`, `NOT_EQUAL`. If a task value was set to a boolean value, it will be serialized to `“true”` or `“false”` for the comparison.
  */
-export declare enum ConditionTask_ConditionTaskOperator {
-    EQUAL_TO = "EQUAL_TO",
-    GREATER_THAN = "GREATER_THAN",
-    GREATER_THAN_OR_EQUAL = "GREATER_THAN_OR_EQUAL",
-    LESS_THAN = "LESS_THAN",
-    LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL",
-    NOT_EQUAL = "NOT_EQUAL"
-}
+export declare const ConditionTask_ConditionTaskOperator: {
+    readonly EQUAL_TO: "EQUAL_TO";
+    readonly GREATER_THAN: "GREATER_THAN";
+    readonly GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+    readonly LESS_THAN: "LESS_THAN";
+    readonly LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+    readonly NOT_EQUAL: "NOT_EQUAL";
+};
+export type ConditionTask_ConditionTaskOperator = (typeof ConditionTask_ConditionTaskOperator)[keyof typeof ConditionTask_ConditionTaskOperator] | (string & {});
 /**
  * * `BUNDLE`: The job is managed by Databricks Asset Bundle.
  * * `SYSTEM_MANAGED`: The job is managed by <Databricks> and is read-only.
  */
-export declare enum JobDeployment_DeploymentKind {
-    BUNDLE = "BUNDLE",
-    SYSTEM_MANAGED = "SYSTEM_MANAGED"
-}
+export declare const JobDeployment_DeploymentKind: {
+    readonly BUNDLE: "BUNDLE";
+    readonly SYSTEM_MANAGED: "SYSTEM_MANAGED";
+};
+export type JobDeployment_DeploymentKind = (typeof JobDeployment_DeploymentKind)[keyof typeof JobDeployment_DeploymentKind] | (string & {});
 /**
  * Dirty state indicates the job is not fully synced with the job specification
  * in the remote repository.
@@ -392,43 +423,48 @@ export declare enum JobDeployment_DeploymentKind {
  * * `NOT_SYNCED`: The job is not yet synced with the remote job specification. Import the remote job specification from UI to make the job fully synced.
  * * `DISCONNECTED`: The job is temporary disconnected from the remote job specification and is allowed for live edit. Import the remote job specification again from UI to make the job fully synced.
  */
-export declare enum JobSource_DirtyState {
-    NOT_SYNCED = "NOT_SYNCED",
-    DISCONNECTED = "DISCONNECTED"
-}
-export declare enum ModelTriggerConfiguration_ModelTriggerCondition {
-    CONDITION_UNSPECIFIED = "CONDITION_UNSPECIFIED",
-    MODEL_CREATED = "MODEL_CREATED",
-    MODEL_VERSION_READY = "MODEL_VERSION_READY",
-    MODEL_ALIAS_SET = "MODEL_ALIAS_SET"
-}
+export declare const JobSource_DirtyState: {
+    readonly NOT_SYNCED: "NOT_SYNCED";
+    readonly DISCONNECTED: "DISCONNECTED";
+};
+export type JobSource_DirtyState = (typeof JobSource_DirtyState)[keyof typeof JobSource_DirtyState] | (string & {});
+export declare const ModelTriggerConfiguration_ModelTriggerCondition: {
+    readonly CONDITION_UNSPECIFIED: "CONDITION_UNSPECIFIED";
+    readonly MODEL_CREATED: "MODEL_CREATED";
+    readonly MODEL_VERSION_READY: "MODEL_VERSION_READY";
+    readonly MODEL_ALIAS_SET: "MODEL_ALIAS_SET";
+};
+export type ModelTriggerConfiguration_ModelTriggerCondition = (typeof ModelTriggerConfiguration_ModelTriggerCondition)[keyof typeof ModelTriggerConfiguration_ModelTriggerCondition] | (string & {});
 /**
  * PerformanceTarget defines how performant (lower latency) or cost efficient the execution of run on serverless compute should be.
  * The performance mode on the job or pipeline should map to a performance setting that is passed to Cluster Manager
  * (see cluster-common PerformanceTarget).
  */
-export declare enum PerformanceTarget_PerformanceTarget {
-    PERFORMANCE_TARGET_UNSPECIFIED = "PERFORMANCE_TARGET_UNSPECIFIED",
-    PERFORMANCE_OPTIMIZED = "PERFORMANCE_OPTIMIZED",
-    STANDARD = "STANDARD"
-}
-export declare enum PeriodicTriggerConfiguration_TimeUnit {
-    TIME_UNIT_UNSPECIFIED = "TIME_UNIT_UNSPECIFIED",
-    HOURS = "HOURS",
-    DAYS = "DAYS",
-    WEEKS = "WEEKS"
-}
+export declare const PerformanceTarget_PerformanceTarget: {
+    readonly PERFORMANCE_TARGET_UNSPECIFIED: "PERFORMANCE_TARGET_UNSPECIFIED";
+    readonly PERFORMANCE_OPTIMIZED: "PERFORMANCE_OPTIMIZED";
+    readonly STANDARD: "STANDARD";
+};
+export type PerformanceTarget_PerformanceTarget = (typeof PerformanceTarget_PerformanceTarget)[keyof typeof PerformanceTarget_PerformanceTarget] | (string & {});
+export declare const PeriodicTriggerConfiguration_TimeUnit: {
+    readonly TIME_UNIT_UNSPECIFIED: "TIME_UNIT_UNSPECIFIED";
+    readonly HOURS: "HOURS";
+    readonly DAYS: "DAYS";
+    readonly WEEKS: "WEEKS";
+};
+export type PeriodicTriggerConfiguration_TimeUnit = (typeof PeriodicTriggerConfiguration_TimeUnit)[keyof typeof PeriodicTriggerConfiguration_TimeUnit] | (string & {});
 /**
  * The reason for queuing the run.
  * * `ACTIVE_RUNS_LIMIT_REACHED`: The run was queued due to reaching the workspace limit of active task runs.
  * * `MAX_CONCURRENT_RUNS_REACHED`: The run was queued due to reaching the per-job limit of concurrent job runs.
  * * `ACTIVE_RUN_JOB_TASKS_LIMIT_REACHED`: The run was queued due to reaching the workspace limit of active run job tasks.
  */
-export declare enum QueueDetailsCode_Code {
-    ACTIVE_RUNS_LIMIT_REACHED = "ACTIVE_RUNS_LIMIT_REACHED",
-    MAX_CONCURRENT_RUNS_REACHED = "MAX_CONCURRENT_RUNS_REACHED",
-    ACTIVE_RUN_JOB_TASKS_LIMIT_REACHED = "ACTIVE_RUN_JOB_TASKS_LIMIT_REACHED"
-}
+export declare const QueueDetailsCode_Code: {
+    readonly ACTIVE_RUNS_LIMIT_REACHED: "ACTIVE_RUNS_LIMIT_REACHED";
+    readonly MAX_CONCURRENT_RUNS_REACHED: "MAX_CONCURRENT_RUNS_REACHED";
+    readonly ACTIVE_RUN_JOB_TASKS_LIMIT_REACHED: "ACTIVE_RUN_JOB_TASKS_LIMIT_REACHED";
+};
+export type QueueDetailsCode_Code = (typeof QueueDetailsCode_Code)[keyof typeof QueueDetailsCode_Code] | (string & {});
 /**
  * A value indicating the run's lifecycle state. The possible values are:
  * * `QUEUED`: The run is queued.
@@ -441,31 +477,33 @@ export declare enum QueueDetailsCode_Code {
  * * `BLOCKED`: The run is blocked on an upstream dependency.
  * * `WAITING_FOR_RETRY`: The run is waiting for a retry.
  */
-export declare enum RunLifeCycleState_RunLifeCycleState {
-    PENDING = "PENDING",
-    RUNNING = "RUNNING",
-    TERMINATING = "TERMINATING",
-    TERMINATED = "TERMINATED",
-    SKIPPED = "SKIPPED",
-    INTERNAL_ERROR = "INTERNAL_ERROR",
-    BLOCKED = "BLOCKED",
-    WAITING_FOR_RETRY = "WAITING_FOR_RETRY",
-    QUEUED = "QUEUED"
-}
+export declare const RunLifeCycleState_RunLifeCycleState: {
+    readonly PENDING: "PENDING";
+    readonly RUNNING: "RUNNING";
+    readonly TERMINATING: "TERMINATING";
+    readonly TERMINATED: "TERMINATED";
+    readonly SKIPPED: "SKIPPED";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    readonly BLOCKED: "BLOCKED";
+    readonly WAITING_FOR_RETRY: "WAITING_FOR_RETRY";
+    readonly QUEUED: "QUEUED";
+};
+export type RunLifeCycleState_RunLifeCycleState = (typeof RunLifeCycleState_RunLifeCycleState)[keyof typeof RunLifeCycleState_RunLifeCycleState] | (string & {});
 /** The current state of the run. */
-export declare enum RunLifecycleStateV2_State {
-    BLOCKED = "BLOCKED",
-    PENDING = "PENDING",
-    QUEUED = "QUEUED",
-    RUNNING = "RUNNING",
-    TERMINATING = "TERMINATING",
-    TERMINATED = "TERMINATED",
+export declare const RunLifecycleStateV2_State: {
+    readonly BLOCKED: "BLOCKED";
+    readonly PENDING: "PENDING";
+    readonly QUEUED: "QUEUED";
+    readonly RUNNING: "RUNNING";
+    readonly TERMINATING: "TERMINATING";
+    readonly TERMINATED: "TERMINATED";
     /**
      * Runs in the Waiting state (e.g. cost-optimized runs) are intentionally delayed until an
      * optimal compute scheduling time
      */
-    WAITING = "WAITING"
-}
+    readonly WAITING: "WAITING";
+};
+export type RunLifecycleStateV2_State = (typeof RunLifecycleStateV2_State)[keyof typeof RunLifecycleStateV2_State] | (string & {});
 /**
  * A value indicating the run's result. The possible values are:
  * * `SUCCESS`: The task completed successfully.
@@ -479,18 +517,19 @@ export declare enum RunLifecycleStateV2_State {
  * * `UPSTREAM_CANCELED`: The run was skipped because an upstream task was canceled.
  * * `DISABLED`: The run was skipped because it was disabled explicitly by the user.
  */
-export declare enum RunResultState_RunResultState {
-    SUCCESS = "SUCCESS",
-    FAILED = "FAILED",
-    TIMEDOUT = "TIMEDOUT",
-    CANCELED = "CANCELED",
-    MAXIMUM_CONCURRENT_RUNS_REACHED = "MAXIMUM_CONCURRENT_RUNS_REACHED",
-    UPSTREAM_CANCELED = "UPSTREAM_CANCELED",
-    UPSTREAM_FAILED = "UPSTREAM_FAILED",
-    EXCLUDED = "EXCLUDED",
-    SUCCESS_WITH_FAILURES = "SUCCESS_WITH_FAILURES",
-    DISABLED = "DISABLED"
-}
+export declare const RunResultState_RunResultState: {
+    readonly SUCCESS: "SUCCESS";
+    readonly FAILED: "FAILED";
+    readonly TIMEDOUT: "TIMEDOUT";
+    readonly CANCELED: "CANCELED";
+    readonly MAXIMUM_CONCURRENT_RUNS_REACHED: "MAXIMUM_CONCURRENT_RUNS_REACHED";
+    readonly UPSTREAM_CANCELED: "UPSTREAM_CANCELED";
+    readonly UPSTREAM_FAILED: "UPSTREAM_FAILED";
+    readonly EXCLUDED: "EXCLUDED";
+    readonly SUCCESS_WITH_FAILURES: "SUCCESS_WITH_FAILURES";
+    readonly DISABLED: "DISABLED";
+};
+export type RunResultState_RunResultState = (typeof RunResultState_RunResultState)[keyof typeof RunResultState_RunResultState] | (string & {});
 /**
  * The state of the SQL alert.
  *
@@ -498,22 +537,25 @@ export declare enum RunResultState_RunResultState {
  * * OK: alert evaluated and did not fulfill trigger conditions
  * * TRIGGERED: alert evaluated and fulfilled trigger conditions
  */
-export declare enum SqlAlertState_SqlAlertState {
-    UNKNOWN = "UNKNOWN",
-    OK = "OK",
-    TRIGGERED = "TRIGGERED"
-}
-export declare enum SqlTask_SqlTaskQueryStatus {
-    PENDING = "PENDING",
-    RUNNING = "RUNNING",
-    SUCCESS = "SUCCESS",
-    FAILED = "FAILED",
-    CANCELLED = "CANCELLED"
-}
-export declare enum TableTriggerConfiguration_Condition {
-    ANY_UPDATED = "ANY_UPDATED",
-    ALL_UPDATED = "ALL_UPDATED"
-}
+export declare const SqlAlertState_SqlAlertState: {
+    readonly UNKNOWN: "UNKNOWN";
+    readonly OK: "OK";
+    readonly TRIGGERED: "TRIGGERED";
+};
+export type SqlAlertState_SqlAlertState = (typeof SqlAlertState_SqlAlertState)[keyof typeof SqlAlertState_SqlAlertState] | (string & {});
+export declare const SqlTask_SqlTaskQueryStatus: {
+    readonly PENDING: "PENDING";
+    readonly RUNNING: "RUNNING";
+    readonly SUCCESS: "SUCCESS";
+    readonly FAILED: "FAILED";
+    readonly CANCELLED: "CANCELLED";
+};
+export type SqlTask_SqlTaskQueryStatus = (typeof SqlTask_SqlTaskQueryStatus)[keyof typeof SqlTask_SqlTaskQueryStatus] | (string & {});
+export declare const TableTriggerConfiguration_Condition: {
+    readonly ANY_UPDATED: "ANY_UPDATED";
+    readonly ALL_UPDATED: "ALL_UPDATED";
+};
+export type TableTriggerConfiguration_Condition = (typeof TableTriggerConfiguration_Condition)[keyof typeof TableTriggerConfiguration_Condition] | (string & {});
 /**
  * The code indicates why the run was terminated. Additional codes might be introduced in future releases.
  * * `SUCCESS`: The run was completed successfully.
@@ -543,25 +585,25 @@ export declare enum TableTriggerConfiguration_Condition {
  * * `BREAKING_CHANGE`: Run failed because of an intentional breaking change in Spark, but it will be retried with a mitigation config.
  * * `CLUSTER_TERMINATED_BY_USER`: The run failed because the externally managed cluster entered an unusable state, likely due to the user terminating or restarting it outside the jobs service.
  */
-export declare enum TerminationCode_Code {
-    SUCCESS = "SUCCESS",
-    CANCELED = "CANCELED",
+export declare const TerminationCode_Code: {
+    readonly SUCCESS: "SUCCESS";
+    readonly CANCELED: "CANCELED";
     /** DriverError represents failures when the driver restarted, or became unhealthy or unreachable during the run. */
-    DRIVER_ERROR = "DRIVER_ERROR",
+    readonly DRIVER_ERROR: "DRIVER_ERROR";
     /**
      * ClusterError represents failures due to cluster issues. These include the failures that occur during
      * creation of a new cluster / starting up an existing cluster, cluster issues and timeouts during the job run
      */
-    CLUSTER_ERROR = "CLUSTER_ERROR",
+    readonly CLUSTER_ERROR: "CLUSTER_ERROR";
     /** Returned if [[ProjectCheckoutInternalRepo]] RPC fails */
-    REPOSITORY_CHECKOUT_FAILED = "REPOSITORY_CHECKOUT_FAILED",
+    readonly REPOSITORY_CHECKOUT_FAILED: "REPOSITORY_CHECKOUT_FAILED";
     /**
      * *
      * InvalidClusterRequest represents failures when the user provides invalid input for a cluster
      * configuration for the run. For example, providing invalid parameter Values in the request/
      * providing a bad request etc
      */
-    INVALID_CLUSTER_REQUEST = "INVALID_CLUSTER_REQUEST",
+    readonly INVALID_CLUSTER_REQUEST: "INVALID_CLUSTER_REQUEST";
     /**
      * *
      * Returned if an org set a limit for number of their concurrent active runs and the run couldn't start
@@ -570,24 +612,24 @@ export declare enum TerminationCode_Code {
      * It should be looked into how we're handling the scenario where a given job exceeds its own internal concurrency
      * limits.
      */
-    WORKSPACE_RUN_LIMIT_EXCEEDED = "WORKSPACE_RUN_LIMIT_EXCEEDED",
-    FEATURE_DISABLED = "FEATURE_DISABLED",
+    readonly WORKSPACE_RUN_LIMIT_EXCEEDED: "WORKSPACE_RUN_LIMIT_EXCEEDED";
+    readonly FEATURE_DISABLED: "FEATURE_DISABLED";
     /**
      * *
      * ClusterRequestLimitExceeded represents failures when cluster
      * creation, start, and upsize requests for a workspace exceeded the rate limit of
      * [[com.databricks.backend.cluster.ClusterSizeConf.upsizeRefillRatePerMinPerOrg]] nodes per min.
      */
-    CLUSTER_REQUEST_LIMIT_EXCEEDED = "CLUSTER_REQUEST_LIMIT_EXCEEDED",
+    readonly CLUSTER_REQUEST_LIMIT_EXCEEDED: "CLUSTER_REQUEST_LIMIT_EXCEEDED";
     /**
      * *
      * StorageAccessError represents failures when the access to user's <Databricks> file system fails.
      * For example, misconfiguration on user's side like deleting AWS S3 bucket without cancelling the workspace,
      * their Azure account being disabled, the storage buckets not being found etc.
      */
-    STORAGE_ACCESS_ERROR = "STORAGE_ACCESS_ERROR",
-    RUN_EXECUTION_ERROR = "RUN_EXECUTION_ERROR",
-    UNAUTHORIZED_ERROR = "UNAUTHORIZED_ERROR",
+    readonly STORAGE_ACCESS_ERROR: "STORAGE_ACCESS_ERROR";
+    readonly RUN_EXECUTION_ERROR: "RUN_EXECUTION_ERROR";
+    readonly UNAUTHORIZED_ERROR: "UNAUTHORIZED_ERROR";
     /**
      * *
      * LibraryInstallationError represents failures due to issues related library installation.
@@ -595,38 +637,40 @@ export declare enum TerminationCode_Code {
      * enough permissions to install the library or any cloud dependency/ infrastructure failures during
      * library installation etc
      */
-    LIBRARY_INSTALLATION_ERROR = "LIBRARY_INSTALLATION_ERROR",
-    MAX_CONCURRENT_RUNS_EXCEEDED = "MAX_CONCURRENT_RUNS_EXCEEDED",
-    MAX_SPARK_CONTEXTS_EXCEEDED = "MAX_SPARK_CONTEXTS_EXCEEDED",
-    RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND",
-    INVALID_RUN_CONFIGURATION = "INVALID_RUN_CONFIGURATION",
-    INTERNAL_ERROR = "INTERNAL_ERROR",
-    CLOUD_FAILURE = "CLOUD_FAILURE",
-    MAX_JOB_QUEUE_SIZE_EXCEEDED = "MAX_JOB_QUEUE_SIZE_EXCEEDED",
-    SKIPPED = "SKIPPED",
-    USER_CANCELED = "USER_CANCELED",
-    BUDGET_POLICY_LIMIT_EXCEEDED = "BUDGET_POLICY_LIMIT_EXCEEDED",
-    DISABLED = "DISABLED",
+    readonly LIBRARY_INSTALLATION_ERROR: "LIBRARY_INSTALLATION_ERROR";
+    readonly MAX_CONCURRENT_RUNS_EXCEEDED: "MAX_CONCURRENT_RUNS_EXCEEDED";
+    readonly MAX_SPARK_CONTEXTS_EXCEEDED: "MAX_SPARK_CONTEXTS_EXCEEDED";
+    readonly RESOURCE_NOT_FOUND: "RESOURCE_NOT_FOUND";
+    readonly INVALID_RUN_CONFIGURATION: "INVALID_RUN_CONFIGURATION";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    readonly CLOUD_FAILURE: "CLOUD_FAILURE";
+    readonly MAX_JOB_QUEUE_SIZE_EXCEEDED: "MAX_JOB_QUEUE_SIZE_EXCEEDED";
+    readonly SKIPPED: "SKIPPED";
+    readonly USER_CANCELED: "USER_CANCELED";
+    readonly BUDGET_POLICY_LIMIT_EXCEEDED: "BUDGET_POLICY_LIMIT_EXCEEDED";
+    readonly DISABLED: "DISABLED";
     /**
      * SuccessWithFailures represents that some child runs failed
      * but the run was ultimately successful.
      */
-    SUCCESS_WITH_FAILURES = "SUCCESS_WITH_FAILURES",
+    readonly SUCCESS_WITH_FAILURES: "SUCCESS_WITH_FAILURES";
     /** Run failed because of an intentional breaking change in Spark, but it will be retried with a mitigation config. */
-    BREAKING_CHANGE = "BREAKING_CHANGE"
-}
+    readonly BREAKING_CHANGE: "BREAKING_CHANGE";
+};
+export type TerminationCode_Code = (typeof TerminationCode_Code)[keyof typeof TerminationCode_Code] | (string & {});
 /**
  * * `SUCCESS`: The run terminated without any issues
  * * `INTERNAL_ERROR`: An error occurred in the <Databricks> platform. Please look at the [status page](https://status.databricks.com/) or contact support if the issue persists.
  * * `CLIENT_ERROR`: The run was terminated because of an error caused by user input or the job configuration.
  * * `CLOUD_FAILURE`: The run was terminated because of an issue with your cloud provider.
  */
-export declare enum TerminationType_Type {
-    SUCCESS = "SUCCESS",
-    INTERNAL_ERROR = "INTERNAL_ERROR",
-    CLIENT_ERROR = "CLIENT_ERROR",
-    CLOUD_FAILURE = "CLOUD_FAILURE"
-}
+export declare const TerminationType_Type: {
+    readonly SUCCESS: "SUCCESS";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    readonly CLIENT_ERROR: "CLIENT_ERROR";
+    readonly CLOUD_FAILURE: "CLOUD_FAILURE";
+};
+export type TerminationType_Type = (typeof TerminationType_Type)[keyof typeof TerminationType_Type] | (string & {});
 export interface AccessControlRequest {
     principalName?: {
         $case: 'userName';
@@ -1768,6 +1812,14 @@ export interface GcsStorageInfo {
     /** GCS destination/URI, e.g. `gs://my-bucket/some-prefix` */
     destination?: string | undefined;
 }
+/**
+ * DEPRECATED — use `AiRuntimeTask` for all new BYOT multi-node GPU
+ * workloads (see ai_runtime_task.proto). `AiRuntimeTask` is the only
+ * supported BYOT task type for new workloads; this proto is retained only
+ * for AIR CLI (fka SGCLI) pywheel backwards compatibility and will be
+ * removed once the pywheel → databricks-cli migration completes (post-
+ * PuPr).
+ */
 export interface GenAiComputeTask {
     /** Runtime image */
     dlRuntimeImage?: string | undefined;