databricks-sdk 0.57.0__py3-none-any.whl → 0.59.0__py3-none-any.whl

databricks/sdk/service/jobs.py

@@ -219,11 +219,6 @@ class BaseRun:
     """The URL to the detail page of the run."""
 
     run_type: Optional[RunType] = None
-    """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]. * `SUBMIT_RUN`: Submit
-    run. A run created with :method:jobs/submit.
-    
-    [dbutils.notebook.run]: https://docs.databricks.com/dev-tools/databricks-utils.html#dbutils-workflow"""
 
     schedule: Optional[CronSchedule] = None
     """The cron schedule that triggered this run if it was triggered by the periodic scheduler."""
@@ -244,7 +239,6 @@ class BaseRun:
     """Deprecated. Please use the `status` field instead."""
 
     status: Optional[RunStatus] = None
-    """The current status of the run"""
 
     tasks: Optional[List[RunTask]] = None
     """The list of tasks performed by the run. Each task has its own `run_id` which you can use to call
@@ -253,19 +247,8 @@ class BaseRun:
     root to determine if more results are available."""
 
     trigger: Optional[TriggerType] = None
-    """The type of trigger that fired this run.
-    
-    * `PERIODIC`: Schedules that periodically trigger runs, such as a cron scheduler. * `ONE_TIME`:
-    One time triggers that fire a single run. This occurs you triggered a single run on demand
-    through the UI or the API. * `RETRY`: Indicates a run that is triggered as a retry of a
-    previously failed run. This occurs when you request to re-run the job in case of failures. *
-    `RUN_JOB_TASK`: Indicates a run that is triggered using a Run Job task. * `FILE_ARRIVAL`:
-    Indicates a run that is triggered by a file arrival. * `TABLE`: Indicates a run that is
-    triggered by a table update. * `CONTINUOUS_RESTART`: Indicates a run created by user to manually
-    restart a continuous job run."""
 
     trigger_info: Optional[TriggerInfo] = None
-    """Additional details about what triggered the run"""
 
     def as_dict(self) -> dict:
         """Serializes the BaseRun into a dictionary suitable for use as a JSON request body."""
@@ -449,39 +432,6 @@ class BaseRun:
         )
 
 
-@dataclass
-class CancelAllRuns:
-    all_queued_runs: Optional[bool] = None
-    """Optional boolean parameter to cancel all queued runs. If no job_id is provided, all queued runs
-    in the workspace are canceled."""
-
-    job_id: Optional[int] = None
-    """The canonical identifier of the job to cancel all runs of."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CancelAllRuns into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.all_queued_runs is not None:
-            body["all_queued_runs"] = self.all_queued_runs
-        if self.job_id is not None:
-            body["job_id"] = self.job_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CancelAllRuns into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.all_queued_runs is not None:
-            body["all_queued_runs"] = self.all_queued_runs
-        if self.job_id is not None:
-            body["job_id"] = self.job_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CancelAllRuns:
-        """Deserializes the CancelAllRuns from a dictionary."""
-        return cls(all_queued_runs=d.get("all_queued_runs", None), job_id=d.get("job_id", None))
-
-
 @dataclass
 class CancelAllRunsResponse:
     def as_dict(self) -> dict:
@@ -500,31 +450,6 @@ class CancelAllRunsResponse:
         return cls()
 
 
-@dataclass
-class CancelRun:
-    run_id: int
-    """This field is required."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CancelRun into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CancelRun into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CancelRun:
-        """Deserializes the CancelRun from a dictionary."""
-        return cls(run_id=d.get("run_id", None))
-
-
 @dataclass
 class CancelRunResponse:
     def as_dict(self) -> dict:
@@ -952,271 +877,6 @@ class Continuous:
         return cls(pause_status=_enum(d, "pause_status", PauseStatus))
 
 
