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

databricks/sdk/service/jobs.py

@@ -432,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:
@@ -483,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:
@@ -932,267 +874,7 @@ class Continuous:
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> Continuous:
         """Deserializes the Continuous from a dictionary."""
-        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
-
-    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
-
-    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),
-        )
+        return cls(pause_status=_enum(d, "pause_status", PauseStatus))
 
 
 @dataclass
@@ -1803,31 +1485,6 @@ class DbtTask:
         )
 
 
-@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
 class DeleteResponse:
     def as_dict(self) -> dict:
@@ -1846,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:
@@ -1937,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
@@ -3283,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
@@ -3443,6 +3009,9 @@ class JobSettings:
     """The queue settings of the job."""
 
     run_as: Optional[JobRunAs] = None
+    """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
@@ -4533,240 +4102,42 @@ class RepairHistoryItem:
             body["effective_performance_target"] = self.effective_performance_target
         if self.end_time is not None:
             body["end_time"] = self.end_time
-        if self.id is not None:
-            body["id"] = self.id
-        if self.start_time is not None:
-            body["start_time"] = self.start_time
-        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
+        if self.id is not None:
+            body["id"] = self.id
+        if self.start_time is not None:
+            body["start_time"] = self.start_time
+        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]) -> 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."""
@@ -4795,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:
@@ -5587,249 +4923,50 @@ class RunIf(Enum):
     `AT_LEAST_ONE_SUCCESS`: At least one dependency has succeeded * `NONE_FAILED`: None of the
     dependencies have failed and at least one was executed * `ALL_DONE`: All dependencies have been
     completed * `AT_LEAST_ONE_FAILED`: At least one dependency failed * `ALL_FAILED`: ALl
-    dependencies have failed"""
-
-    ALL_DONE = "ALL_DONE"
-    ALL_FAILED = "ALL_FAILED"
-    ALL_SUCCESS = "ALL_SUCCESS"
-    AT_LEAST_ONE_FAILED = "AT_LEAST_ONE_FAILED"
-    AT_LEAST_ONE_SUCCESS = "AT_LEAST_ONE_SUCCESS"
-    NONE_FAILED = "NONE_FAILED"
-
-
-@dataclass
-class RunJobOutput:
-    run_id: Optional[int] = None
-    """The run id of the triggered job run"""
-
-    def as_dict(self) -> dict:
-        """Serializes the RunJobOutput 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 RunJobOutput 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]) -> RunJobOutput:
-        """Deserializes the RunJobOutput from a dictionary."""
-        return cls(run_id=d.get("run_id", None))
-
-
-@dataclass
-class RunJobTask:
-    job_id: int
-    """ID of the job to trigger."""
-
-    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."""
+    dependencies have failed"""
 
-    BLOCKED = "BLOCKED"
-    INTERNAL_ERROR = "INTERNAL_ERROR"
-    PENDING = "PENDING"
-    QUEUED = "QUEUED"
-    RUNNING = "RUNNING"
-    SKIPPED = "SKIPPED"
-    TERMINATED = "TERMINATED"
-    TERMINATING = "TERMINATING"
-    WAITING_FOR_RETRY = "WAITING_FOR_RETRY"
+    ALL_DONE = "ALL_DONE"
+    ALL_FAILED = "ALL_FAILED"
+    ALL_SUCCESS = "ALL_SUCCESS"
+    AT_LEAST_ONE_FAILED = "AT_LEAST_ONE_FAILED"
+    AT_LEAST_ONE_SUCCESS = "AT_LEAST_ONE_SUCCESS"
+    NONE_FAILED = "NONE_FAILED"
 
 
-class RunLifecycleStateV2State(Enum):
-    """The current state of the run."""
+@dataclass
+class RunJobOutput:
+    run_id: Optional[int] = None
+    """The run id of the triggered job run"""
 
-    BLOCKED = "BLOCKED"
-    PENDING = "PENDING"
-    QUEUED = "QUEUED"
-    RUNNING = "RUNNING"
-    TERMINATED = "TERMINATED"
-    TERMINATING = "TERMINATING"
-    WAITING = "WAITING"
+    def as_dict(self) -> dict:
+        """Serializes the RunJobOutput 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 RunJobOutput 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]) -> RunJobOutput:
+        """Deserializes the RunJobOutput from a dictionary."""
+        return cls(run_id=d.get("run_id", None))
 
 
 @dataclass
-class RunNow:
+class RunJobTask:
     job_id: int
-    """The ID of the job to be executed"""
+    """ID of the job to trigger."""
 
     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"""
-
     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
@@ -5842,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":
@@ -5861,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"""
 
@@ -5895,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
@@ -5920,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:
@@ -5934,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:
@@ -5953,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:
@@ -5967,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:
@@ -5986,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."""
@@ -7690,156 +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
-
-    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."""
@@ -9049,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:
@@ -9499,6 +8433,9 @@ class JobsAPI:
         :param queue: :class:`QueueSettings` (optional)
           The queue settings of the job.
         :param run_as: :class:`JobRunAs` (optional)
+          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`.