-@dataclass
-class CreateJob:
-    access_control_list: Optional[List[JobAccessControlRequest]] = None
-    """List of permissions to set on the job."""
-
-    budget_policy_id: Optional[str] = None
-    """The id of the user specified budget policy to use for this job. If not specified, a default
-    budget policy may be applied when creating or modifying the job. See
-    `effective_budget_policy_id` for the budget policy used by this workload."""
-
-    continuous: Optional[Continuous] = None
-    """An optional continuous property for this job. The continuous property will ensure that there is
-    always one run executing. Only one of `schedule` and `continuous` can be used."""
-
-    deployment: Optional[JobDeployment] = None
-    """Deployment information for jobs managed by external sources."""
-
-    description: Optional[str] = None
-    """An optional description for the job. The maximum length is 27700 characters in UTF-8 encoding."""
-
-    edit_mode: Optional[JobEditMode] = None
-    """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."""
-
-    email_notifications: Optional[JobEmailNotifications] = None
-    """An optional set of email addresses that is notified when runs of this job begin or complete as
-    well as when this job is deleted."""
-
-    environments: Optional[List[JobEnvironment]] = None
-    """A list of task execution environment specifications that can be referenced by serverless tasks
-    of this job. An environment is required to be present for serverless tasks. For serverless
-    notebook tasks, the environment is accessible in the notebook environment panel. For other
-    serverless tasks, the task environment is required to be specified using environment_key in the
-    task settings."""
-
-    format: Optional[Format] = None
-    """Used to tell what is the format of the job. This field is ignored in Create/Update/Reset calls.
-    When using the Jobs API 2.1 this value is always set to `"MULTI_TASK"`."""
-
-    git_source: Optional[GitSource] = None
-    """An optional specification for a remote Git repository containing the source code used by tasks.
-    Version-controlled source code is supported by notebook, dbt, Python script, and SQL File tasks.
-    
-    If `git_source` is set, these tasks retrieve the file from the remote repository by default.
-    However, this behavior can be overridden by setting `source` to `WORKSPACE` on the task.
-    
-    Note: dbt and SQL File tasks support only version-controlled sources. If dbt or SQL File tasks
-    are used, `git_source` must be defined on the job."""
-
-    health: Optional[JobsHealthRules] = None
-    """An optional set of health rules that can be defined for this job."""
-
-    job_clusters: Optional[List[JobCluster]] = None
-    """A list of job cluster specifications that can be shared and reused by tasks of this job.
-    Libraries cannot be declared in a shared job cluster. You must declare dependent libraries in
-    task settings."""
-
-    max_concurrent_runs: Optional[int] = None
-    """An optional maximum allowed number of concurrent runs of the job. Set this value if you want to
-    be able to execute multiple runs of the same job concurrently. This is useful for example if you
-    trigger your job on a frequent schedule and want to allow consecutive runs to overlap with each
-    other, or if you want to trigger multiple runs which differ by their input parameters. This
-    setting affects only new runs. For example, suppose the job’s concurrency is 4 and there are 4
-    concurrent active runs. Then setting the concurrency to 3 won’t kill any of the active runs.
-    However, from then on, new runs are skipped unless there are fewer than 3 active runs. This
-    value cannot exceed 1000. Setting this value to `0` causes all new runs to be skipped."""
-
-    name: Optional[str] = None
-    """An optional name for the job. The maximum length is 4096 bytes in UTF-8 encoding."""
-
-    notification_settings: Optional[JobNotificationSettings] = None
-    """Optional notification settings that are used when sending notifications to each of the
-    `email_notifications` and `webhook_notifications` for this job."""
-
-    parameters: Optional[List[JobParameterDefinition]] = None
-    """Job-level parameter definitions"""
-
-    performance_target: Optional[PerformanceTarget] = None
-    """The performance mode on a serverless job. This field determines the level of compute performance
-    or cost-efficiency for the run.
-    
-    * `STANDARD`: Enables cost-efficient execution of serverless workloads. *
-    `PERFORMANCE_OPTIMIZED`: Prioritizes fast startup and execution times through rapid scaling and
-    optimized cluster performance."""
-
-    queue: Optional[QueueSettings] = None
-    """The queue settings of the job."""
-
-    run_as: Optional[JobRunAs] = None
-    """Write-only setting. Specifies the user or service principal that the job runs as. If not
-    specified, the job runs as the user who created the job.
-    
-    Either `user_name` or `service_principal_name` should be specified. If not, an error is thrown."""
-
-    schedule: Optional[CronSchedule] = None
-    """An optional periodic schedule for this job. The default behavior is that the job only runs when
-    triggered by clicking “Run Now” in the Jobs UI or sending an API request to `runNow`."""
-
-    tags: Optional[Dict[str, str]] = None
-    """A map of tags associated with the job. These are forwarded to the cluster as cluster tags for
-    jobs clusters, and are subject to the same limitations as cluster tags. A maximum of 25 tags can
-    be added to the job."""
-
-    tasks: Optional[List[Task]] = None
-    """A list of task specifications to be executed by this job. It supports up to 1000 elements in
-    write endpoints (:method:jobs/create, :method:jobs/reset, :method:jobs/update,
-    :method:jobs/submit). Read endpoints return only 100 tasks. If more than 100 tasks are
-    available, you can paginate through them using :method:jobs/get. Use the `next_page_token` field
-    at the object root to determine if more results are available."""
-
-    timeout_seconds: Optional[int] = None
-    """An optional timeout applied to each run of this job. A value of `0` means no timeout."""
-
-    trigger: Optional[TriggerSettings] = None
-    """A configuration to trigger a run when certain conditions are met. The default behavior is that
-    the job runs only when triggered by clicking “Run Now” in the Jobs UI or sending an API
-    request to `runNow`."""
-
-    webhook_notifications: Optional[WebhookNotifications] = None
-    """A collection of system notification IDs to notify when runs of this job begin or complete."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateJob into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = [v.as_dict() for v in self.access_control_list]
-        if self.budget_policy_id is not None:
-            body["budget_policy_id"] = self.budget_policy_id
-        if self.continuous:
-            body["continuous"] = self.continuous.as_dict()
-        if self.deployment:
-            body["deployment"] = self.deployment.as_dict()
-        if self.description is not None:
-            body["description"] = self.description
-        if self.edit_mode is not None:
-            body["edit_mode"] = self.edit_mode.value
-        if self.email_notifications:
-            body["email_notifications"] = self.email_notifications.as_dict()
-        if self.environments:
-            body["environments"] = [v.as_dict() for v in self.environments]
-        if self.format is not None:
-            body["format"] = self.format.value
-        if self.git_source:
-            body["git_source"] = self.git_source.as_dict()
-        if self.health:
-            body["health"] = self.health.as_dict()
-        if self.job_clusters:
-            body["job_clusters"] = [v.as_dict() for v in self.job_clusters]
-        if self.max_concurrent_runs is not None:
-            body["max_concurrent_runs"] = self.max_concurrent_runs
-        if self.name is not None:
-            body["name"] = self.name
-        if self.notification_settings:
-            body["notification_settings"] = self.notification_settings.as_dict()
-        if self.parameters:
-            body["parameters"] = [v.as_dict() for v in self.parameters]
-        if self.performance_target is not None:
-            body["performance_target"] = self.performance_target.value
-        if self.queue:
-            body["queue"] = self.queue.as_dict()
-        if self.run_as:
-            body["run_as"] = self.run_as.as_dict()
-        if self.schedule:
-            body["schedule"] = self.schedule.as_dict()
-        if self.tags:
-            body["tags"] = self.tags
-        if self.tasks:
-            body["tasks"] = [v.as_dict() for v in self.tasks]
-        if self.timeout_seconds is not None:
-            body["timeout_seconds"] = self.timeout_seconds
-        if self.trigger:
-            body["trigger"] = self.trigger.as_dict()
-        if self.webhook_notifications:
-            body["webhook_notifications"] = self.webhook_notifications.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateJob into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = self.access_control_list
-        if self.budget_policy_id is not None:
-            body["budget_policy_id"] = self.budget_policy_id
-        if self.continuous:
-            body["continuous"] = self.continuous
-        if self.deployment:
-            body["deployment"] = self.deployment
-        if self.description is not None:
-            body["description"] = self.description
-        if self.edit_mode is not None:
-            body["edit_mode"] = self.edit_mode
-        if self.email_notifications:
-            body["email_notifications"] = self.email_notifications
-        if self.environments:
-            body["environments"] = self.environments
-        if self.format is not None:
-            body["format"] = self.format
-        if self.git_source:
-            body["git_source"] = self.git_source
-        if self.health:
-            body["health"] = self.health
-        if self.job_clusters:
-            body["job_clusters"] = self.job_clusters
-        if self.max_concurrent_runs is not None:
-            body["max_concurrent_runs"] = self.max_concurrent_runs
-        if self.name is not None:
-            body["name"] = self.name
-        if self.notification_settings:
-            body["notification_settings"] = self.notification_settings
-        if self.parameters:
-            body["parameters"] = self.parameters
-        if self.performance_target is not None:
-            body["performance_target"] = self.performance_target
-        if self.queue:
-            body["queue"] = self.queue
-        if self.run_as:
-            body["run_as"] = self.run_as
-        if self.schedule:
-            body["schedule"] = self.schedule
-        if self.tags:
-            body["tags"] = self.tags
-        if self.tasks:
-            body["tasks"] = self.tasks
-        if self.timeout_seconds is not None:
-            body["timeout_seconds"] = self.timeout_seconds
-        if self.trigger:
-            body["trigger"] = self.trigger
-        if self.webhook_notifications:
-            body["webhook_notifications"] = self.webhook_notifications
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateJob:
-        """Deserializes the CreateJob from a dictionary."""
-        return cls(
-            access_control_list=_repeated_dict(d, "access_control_list", JobAccessControlRequest),
-            budget_policy_id=d.get("budget_policy_id", None),
-            continuous=_from_dict(d, "continuous", Continuous),
-            deployment=_from_dict(d, "deployment", JobDeployment),
-            description=d.get("description", None),
-            edit_mode=_enum(d, "edit_mode", JobEditMode),
-            email_notifications=_from_dict(d, "email_notifications", JobEmailNotifications),
-            environments=_repeated_dict(d, "environments", JobEnvironment),
-            format=_enum(d, "format", Format),
-            git_source=_from_dict(d, "git_source", GitSource),
-            health=_from_dict(d, "health", JobsHealthRules),
-            job_clusters=_repeated_dict(d, "job_clusters", JobCluster),
-            max_concurrent_runs=d.get("max_concurrent_runs", None),
-            name=d.get("name", None),
-            notification_settings=_from_dict(d, "notification_settings", JobNotificationSettings),
-            parameters=_repeated_dict(d, "parameters", JobParameterDefinition),
-            performance_target=_enum(d, "performance_target", PerformanceTarget),
-            queue=_from_dict(d, "queue", QueueSettings),
-            run_as=_from_dict(d, "run_as", JobRunAs),
-            schedule=_from_dict(d, "schedule", CronSchedule),
-            tags=d.get("tags", None),
-            tasks=_repeated_dict(d, "tasks", Task),
-            timeout_seconds=d.get("timeout_seconds", None),
-            trigger=_from_dict(d, "trigger", TriggerSettings),
-            webhook_notifications=_from_dict(d, "webhook_notifications", WebhookNotifications),
-        )
-
-
 @dataclass
 class CreateResponse:
     """Job was created successfully"""
@@ -1822,32 +1482,7 @@ class DbtTask:
             schema=d.get("schema", None),
             source=_enum(d, "source", Source),
             warehouse_id=d.get("warehouse_id", None),
-        )
-
-
-@dataclass
-class DeleteJob:
-    job_id: int
-    """The canonical identifier of the job to delete. This field is required."""
-
-    def as_dict(self) -> dict:
-        """Serializes the DeleteJob into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.job_id is not None:
-            body["job_id"] = self.job_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteJob into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.job_id is not None:
-            body["job_id"] = self.job_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteJob:
-        """Deserializes the DeleteJob from a dictionary."""
-        return cls(job_id=d.get("job_id", None))
+        )
 
 
 @dataclass
@@ -1868,31 +1503,6 @@ class DeleteResponse:
         return cls()
 
 
-@dataclass
-class DeleteRun:
-    run_id: int
-    """ID of the run to delete."""
-
-    def as_dict(self) -> dict:
-        """Serializes the DeleteRun into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteRun into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteRun:
-        """Deserializes the DeleteRun from a dictionary."""
-        return cls(run_id=d.get("run_id", None))
-
-
 @dataclass
 class DeleteRunResponse:
     def as_dict(self) -> dict:
@@ -1959,38 +1569,6 @@ class EnforcePolicyComplianceForJobResponseJobClusterSettingsChange:
         )
 
 
-@dataclass
-class EnforcePolicyComplianceRequest:
-    job_id: int
-    """The ID of the job you want to enforce policy compliance on."""
-
-    validate_only: Optional[bool] = None
-    """If set, previews changes made to the job to comply with its policy, but does not update the job."""
-
-    def as_dict(self) -> dict:
-        """Serializes the EnforcePolicyComplianceRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.job_id is not None:
-            body["job_id"] = self.job_id
-        if self.validate_only is not None:
-            body["validate_only"] = self.validate_only
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the EnforcePolicyComplianceRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.job_id is not None:
-            body["job_id"] = self.job_id
-        if self.validate_only is not None:
-            body["validate_only"] = self.validate_only
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> EnforcePolicyComplianceRequest:
-        """Deserializes the EnforcePolicyComplianceRequest from a dictionary."""
-        return cls(job_id=d.get("job_id", None), validate_only=d.get("validate_only", None))
-
-
 @dataclass
 class EnforcePolicyComplianceResponse:
     has_changes: Optional[bool] = None
@@ -2557,8 +2135,6 @@ class GitSource:
     with git_branch or git_tag."""
 
     git_snapshot: Optional[GitSnapshot] = None
-    """Read-only state of the remote repository at the time the job was run. This field is only
-    included on job runs."""
 
     git_tag: Optional[str] = None
     """Name of the tag to be checked out and used by this job. This field cannot be specified in
@@ -2731,7 +2307,6 @@ class JobAccessControlRequest:
     """name of the group"""
 
     permission_level: Optional[JobPermissionLevel] = None
-    """Permission level"""
 
     service_principal_name: Optional[str] = None
     """application ID of a service principal"""
@@ -3054,9 +2629,6 @@ class JobEnvironment:
     """The key of an environment. It has to be unique within a job."""
 
     spec: Optional[compute.Environment] = None
-    """The environment entity used to preserve serverless environment side panel, jobs' environment for
-    non-notebook task, and DLT's environment for classic and serverless pipelines. In this minimal
-    environment spec, only pip dependencies are supported."""
 
     def as_dict(self) -> dict:
         """Serializes the JobEnvironment into a dictionary suitable for use as a JSON request body."""
@@ -3197,7 +2769,6 @@ class JobPermission:
     inherited_from_object: Optional[List[str]] = None
 
     permission_level: Optional[JobPermissionLevel] = None
-    """Permission level"""
 
     def as_dict(self) -> dict:
         """Serializes the JobPermission into a dictionary suitable for use as a JSON request body."""
@@ -3285,7 +2856,6 @@ class JobPermissionsDescription:
     description: Optional[str] = None
 
     permission_level: Optional[JobPermissionLevel] = None
-    """Permission level"""
 
     def as_dict(self) -> dict:
         """Serializes the JobPermissionsDescription into a dictionary suitable for use as a JSON request body."""
@@ -3313,40 +2883,6 @@ class JobPermissionsDescription:
         )
 
 
-@dataclass
-class JobPermissionsRequest:
-    access_control_list: Optional[List[JobAccessControlRequest]] = None
-
-    job_id: Optional[str] = None
-    """The job for which to get or manage permissions."""
-
-    def as_dict(self) -> dict:
-        """Serializes the JobPermissionsRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = [v.as_dict() for v in self.access_control_list]
-        if self.job_id is not None:
-            body["job_id"] = self.job_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the JobPermissionsRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = self.access_control_list
-        if self.job_id is not None:
-            body["job_id"] = self.job_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> JobPermissionsRequest:
-        """Deserializes the JobPermissionsRequest from a dictionary."""
-        return cls(
-            access_control_list=_repeated_dict(d, "access_control_list", JobAccessControlRequest),
-            job_id=d.get("job_id", None),
-        )
-
-
 @dataclass
 class JobRunAs:
     """Write-only setting. Specifies the user or service principal that the job runs as. If not
@@ -3435,7 +2971,6 @@ class JobSettings:
     are used, `git_source` must be defined on the job."""
 
     health: Optional[JobsHealthRules] = None
-    """An optional set of health rules that can be defined for this job."""
 
     job_clusters: Optional[List[JobCluster]] = None
     """A list of job cluster specifications that can be shared and reused by tasks of this job.
@@ -3474,10 +3009,9 @@ class JobSettings:
     """The queue settings of the job."""
 
     run_as: Optional[JobRunAs] = None
-    """Write-only setting. Specifies the user or service principal that the job runs as. If not
-    specified, the job runs as the user who created the job.
-    
-    Either `user_name` or `service_principal_name` should be specified. If not, an error is thrown."""
+    """The user or service principal that the job runs as, if specified in the request. This field
+    indicates the explicit configuration of `run_as` for the job. To find the value in all cases,
+    explicit or implicit, use `run_as_user_name`."""
 
     schedule: Optional[CronSchedule] = None
     """An optional periodic schedule for this job. The default behavior is that the job only runs when
@@ -3736,18 +3270,8 @@ class JobsHealthOperator(Enum):
 @dataclass
 class JobsHealthRule:
     metric: JobsHealthMetric
-    """Specifies the health metric that is being evaluated for a particular health rule.
-    
-    * `RUN_DURATION_SECONDS`: Expected total time for a run in seconds. * `STREAMING_BACKLOG_BYTES`:
-    An estimate of the maximum bytes of data waiting to be consumed across all streams. This metric
-    is in Public Preview. * `STREAMING_BACKLOG_RECORDS`: An estimate of the maximum offset lag
-    across all streams. This metric is in Public Preview. * `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."""
 
     op: JobsHealthOperator
-    """Specifies the operator used to compare the health metric value with the specified threshold."""
 
     value: int
     """Specifies the threshold value that the health metric should obey to satisfy the health rule."""
@@ -4453,11 +3977,6 @@ class PythonWheelTask:
 @dataclass
 class QueueDetails:
     code: Optional[QueueDetailsCodeCode] = None
-    """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."""
 
     message: Optional[str] = None
     """A descriptive message with the queuing details. This field is unstructured, and its exact format
@@ -4548,7 +4067,6 @@ class RepairHistoryItem:
     """Deprecated. Please use the `status` field instead."""
 
     status: Optional[RunStatus] = None
-    """The current status of the run"""
 
     task_run_ids: Optional[List[int]] = None
     """The run IDs of the task runs that ran as part of this repair history item."""
@@ -4591,233 +4109,35 @@ class RepairHistoryItem:
         if self.state:
             body["state"] = self.state
         if self.status:
-            body["status"] = self.status
-        if self.task_run_ids:
-            body["task_run_ids"] = self.task_run_ids
-        if self.type is not None:
-            body["type"] = self.type
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> RepairHistoryItem:
-        """Deserializes the RepairHistoryItem from a dictionary."""
-        return cls(
-            effective_performance_target=_enum(d, "effective_performance_target", PerformanceTarget),
-            end_time=d.get("end_time", None),
-            id=d.get("id", None),
-            start_time=d.get("start_time", None),
-            state=_from_dict(d, "state", RunState),
-            status=_from_dict(d, "status", RunStatus),
-            task_run_ids=d.get("task_run_ids", None),
-            type=_enum(d, "type", RepairHistoryItemType),
-        )
-
-
-class RepairHistoryItemType(Enum):
-    """The repair history item type. Indicates whether a run is the original run or a repair run."""
-
-    ORIGINAL = "ORIGINAL"
-    REPAIR = "REPAIR"
-
-
-@dataclass
-class RepairRun:
-    run_id: int
-    """The job run ID of the run to repair. The run must not be in progress."""
-
-    dbt_commands: Optional[List[str]] = None
-    """An array of commands to execute for jobs with the dbt task, for example `"dbt_commands": ["dbt
-    deps", "dbt seed", "dbt deps", "dbt seed", "dbt run"]`"""
-
-    jar_params: Optional[List[str]] = None
-    """A list of parameters for jobs with Spark JAR tasks, for example `"jar_params": ["john doe",
-    "35"]`. The parameters are used to invoke the main function of the main class specified in the
-    Spark JAR task. If not specified upon `run-now`, it defaults to an empty list. jar_params cannot
-    be specified in conjunction with notebook_params. The JSON representation of this field (for
-    example `{"jar_params":["john doe","35"]}`) cannot exceed 10,000 bytes.
-    
-    Use [Task parameter variables] to set parameters containing information about job runs.
-    
-    [Task parameter variables]: https://docs.databricks.com/jobs.html#parameter-variables"""
-
-    job_parameters: Optional[Dict[str, str]] = None
-    """Job-level parameters used in the run. for example `"param": "overriding_val"`"""
-
-    latest_repair_id: Optional[int] = None
-    """The ID of the latest repair. This parameter is not required when repairing a run for the first
-    time, but must be provided on subsequent requests to repair the same run."""
-
-    notebook_params: Optional[Dict[str, str]] = None
-    """A map from keys to values for jobs with notebook task, for example `"notebook_params": {"name":
-    "john doe", "age": "35"}`. The map is passed to the notebook and is accessible through the
-    [dbutils.widgets.get] function.
-    
-    If not specified upon `run-now`, the triggered run uses the job’s base parameters.
-    
-    notebook_params cannot be specified in conjunction with jar_params.
-    
-    Use [Task parameter variables] to set parameters containing information about job runs.
-    
-    The JSON representation of this field (for example `{"notebook_params":{"name":"john
-    doe","age":"35"}}`) cannot exceed 10,000 bytes.
-    
-    [Task parameter variables]: https://docs.databricks.com/jobs.html#parameter-variables
-    [dbutils.widgets.get]: https://docs.databricks.com/dev-tools/databricks-utils.html"""
-
-    performance_target: Optional[PerformanceTarget] = None
-    """The performance mode on a serverless job. The performance target determines the level of compute
-    performance or cost-efficiency for the run. This field overrides the performance target defined
-    on the job level.
-    
-    * `STANDARD`: Enables cost-efficient execution of serverless workloads. *
-    `PERFORMANCE_OPTIMIZED`: Prioritizes fast startup and execution times through rapid scaling and
-    optimized cluster performance."""
-
-    pipeline_params: Optional[PipelineParams] = None
-    """Controls whether the pipeline should perform a full refresh"""
-
-    python_named_params: Optional[Dict[str, str]] = None
-
-    python_params: Optional[List[str]] = None
-    """A list of parameters for jobs with Python tasks, for example `"python_params": ["john doe",
-    "35"]`. The parameters are passed to Python file as command-line parameters. If specified upon
-    `run-now`, it would overwrite the parameters specified in job setting. The JSON representation
-    of this field (for example `{"python_params":["john doe","35"]}`) cannot exceed 10,000 bytes.
-    
-    Use [Task parameter variables] to set parameters containing information about job runs.
-    
-    Important
-    
-    These parameters accept only Latin characters (ASCII character set). Using non-ASCII characters
-    returns an error. Examples of invalid, non-ASCII characters are Chinese, Japanese kanjis, and
-    emojis.
-    
-    [Task parameter variables]: https://docs.databricks.com/jobs.html#parameter-variables"""
-
-    rerun_all_failed_tasks: Optional[bool] = None
-    """If true, repair all failed tasks. Only one of `rerun_tasks` or `rerun_all_failed_tasks` can be
-    used."""
-
-    rerun_dependent_tasks: Optional[bool] = None
-    """If true, repair all tasks that depend on the tasks in `rerun_tasks`, even if they were
-    previously successful. Can be also used in combination with `rerun_all_failed_tasks`."""
-
-    rerun_tasks: Optional[List[str]] = None
-    """The task keys of the task runs to repair."""
-
-    spark_submit_params: Optional[List[str]] = None
-    """A list of parameters for jobs with spark submit task, for example `"spark_submit_params":
-    ["--class", "org.apache.spark.examples.SparkPi"]`. The parameters are passed to spark-submit
-    script as command-line parameters. If specified upon `run-now`, it would overwrite the
-    parameters specified in job setting. The JSON representation of this field (for example
-    `{"python_params":["john doe","35"]}`) cannot exceed 10,000 bytes.
-    
-    Use [Task parameter variables] to set parameters containing information about job runs
-    
-    Important
-    
-    These parameters accept only Latin characters (ASCII character set). Using non-ASCII characters
-    returns an error. Examples of invalid, non-ASCII characters are Chinese, Japanese kanjis, and
-    emojis.
-    
-    [Task parameter variables]: https://docs.databricks.com/jobs.html#parameter-variables"""
-
-    sql_params: Optional[Dict[str, str]] = None
-    """A map from keys to values for jobs with SQL task, for example `"sql_params": {"name": "john
-    doe", "age": "35"}`. The SQL alert task does not support custom parameters."""
-
-    def as_dict(self) -> dict:
-        """Serializes the RepairRun into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.dbt_commands:
-            body["dbt_commands"] = [v for v in self.dbt_commands]
-        if self.jar_params:
-            body["jar_params"] = [v for v in self.jar_params]
-        if self.job_parameters:
-            body["job_parameters"] = self.job_parameters
-        if self.latest_repair_id is not None:
-            body["latest_repair_id"] = self.latest_repair_id
-        if self.notebook_params:
-            body["notebook_params"] = self.notebook_params
-        if self.performance_target is not None:
-            body["performance_target"] = self.performance_target.value
-        if self.pipeline_params:
-            body["pipeline_params"] = self.pipeline_params.as_dict()
-        if self.python_named_params:
-            body["python_named_params"] = self.python_named_params
-        if self.python_params:
-            body["python_params"] = [v for v in self.python_params]
-        if self.rerun_all_failed_tasks is not None:
-            body["rerun_all_failed_tasks"] = self.rerun_all_failed_tasks
-        if self.rerun_dependent_tasks is not None:
-            body["rerun_dependent_tasks"] = self.rerun_dependent_tasks
-        if self.rerun_tasks:
-            body["rerun_tasks"] = [v for v in self.rerun_tasks]
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        if self.spark_submit_params:
-            body["spark_submit_params"] = [v for v in self.spark_submit_params]
-        if self.sql_params:
-            body["sql_params"] = self.sql_params
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the RepairRun into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.dbt_commands:
-            body["dbt_commands"] = self.dbt_commands
-        if self.jar_params:
-            body["jar_params"] = self.jar_params
-        if self.job_parameters:
-            body["job_parameters"] = self.job_parameters
-        if self.latest_repair_id is not None:
-            body["latest_repair_id"] = self.latest_repair_id
-        if self.notebook_params:
-            body["notebook_params"] = self.notebook_params
-        if self.performance_target is not None:
-            body["performance_target"] = self.performance_target
-        if self.pipeline_params:
-            body["pipeline_params"] = self.pipeline_params
-        if self.python_named_params:
-            body["python_named_params"] = self.python_named_params
-        if self.python_params:
-            body["python_params"] = self.python_params
-        if self.rerun_all_failed_tasks is not None:
-            body["rerun_all_failed_tasks"] = self.rerun_all_failed_tasks
-        if self.rerun_dependent_tasks is not None:
-            body["rerun_dependent_tasks"] = self.rerun_dependent_tasks
-        if self.rerun_tasks:
-            body["rerun_tasks"] = self.rerun_tasks
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        if self.spark_submit_params:
-            body["spark_submit_params"] = self.spark_submit_params
-        if self.sql_params:
-            body["sql_params"] = self.sql_params
+            body["status"] = self.status
+        if self.task_run_ids:
+            body["task_run_ids"] = self.task_run_ids
+        if self.type is not None:
+            body["type"] = self.type
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> RepairRun:
-        """Deserializes the RepairRun from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> RepairHistoryItem:
+        """Deserializes the RepairHistoryItem from a dictionary."""
         return cls(
-            dbt_commands=d.get("dbt_commands", None),
-            jar_params=d.get("jar_params", None),
-            job_parameters=d.get("job_parameters", None),
-            latest_repair_id=d.get("latest_repair_id", None),
-            notebook_params=d.get("notebook_params", None),
-            performance_target=_enum(d, "performance_target", PerformanceTarget),
-            pipeline_params=_from_dict(d, "pipeline_params", PipelineParams),
-            python_named_params=d.get("python_named_params", None),
-            python_params=d.get("python_params", None),
-            rerun_all_failed_tasks=d.get("rerun_all_failed_tasks", None),
-            rerun_dependent_tasks=d.get("rerun_dependent_tasks", None),
-            rerun_tasks=d.get("rerun_tasks", None),
-            run_id=d.get("run_id", None),
-            spark_submit_params=d.get("spark_submit_params", None),
-            sql_params=d.get("sql_params", None),
+            effective_performance_target=_enum(d, "effective_performance_target", PerformanceTarget),
+            end_time=d.get("end_time", None),
+            id=d.get("id", None),
+            start_time=d.get("start_time", None),
+            state=_from_dict(d, "state", RunState),
+            status=_from_dict(d, "status", RunStatus),
+            task_run_ids=d.get("task_run_ids", None),
+            type=_enum(d, "type", RepairHistoryItemType),
         )
 
 
+class RepairHistoryItemType(Enum):
+    """The repair history item type. Indicates whether a run is the original run or a repair run."""
+
+    ORIGINAL = "ORIGINAL"
+    REPAIR = "REPAIR"
+
+
 @dataclass
 class RepairRunResponse:
     """Run repair was initiated."""
@@ -4846,41 +4166,6 @@ class RepairRunResponse:
         return cls(repair_id=d.get("repair_id", None))
 
 
-@dataclass
-class ResetJob:
-    job_id: int
-    """The canonical identifier of the job to reset. This field is required."""
-
-    new_settings: JobSettings
-    """The new settings of the job. These settings completely replace the old settings.
-    
-    Changes to the field `JobBaseSettings.timeout_seconds` are applied to active runs. Changes to
-    other fields are applied to future runs only."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ResetJob into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.job_id is not None:
-            body["job_id"] = self.job_id
-        if self.new_settings:
-            body["new_settings"] = self.new_settings.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the ResetJob into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.job_id is not None:
-            body["job_id"] = self.job_id
-        if self.new_settings:
-            body["new_settings"] = self.new_settings
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> ResetJob:
-        """Deserializes the ResetJob from a dictionary."""
-        return cls(job_id=d.get("job_id", None), new_settings=_from_dict(d, "new_settings", JobSettings))
-
-
 @dataclass
 class ResetResponse:
     def as_dict(self) -> dict:
@@ -5292,11 +4577,6 @@ class Run:
     """The URL to the detail page of the run."""
 
     run_type: Optional[RunType] = None
-    """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]. * `SUBMIT_RUN`: Submit
-    run. A run created with :method:jobs/submit.
-    
-    [dbutils.notebook.run]: https://docs.databricks.com/dev-tools/databricks-utils.html#dbutils-workflow"""
 
     schedule: Optional[CronSchedule] = None
     """The cron schedule that triggered this run if it was triggered by the periodic scheduler."""
@@ -5317,7 +4597,6 @@ class Run:
     """Deprecated. Please use the `status` field instead."""
 
     status: Optional[RunStatus] = None
-    """The current status of the run"""
 
     tasks: Optional[List[RunTask]] = None
     """The list of tasks performed by the run. Each task has its own `run_id` which you can use to call
@@ -5326,19 +4605,8 @@ class Run:
     root to determine if more results are available."""
 
     trigger: Optional[TriggerType] = None
-    """The type of trigger that fired this run.
-    
-    * `PERIODIC`: Schedules that periodically trigger runs, such as a cron scheduler. * `ONE_TIME`:
-    One time triggers that fire a single run. This occurs you triggered a single run on demand
-    through the UI or the API. * `RETRY`: Indicates a run that is triggered as a retry of a
-    previously failed run. This occurs when you request to re-run the job in case of failures. *
-    `RUN_JOB_TASK`: Indicates a run that is triggered using a Run Job task. * `FILE_ARRIVAL`:
-    Indicates a run that is triggered by a file arrival. * `TABLE`: Indicates a run that is
-    triggered by a table update. * `CONTINUOUS_RESTART`: Indicates a run created by user to manually
-    restart a continuous job run."""
 
     trigger_info: Optional[TriggerInfo] = None
-    """Additional details about what triggered the run"""
 
     def as_dict(self) -> dict:
         """Serializes the Run into a dictionary suitable for use as a JSON request body."""
@@ -5697,206 +4965,7 @@ class RunJobTask:
 
     dbt_commands: Optional[List[str]] = None
     """An array of commands to execute for jobs with the dbt task, for example `"dbt_commands": ["dbt
-    deps", "dbt seed", "dbt deps", "dbt seed", "dbt run"]`"""
-
-    jar_params: Optional[List[str]] = None
-    """A list of parameters for jobs with Spark JAR tasks, for example `"jar_params": ["john doe",
-    "35"]`. The parameters are used to invoke the main function of the main class specified in the
-    Spark JAR task. If not specified upon `run-now`, it defaults to an empty list. jar_params cannot
-    be specified in conjunction with notebook_params. The JSON representation of this field (for
-    example `{"jar_params":["john doe","35"]}`) cannot exceed 10,000 bytes.
-    
-    Use [Task parameter variables] to set parameters containing information about job runs.
-    
-    [Task parameter variables]: https://docs.databricks.com/jobs.html#parameter-variables"""
-
-    job_parameters: Optional[Dict[str, str]] = None
-    """Job-level parameters used to trigger the job."""
-
-    notebook_params: Optional[Dict[str, str]] = None
-    """A map from keys to values for jobs with notebook task, for example `"notebook_params": {"name":
-    "john doe", "age": "35"}`. The map is passed to the notebook and is accessible through the
-    [dbutils.widgets.get] function.
-    
-    If not specified upon `run-now`, the triggered run uses the job’s base parameters.
-    
-    notebook_params cannot be specified in conjunction with jar_params.
-    
-    Use [Task parameter variables] to set parameters containing information about job runs.
-    
-    The JSON representation of this field (for example `{"notebook_params":{"name":"john
-    doe","age":"35"}}`) cannot exceed 10,000 bytes.
-    
-    [Task parameter variables]: https://docs.databricks.com/jobs.html#parameter-variables
-    [dbutils.widgets.get]: https://docs.databricks.com/dev-tools/databricks-utils.html"""
-
-    pipeline_params: Optional[PipelineParams] = None
-    """Controls whether the pipeline should perform a full refresh"""
-
-    python_named_params: Optional[Dict[str, str]] = None
-
-    python_params: Optional[List[str]] = None
-    """A list of parameters for jobs with Python tasks, for example `"python_params": ["john doe",
-    "35"]`. The parameters are passed to Python file as command-line parameters. If specified upon
-    `run-now`, it would overwrite the parameters specified in job setting. The JSON representation
-    of this field (for example `{"python_params":["john doe","35"]}`) cannot exceed 10,000 bytes.
-    
-    Use [Task parameter variables] to set parameters containing information about job runs.
-    
-    Important
-    
-    These parameters accept only Latin characters (ASCII character set). Using non-ASCII characters
-    returns an error. Examples of invalid, non-ASCII characters are Chinese, Japanese kanjis, and
-    emojis.
-    
-    [Task parameter variables]: https://docs.databricks.com/jobs.html#parameter-variables"""
-
-    spark_submit_params: Optional[List[str]] = None
-    """A list of parameters for jobs with spark submit task, for example `"spark_submit_params":
-    ["--class", "org.apache.spark.examples.SparkPi"]`. The parameters are passed to spark-submit
-    script as command-line parameters. If specified upon `run-now`, it would overwrite the
-    parameters specified in job setting. The JSON representation of this field (for example
-    `{"python_params":["john doe","35"]}`) cannot exceed 10,000 bytes.
-    
-    Use [Task parameter variables] to set parameters containing information about job runs
-    
-    Important
-    
-    These parameters accept only Latin characters (ASCII character set). Using non-ASCII characters
-    returns an error. Examples of invalid, non-ASCII characters are Chinese, Japanese kanjis, and
-    emojis.
-    
-    [Task parameter variables]: https://docs.databricks.com/jobs.html#parameter-variables"""
-
-    sql_params: Optional[Dict[str, str]] = None
-    """A map from keys to values for jobs with SQL task, for example `"sql_params": {"name": "john
-    doe", "age": "35"}`. The SQL alert task does not support custom parameters."""
-
-    def as_dict(self) -> dict:
-        """Serializes the RunJobTask into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.dbt_commands:
-            body["dbt_commands"] = [v for v in self.dbt_commands]
-        if self.jar_params:
-            body["jar_params"] = [v for v in self.jar_params]
-        if self.job_id is not None:
-            body["job_id"] = self.job_id
-        if self.job_parameters:
-            body["job_parameters"] = self.job_parameters
-        if self.notebook_params:
-            body["notebook_params"] = self.notebook_params
-        if self.pipeline_params:
-            body["pipeline_params"] = self.pipeline_params.as_dict()
-        if self.python_named_params:
-            body["python_named_params"] = self.python_named_params
-        if self.python_params:
-            body["python_params"] = [v for v in self.python_params]
-        if self.spark_submit_params:
-            body["spark_submit_params"] = [v for v in self.spark_submit_params]
-        if self.sql_params:
-            body["sql_params"] = self.sql_params
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the RunJobTask into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.dbt_commands:
-            body["dbt_commands"] = self.dbt_commands
-        if self.jar_params:
-            body["jar_params"] = self.jar_params
-        if self.job_id is not None:
-            body["job_id"] = self.job_id
-        if self.job_parameters:
-            body["job_parameters"] = self.job_parameters
-        if self.notebook_params:
-            body["notebook_params"] = self.notebook_params
-        if self.pipeline_params:
-            body["pipeline_params"] = self.pipeline_params
-        if self.python_named_params:
-            body["python_named_params"] = self.python_named_params
-        if self.python_params:
-            body["python_params"] = self.python_params
-        if self.spark_submit_params:
-            body["spark_submit_params"] = self.spark_submit_params
-        if self.sql_params:
-            body["sql_params"] = self.sql_params
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> RunJobTask:
-        """Deserializes the RunJobTask from a dictionary."""
-        return cls(
-            dbt_commands=d.get("dbt_commands", None),
-            jar_params=d.get("jar_params", None),
-            job_id=d.get("job_id", None),
-            job_parameters=d.get("job_parameters", None),
-            notebook_params=d.get("notebook_params", None),
-            pipeline_params=_from_dict(d, "pipeline_params", PipelineParams),
-            python_named_params=d.get("python_named_params", None),
-            python_params=d.get("python_params", None),
-            spark_submit_params=d.get("spark_submit_params", None),
-            sql_params=d.get("sql_params", None),
-        )
-
-
-class RunLifeCycleState(Enum):
-    """A value indicating the run's lifecycle state. The possible values are: * `QUEUED`: The run is
-    queued. * `PENDING`: The run is waiting to be executed while the cluster and execution context
-    are being prepared. * `RUNNING`: The task of this run is being executed. * `TERMINATING`: The
-    task of this run has completed, and the cluster and execution context are being cleaned up. *
-    `TERMINATED`: The task of this run has completed, and the cluster and execution context have
-    been cleaned up. This state is terminal. * `SKIPPED`: This run was aborted because a previous
-    run of the same job was already active. This state is terminal. * `INTERNAL_ERROR`: An
-    exceptional state that indicates a failure in the Jobs service, such as network failure over a
-    long period. If a run on a new cluster ends in the `INTERNAL_ERROR` state, the Jobs service
-    terminates the cluster as soon as possible. This state is terminal. * `BLOCKED`: The run is
-    blocked on an upstream dependency. * `WAITING_FOR_RETRY`: The run is waiting for a retry."""
-
-    BLOCKED = "BLOCKED"
-    INTERNAL_ERROR = "INTERNAL_ERROR"
-    PENDING = "PENDING"
-    QUEUED = "QUEUED"
-    RUNNING = "RUNNING"
-    SKIPPED = "SKIPPED"
-    TERMINATED = "TERMINATED"
-    TERMINATING = "TERMINATING"
-    WAITING_FOR_RETRY = "WAITING_FOR_RETRY"
-
-
-class RunLifecycleStateV2State(Enum):
-    """The current state of the run."""
-
-    BLOCKED = "BLOCKED"
-    PENDING = "PENDING"
-    QUEUED = "QUEUED"
-    RUNNING = "RUNNING"
-    TERMINATED = "TERMINATED"
-    TERMINATING = "TERMINATING"
-    WAITING = "WAITING"
-
-
-@dataclass
-class RunNow:
-    job_id: int
-    """The ID of the job to be executed"""
-
-    dbt_commands: Optional[List[str]] = None
-    """An array of commands to execute for jobs with the dbt task, for example `"dbt_commands": ["dbt
-    deps", "dbt seed", "dbt deps", "dbt seed", "dbt run"]`"""
-
-    idempotency_token: Optional[str] = None
-    """An optional token to guarantee the idempotency of job run requests. If a run with the provided
-    token already exists, the request does not create a new run but returns the ID of the existing
-    run instead. If a run with the provided token is deleted, an error is returned.
-    
-    If you specify the idempotency token, upon failure you can retry until the request succeeds.
-    Databricks guarantees that exactly one run is launched with that idempotency token.
-    
-    This token must have at most 64 characters.
-    
-    For more information, see [How to ensure idempotency for jobs].
-    
-    [How to ensure idempotency for jobs]: https://kb.databricks.com/jobs/jobs-idempotency.html"""
+    deps", "dbt seed", "dbt deps", "dbt seed", "dbt run"]`"""
 
     jar_params: Optional[List[str]] = None
     """A list of parameters for jobs with Spark JAR tasks, for example `"jar_params": ["john doe",
@@ -5910,7 +4979,7 @@ class RunNow:
     [Task parameter variables]: https://docs.databricks.com/jobs.html#parameter-variables"""
 
     job_parameters: Optional[Dict[str, str]] = None
-    """Job-level parameters used in the run. for example `"param": "overriding_val"`"""
+    """Job-level parameters used to trigger the job."""
 
     notebook_params: Optional[Dict[str, str]] = None
     """A map from keys to values for jobs with notebook task, for example `"notebook_params": {"name":
@@ -5929,19 +4998,6 @@ class RunNow:
     [Task parameter variables]: https://docs.databricks.com/jobs.html#parameter-variables
     [dbutils.widgets.get]: https://docs.databricks.com/dev-tools/databricks-utils.html"""
 
-    only: Optional[List[str]] = None
-    """A list of task keys to run inside of the job. If this field is not provided, all tasks in the
-    job will be run."""
-
-    performance_target: Optional[PerformanceTarget] = None
-    """The performance mode on a serverless job. The performance target determines the level of compute
-    performance or cost-efficiency for the run. This field overrides the performance target defined
-    on the job level.
-    
-    * `STANDARD`: Enables cost-efficient execution of serverless workloads. *
-    `PERFORMANCE_OPTIMIZED`: Prioritizes fast startup and execution times through rapid scaling and
-    optimized cluster performance."""
-
     pipeline_params: Optional[PipelineParams] = None
     """Controls whether the pipeline should perform a full refresh"""
 
@@ -5963,9 +5019,6 @@ class RunNow:
     
     [Task parameter variables]: https://docs.databricks.com/jobs.html#parameter-variables"""
 
-    queue: Optional[QueueSettings] = None
-    """The queue settings of the run."""
-
     spark_submit_params: Optional[List[str]] = None
     """A list of parameters for jobs with spark submit task, for example `"spark_submit_params":
     ["--class", "org.apache.spark.examples.SparkPi"]`. The parameters are passed to spark-submit
@@ -5988,12 +5041,10 @@ class RunNow:
     doe", "age": "35"}`. The SQL alert task does not support custom parameters."""
 
     def as_dict(self) -> dict:
-        """Serializes the RunNow into a dictionary suitable for use as a JSON request body."""
+        """Serializes the RunJobTask into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.dbt_commands:
             body["dbt_commands"] = [v for v in self.dbt_commands]
-        if self.idempotency_token is not None:
-            body["idempotency_token"] = self.idempotency_token
         if self.jar_params:
             body["jar_params"] = [v for v in self.jar_params]
         if self.job_id is not None:
@@ -6002,18 +5053,12 @@ class RunNow:
             body["job_parameters"] = self.job_parameters
         if self.notebook_params:
             body["notebook_params"] = self.notebook_params
-        if self.only:
-            body["only"] = [v for v in self.only]
-        if self.performance_target is not None:
-            body["performance_target"] = self.performance_target.value
         if self.pipeline_params:
             body["pipeline_params"] = self.pipeline_params.as_dict()
         if self.python_named_params:
             body["python_named_params"] = self.python_named_params
         if self.python_params:
             body["python_params"] = [v for v in self.python_params]
-        if self.queue:
-            body["queue"] = self.queue.as_dict()
         if self.spark_submit_params:
             body["spark_submit_params"] = [v for v in self.spark_submit_params]
         if self.sql_params:
@@ -6021,12 +5066,10 @@ class RunNow:
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the RunNow into a shallow dictionary of its immediate attributes."""
+        """Serializes the RunJobTask into a shallow dictionary of its immediate attributes."""
         body = {}
         if self.dbt_commands:
             body["dbt_commands"] = self.dbt_commands
-        if self.idempotency_token is not None:
-            body["idempotency_token"] = self.idempotency_token
         if self.jar_params:
             body["jar_params"] = self.jar_params
         if self.job_id is not None:
@@ -6035,18 +5078,12 @@ class RunNow:
             body["job_parameters"] = self.job_parameters
         if self.notebook_params:
             body["notebook_params"] = self.notebook_params
-        if self.only:
-            body["only"] = self.only
-        if self.performance_target is not None:
-            body["performance_target"] = self.performance_target
         if self.pipeline_params:
             body["pipeline_params"] = self.pipeline_params
         if self.python_named_params:
             body["python_named_params"] = self.python_named_params
         if self.python_params:
             body["python_params"] = self.python_params
-        if self.queue:
-            body["queue"] = self.queue
         if self.spark_submit_params:
             body["spark_submit_params"] = self.spark_submit_params
         if self.sql_params:
@@ -6054,26 +5091,58 @@ class RunNow:
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> RunNow:
-        """Deserializes the RunNow from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> RunJobTask:
+        """Deserializes the RunJobTask from a dictionary."""
         return cls(
             dbt_commands=d.get("dbt_commands", None),
-            idempotency_token=d.get("idempotency_token", None),
             jar_params=d.get("jar_params", None),
             job_id=d.get("job_id", None),
             job_parameters=d.get("job_parameters", None),
             notebook_params=d.get("notebook_params", None),
-            only=d.get("only", None),
-            performance_target=_enum(d, "performance_target", PerformanceTarget),
             pipeline_params=_from_dict(d, "pipeline_params", PipelineParams),
             python_named_params=d.get("python_named_params", None),
             python_params=d.get("python_params", None),
-            queue=_from_dict(d, "queue", QueueSettings),
             spark_submit_params=d.get("spark_submit_params", None),
             sql_params=d.get("sql_params", None),
         )
 
 
+class RunLifeCycleState(Enum):
+    """A value indicating the run's lifecycle state. The possible values are: * `QUEUED`: The run is
+    queued. * `PENDING`: The run is waiting to be executed while the cluster and execution context
+    are being prepared. * `RUNNING`: The task of this run is being executed. * `TERMINATING`: The
+    task of this run has completed, and the cluster and execution context are being cleaned up. *
+    `TERMINATED`: The task of this run has completed, and the cluster and execution context have
+    been cleaned up. This state is terminal. * `SKIPPED`: This run was aborted because a previous
+    run of the same job was already active. This state is terminal. * `INTERNAL_ERROR`: An
+    exceptional state that indicates a failure in the Jobs service, such as network failure over a
+    long period. If a run on a new cluster ends in the `INTERNAL_ERROR` state, the Jobs service
+    terminates the cluster as soon as possible. This state is terminal. * `BLOCKED`: The run is
+    blocked on an upstream dependency. * `WAITING_FOR_RETRY`: The run is waiting for a retry."""
+
+    BLOCKED = "BLOCKED"
+    INTERNAL_ERROR = "INTERNAL_ERROR"
+    PENDING = "PENDING"
+    QUEUED = "QUEUED"
+    RUNNING = "RUNNING"
+    SKIPPED = "SKIPPED"
+    TERMINATED = "TERMINATED"
+    TERMINATING = "TERMINATING"
+    WAITING_FOR_RETRY = "WAITING_FOR_RETRY"
+
+
+class RunLifecycleStateV2State(Enum):
+    """The current state of the run."""
+
+    BLOCKED = "BLOCKED"
+    PENDING = "PENDING"
+    QUEUED = "QUEUED"
+    RUNNING = "RUNNING"
+    TERMINATED = "TERMINATED"
+    TERMINATING = "TERMINATING"
+    WAITING = "WAITING"
+
+
 @dataclass
 class RunNowResponse:
     """Run was started successfully."""
@@ -6482,7 +5551,6 @@ class RunStatus:
     """If the run was queued, details about the reason for queuing the run."""
 
     state: Optional[RunLifecycleStateV2State] = None
-    """The current state of the run."""
 
     termination_details: Optional[TerminationDetails] = None
     """If the run is in a TERMINATING or TERMINATED state, details about the reason for terminating the
@@ -6719,7 +5787,6 @@ class RunTask:
     """Deprecated. Please use the `status` field instead."""
 
     status: Optional[RunStatus] = None
-    """The current status of the run"""
 
     timeout_seconds: Optional[int] = None
     """An optional timeout applied to each run of this job task. A value of `0` means no timeout."""
@@ -7154,10 +6221,6 @@ class SparkSubmitTask:
 @dataclass
 class SqlAlertOutput:
     alert_state: Optional[SqlAlertState] = None
-    """The state of the SQL alert.
-    
-    * UNKNOWN: alert yet to be evaluated * OK: alert evaluated and did not fulfill trigger
-    conditions * TRIGGERED: alert evaluated and fulfilled trigger conditions"""
 
     output_link: Optional[str] = None
     """The link to find the output results."""
@@ -7764,157 +6827,6 @@ class StorageMode(Enum):
     IMPORT = "IMPORT"
 
 
-@dataclass
-class SubmitRun:
-    access_control_list: Optional[List[JobAccessControlRequest]] = None
-    """List of permissions to set on the job."""
-
-    budget_policy_id: Optional[str] = None
-    """The user specified id of the budget policy to use for this one-time run. If not specified, the
-    run will be not be attributed to any budget policy."""
-
-    email_notifications: Optional[JobEmailNotifications] = None
-    """An optional set of email addresses notified when the run begins or completes."""
-
-    environments: Optional[List[JobEnvironment]] = None
-    """A list of task execution environment specifications that can be referenced by tasks of this run."""
-
-    git_source: Optional[GitSource] = None
-    """An optional specification for a remote Git repository containing the source code used by tasks.
-    Version-controlled source code is supported by notebook, dbt, Python script, and SQL File tasks.
-    
-    If `git_source` is set, these tasks retrieve the file from the remote repository by default.
-    However, this behavior can be overridden by setting `source` to `WORKSPACE` on the task.
-    
-    Note: dbt and SQL File tasks support only version-controlled sources. If dbt or SQL File tasks
-    are used, `git_source` must be defined on the job."""
-
-    health: Optional[JobsHealthRules] = None
-    """An optional set of health rules that can be defined for this job."""
-
-    idempotency_token: Optional[str] = None
-    """An optional token that can be used to guarantee the idempotency of job run requests. If a run
-    with the provided token already exists, the request does not create a new run but returns the ID
-    of the existing run instead. If a run with the provided token is deleted, an error is returned.
-    
-    If you specify the idempotency token, upon failure you can retry until the request succeeds.
-    Databricks guarantees that exactly one run is launched with that idempotency token.
-    
-    This token must have at most 64 characters.
-    
-    For more information, see [How to ensure idempotency for jobs].
-    
-    [How to ensure idempotency for jobs]: https://kb.databricks.com/jobs/jobs-idempotency.html"""
-
-    notification_settings: Optional[JobNotificationSettings] = None
-    """Optional notification settings that are used when sending notifications to each of the
-    `email_notifications` and `webhook_notifications` for this run."""
-
-    queue: Optional[QueueSettings] = None
-    """The queue settings of the one-time run."""
-
-    run_as: Optional[JobRunAs] = None
-    """Specifies the user or service principal that the job runs as. If not specified, the job runs as
-    the user who submits the request."""
-
-    run_name: Optional[str] = None
-    """An optional name for the run. The default value is `Untitled`."""
-
-    tasks: Optional[List[SubmitTask]] = None
-
-    timeout_seconds: Optional[int] = None
-    """An optional timeout applied to each run of this job. A value of `0` means no timeout."""
-
-    webhook_notifications: Optional[WebhookNotifications] = None
-    """A collection of system notification IDs to notify when the run begins or completes."""
-
-    def as_dict(self) -> dict:
-        """Serializes the SubmitRun into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = [v.as_dict() for v in self.access_control_list]
-        if self.budget_policy_id is not None:
-            body["budget_policy_id"] = self.budget_policy_id
-        if self.email_notifications:
-            body["email_notifications"] = self.email_notifications.as_dict()
-        if self.environments:
-            body["environments"] = [v.as_dict() for v in self.environments]
-        if self.git_source:
-            body["git_source"] = self.git_source.as_dict()
-        if self.health:
-            body["health"] = self.health.as_dict()
-        if self.idempotency_token is not None:
-            body["idempotency_token"] = self.idempotency_token
-        if self.notification_settings:
-            body["notification_settings"] = self.notification_settings.as_dict()
-        if self.queue:
-            body["queue"] = self.queue.as_dict()
-        if self.run_as:
-            body["run_as"] = self.run_as.as_dict()
-        if self.run_name is not None:
-            body["run_name"] = self.run_name
-        if self.tasks:
-            body["tasks"] = [v.as_dict() for v in self.tasks]
-        if self.timeout_seconds is not None:
-            body["timeout_seconds"] = self.timeout_seconds
-        if self.webhook_notifications:
-            body["webhook_notifications"] = self.webhook_notifications.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the SubmitRun into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = self.access_control_list
-        if self.budget_policy_id is not None:
-            body["budget_policy_id"] = self.budget_policy_id
-        if self.email_notifications:
-            body["email_notifications"] = self.email_notifications
-        if self.environments:
-            body["environments"] = self.environments
-        if self.git_source:
-            body["git_source"] = self.git_source
-        if self.health:
-            body["health"] = self.health
-        if self.idempotency_token is not None:
-            body["idempotency_token"] = self.idempotency_token
-        if self.notification_settings:
-            body["notification_settings"] = self.notification_settings
-        if self.queue:
-            body["queue"] = self.queue
-        if self.run_as:
-            body["run_as"] = self.run_as
-        if self.run_name is not None:
-            body["run_name"] = self.run_name
-        if self.tasks:
-            body["tasks"] = self.tasks
-        if self.timeout_seconds is not None:
-            body["timeout_seconds"] = self.timeout_seconds
-        if self.webhook_notifications:
-            body["webhook_notifications"] = self.webhook_notifications
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> SubmitRun:
-        """Deserializes the SubmitRun from a dictionary."""
-        return cls(
-            access_control_list=_repeated_dict(d, "access_control_list", JobAccessControlRequest),
-            budget_policy_id=d.get("budget_policy_id", None),
-            email_notifications=_from_dict(d, "email_notifications", JobEmailNotifications),
-            environments=_repeated_dict(d, "environments", JobEnvironment),
-            git_source=_from_dict(d, "git_source", GitSource),
-            health=_from_dict(d, "health", JobsHealthRules),
-            idempotency_token=d.get("idempotency_token", None),
-            notification_settings=_from_dict(d, "notification_settings", JobNotificationSettings),
-            queue=_from_dict(d, "queue", QueueSettings),
-            run_as=_from_dict(d, "run_as", JobRunAs),
-            run_name=d.get("run_name", None),
-            tasks=_repeated_dict(d, "tasks", SubmitTask),
-            timeout_seconds=d.get("timeout_seconds", None),
-            webhook_notifications=_from_dict(d, "webhook_notifications", WebhookNotifications),
-        )
-
-
 @dataclass
 class SubmitRunResponse:
     """Run was created and started successfully."""
@@ -7999,7 +6911,6 @@ class SubmitTask:
     gen_ai_compute_task: Optional[GenAiComputeTask] = None
 
     health: Optional[JobsHealthRules] = None
-    """An optional set of health rules that can be defined for this job."""
 
     libraries: Optional[List[compute.Library]] = None
     """An optional list of libraries to be installed on the cluster. The default value is an empty
@@ -8428,7 +7339,6 @@ class Task:
     gen_ai_compute_task: Optional[GenAiComputeTask] = None
 
     health: Optional[JobsHealthRules] = None
-    """An optional set of health rules that can be defined for this job."""
 
     job_cluster_key: Optional[str] = None
     """If job_cluster_key, this task is executed reusing the cluster specified in
@@ -8940,55 +7850,12 @@ class TerminationCodeCode(Enum):
 @dataclass
 class TerminationDetails:
     code: Optional[TerminationCodeCode] = None
-    """The code indicates why the run was terminated. Additional codes might be introduced in future
-    releases. * `SUCCESS`: The run was completed successfully. * `SUCCESS_WITH_FAILURES`: The run
-    was completed successfully but some child runs failed. * `USER_CANCELED`: The run was
-    successfully canceled during execution by a user. * `CANCELED`: The run was canceled during
-    execution by the Databricks platform; for example, if the maximum run duration was exceeded. *
-    `SKIPPED`: Run was never executed, for example, if the upstream task run failed, the dependency
-    type condition was not met, or there were no material tasks to execute. * `INTERNAL_ERROR`: The
-    run encountered an unexpected error. Refer to the state message for further details. *
-    `DRIVER_ERROR`: The run encountered an error while communicating with the Spark Driver. *
-    `CLUSTER_ERROR`: The run failed due to a cluster error. Refer to the state message for further
-    details. * `REPOSITORY_CHECKOUT_FAILED`: Failed to complete the checkout due to an error when
-    communicating with the third party service. * `INVALID_CLUSTER_REQUEST`: The run failed because
-    it issued an invalid request to start the cluster. * `WORKSPACE_RUN_LIMIT_EXCEEDED`: The
-    workspace has reached the quota for the maximum number of concurrent active runs. Consider
-    scheduling the runs over a larger time frame. * `FEATURE_DISABLED`: The run failed because it
-    tried to access a feature unavailable for the workspace. * `CLUSTER_REQUEST_LIMIT_EXCEEDED`: The
-    number of cluster creation, start, and upsize requests have exceeded the allotted rate limit.
-    Consider spreading the run execution over a larger time frame. * `STORAGE_ACCESS_ERROR`: The run
-    failed due to an error when accessing the customer blob storage. Refer to the state message for
-    further details. * `RUN_EXECUTION_ERROR`: The run was completed with task failures. For more
-    details, refer to the state message or run output. * `UNAUTHORIZED_ERROR`: The run failed due to
-    a permission issue while accessing a resource. Refer to the state message for further details. *
-    `LIBRARY_INSTALLATION_ERROR`: The run failed while installing the user-requested library. Refer
-    to the state message for further details. The causes might include, but are not limited to: The
-    provided library is invalid, there are insufficient permissions to install the library, and so
-    forth. * `MAX_CONCURRENT_RUNS_EXCEEDED`: The scheduled run exceeds the limit of maximum
-    concurrent runs set for the job. * `MAX_SPARK_CONTEXTS_EXCEEDED`: The run is scheduled on a
-    cluster that has already reached the maximum number of contexts it is configured to create. See:
-    [Link]. * `RESOURCE_NOT_FOUND`: A resource necessary for run execution does not exist. Refer to
-    the state message for further details. * `INVALID_RUN_CONFIGURATION`: The run failed due to an
-    invalid configuration. Refer to the state message for further details. * `CLOUD_FAILURE`: The
-    run failed due to a cloud provider issue. Refer to the state message for further details. *
-    `MAX_JOB_QUEUE_SIZE_EXCEEDED`: The run was skipped due to reaching the job level queue size
-    limit. * `DISABLED`: The run was never executed because it was disabled explicitly by the user.
-    
-    [Link]: https://kb.databricks.com/en_US/notebooks/too-many-execution-contexts-are-open-right-now"""
 
     message: Optional[str] = None
     """A descriptive message with the termination details. This field is unstructured and the format
     might change."""
 
     type: Optional[TerminationTypeType] = None
-    """* `SUCCESS`: The run terminated without any issues * `INTERNAL_ERROR`: An error occurred in the
-    Databricks platform. Please look at the [status page] 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.
-    
-    [status page]: https://status.databricks.com/"""
 
     def as_dict(self) -> dict:
         """Serializes the TerminationDetails into a dictionary suitable for use as a JSON request body."""
@@ -9154,10 +8021,13 @@ class TriggerType(Enum):
     through the UI or the API. * `RETRY`: Indicates a run that is triggered as a retry of a
     previously failed run. This occurs when you request to re-run the job in case of failures. *
     `RUN_JOB_TASK`: Indicates a run that is triggered using a Run Job task. * `FILE_ARRIVAL`:
-    Indicates a run that is triggered by a file arrival. * `TABLE`: Indicates a run that is
-    triggered by a table update. * `CONTINUOUS_RESTART`: Indicates a run created by user to manually
-    restart a continuous job run."""
+    Indicates a run that is triggered by a file arrival. * `CONTINUOUS`: Indicates a run that is
+    triggered by a continuous job. * `TABLE`: Indicates a run that is triggered by a table update. *
+    `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."""
 
+    CONTINUOUS = "CONTINUOUS"
+    CONTINUOUS_RESTART = "CONTINUOUS_RESTART"
     FILE_ARRIVAL = "FILE_ARRIVAL"
     ONE_TIME = "ONE_TIME"
     PERIODIC = "PERIODIC"
@@ -9166,59 +8036,6 @@ class TriggerType(Enum):
     TABLE = "TABLE"
 
 
-@dataclass
-class UpdateJob:
-    job_id: int
-    """The canonical identifier of the job to update. This field is required."""
-
-    fields_to_remove: Optional[List[str]] = None
-    """Remove top-level fields in the job settings. Removing nested fields is not supported, except for
-    tasks and job clusters (`tasks/task_1`). This field is optional."""
-
-    new_settings: Optional[JobSettings] = None
-    """The new settings for the job.
-    
-    Top-level fields specified in `new_settings` are completely replaced, except for arrays which
-    are merged. That is, new and existing entries are completely replaced based on the respective
-    key fields, i.e. `task_key` or `job_cluster_key`, while previous entries are kept.
-    
-    Partially updating nested fields is not supported.
-    
-    Changes to the field `JobSettings.timeout_seconds` are applied to active runs. Changes to other
-    fields are applied to future runs only."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateJob into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.fields_to_remove:
-            body["fields_to_remove"] = [v for v in self.fields_to_remove]
-        if self.job_id is not None:
-            body["job_id"] = self.job_id
-        if self.new_settings:
-            body["new_settings"] = self.new_settings.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateJob into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.fields_to_remove:
-            body["fields_to_remove"] = self.fields_to_remove
-        if self.job_id is not None:
-            body["job_id"] = self.job_id
-        if self.new_settings:
-            body["new_settings"] = self.new_settings
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateJob:
-        """Deserializes the UpdateJob from a dictionary."""
-        return cls(
-            fields_to_remove=d.get("fields_to_remove", None),
-            job_id=d.get("job_id", None),
-            new_settings=_from_dict(d, "new_settings", JobSettings),
-        )
-
-
 @dataclass
 class UpdateResponse:
     def as_dict(self) -> dict:
@@ -9587,7 +8404,6 @@ class JobsAPI:
           Note: dbt and SQL File tasks support only version-controlled sources. If dbt or SQL File tasks are
           used, `git_source` must be defined on the job.
         :param health: :class:`JobsHealthRules` (optional)
-          An optional set of health rules that can be defined for this job.
         :param job_clusters: List[:class:`JobCluster`] (optional)
           A list of job cluster specifications that can be shared and reused by tasks of this job. Libraries
           cannot be declared in a shared job cluster. You must declare dependent libraries in task settings.
@@ -9617,10 +8433,9 @@ class JobsAPI:
         :param queue: :class:`QueueSettings` (optional)
           The queue settings of the job.
         :param run_as: :class:`JobRunAs` (optional)
-          Write-only setting. Specifies the user or service principal that the job runs as. If not specified,
-          the job runs as the user who created the job.
-
-          Either `user_name` or `service_principal_name` should be specified. If not, an error is thrown.
+          The user or service principal that the job runs as, if specified in the request. This field
+          indicates the explicit configuration of `run_as` for the job. To find the value in all cases,
+          explicit or implicit, use `run_as_user_name`.
         :param schedule: :class:`CronSchedule` (optional)
           An optional periodic schedule for this job. The default behavior is that the job only runs when
           triggered by clicking “Run Now” in the Jobs UI or sending an API request to `runNow`.
@@ -10515,7 +9330,6 @@ class JobsAPI:
           Note: dbt and SQL File tasks support only version-controlled sources. If dbt or SQL File tasks are
           used, `git_source` must be defined on the job.
         :param health: :class:`JobsHealthRules` (optional)
-          An optional set of health rules that can be defined for this job.
         :param idempotency_token: str (optional)
           An optional token that can be used to guarantee the idempotency of job run requests. If a run with
           the provided token already exists, the request does not create a new run but returns the ID of the