databricks-sdk 0.49.0__py3-none-any.whl → 0.51.0__py3-none-any.whl

databricks/sdk/service/jobs.py

@@ -21,6 +21,12 @@ from databricks.sdk.service import compute
 # all definitions in this file are in alphabetical order
 
 
+class AuthenticationMethod(Enum):
+
+    OAUTH = "OAUTH"
+    PAT = "PAT"
+
+
 @dataclass
 class BaseJob:
     created_time: Optional[int] = None
@@ -37,9 +43,9 @@ class BaseJob:
     on accessible budget policies of the run_as identity on job creation or modification."""
 
     has_more: Optional[bool] = None
-    """Indicates if the job has more sub-resources (`tasks`, `job_clusters`) that are not shown. They
-    can be accessed via :method:jobs/get endpoint. It is only relevant for API 2.2 :method:jobs/list
-    requests with `expand_tasks=true`."""
+    """Indicates if the job has more array properties (`tasks`, `job_clusters`) that are not shown.
+    They can be accessed via :method:jobs/get endpoint. It is only relevant for API 2.2
+    :method:jobs/list requests with `expand_tasks=true`."""
 
     job_id: Optional[int] = None
     """The canonical identifier for this job."""
@@ -125,9 +131,13 @@ class BaseRun:
     """Description of the run"""
 
     effective_performance_target: Optional[PerformanceTarget] = None
-    """effective_performance_target is the actual performance target used by the run during execution.
-    effective_performance_target can differ from the client-set performance_target depending on if
-    the job was eligible to be cost-optimized."""
+    """The actual performance target used by the serverless run during execution. This can differ from
+    the client-set performance target on the request depending on whether the performance mode is
+    supported by the job type.
+    
+    * `STANDARD`: Enables cost-efficient execution of serverless workloads. *
+    `PERFORMANCE_OPTIMIZED`: Prioritizes fast startup and execution times through rapid scaling and
+    optimized cluster performance."""
 
     end_time: Optional[int] = None
     """The time at which this run ended in epoch milliseconds (milliseconds since 1/1/1970 UTC). This
@@ -151,8 +161,8 @@ class BaseRun:
     are used, `git_source` must be defined on the job."""
 
     has_more: Optional[bool] = None
-    """Indicates if the run has more sub-resources (`tasks`, `job_clusters`) that are not shown. They
-    can be accessed via :method:jobs/getrun endpoint. It is only relevant for API 2.2
+    """Indicates if the run has more array properties (`tasks`, `job_clusters`) that are not shown.
+    They can be accessed via :method:jobs/getrun endpoint. It is only relevant for API 2.2
     :method:jobs/listruns requests with `expand_tasks=true`."""
 
     job_clusters: Optional[List[JobCluster]] = None
@@ -566,10 +576,11 @@ class CleanRoomTaskRunState:
 
     life_cycle_state: Optional[CleanRoomTaskRunLifeCycleState] = None
     """A value indicating the run's current lifecycle state. This field is always available in the
-    response."""
+    response. Note: Additional states might be introduced in future releases."""
 
     result_state: Optional[CleanRoomTaskRunResultState] = None
-    """A value indicating the run's result. This field is only available for terminal lifecycle states."""
+    """A value indicating the run's result. This field is only available for terminal lifecycle states.
+    Note: Additional states might be introduced in future releases."""
 
     def as_dict(self) -> dict:
         """Serializes the CleanRoomTaskRunState into a dictionary suitable for use as a JSON request body."""
@@ -793,8 +804,6 @@ class ClusterSpec:
 
 @dataclass
 class ComputeConfig:
-    """Next field: 4"""
-
     num_gpus: int
     """Number of GPUs."""
 
@@ -992,8 +1001,7 @@ class CreateJob:
     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. If more than 100 job clusters are available, you can paginate through them using
-    :method:jobs/get."""
+    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
@@ -1016,8 +1024,12 @@ class CreateJob:
     """Job-level parameter definitions"""
 
     performance_target: Optional[PerformanceTarget] = None
-    """PerformanceTarget defines how performant or cost efficient the execution of run on serverless
-    should be."""
+    """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."""
@@ -1038,9 +1050,11 @@ class CreateJob:
     be added to the job."""
 
     tasks: Optional[List[Task]] = None
-    """A list of task specifications to be executed by this job. 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."""
+    """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."""
@@ -1271,6 +1285,110 @@ class CronSchedule:
         )
 
 
+@dataclass
+class DashboardPageSnapshot:
+    page_display_name: Optional[str] = None
+
+    widget_error_details: Optional[List[WidgetErrorDetail]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the DashboardPageSnapshot into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.page_display_name is not None:
+            body["page_display_name"] = self.page_display_name
+        if self.widget_error_details:
+            body["widget_error_details"] = [v.as_dict() for v in self.widget_error_details]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DashboardPageSnapshot into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.page_display_name is not None:
+            body["page_display_name"] = self.page_display_name
+        if self.widget_error_details:
+            body["widget_error_details"] = self.widget_error_details
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> DashboardPageSnapshot:
+        """Deserializes the DashboardPageSnapshot from a dictionary."""
+        return cls(
+            page_display_name=d.get("page_display_name", None),
+            widget_error_details=_repeated_dict(d, "widget_error_details", WidgetErrorDetail),
+        )
+
+
+@dataclass
+class DashboardTask:
+    """Configures the Lakeview Dashboard job task type."""
+
+    dashboard_id: Optional[str] = None
+    """The identifier of the dashboard to refresh."""
+
+    subscription: Optional[Subscription] = None
+    """Optional: subscription configuration for sending the dashboard snapshot."""
+
+    warehouse_id: Optional[str] = None
+    """Optional: The warehouse id to execute the dashboard with for the schedule. If not specified, the
+    default warehouse of the dashboard will be used."""
+
+    def as_dict(self) -> dict:
+        """Serializes the DashboardTask into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.dashboard_id is not None:
+            body["dashboard_id"] = self.dashboard_id
+        if self.subscription:
+            body["subscription"] = self.subscription.as_dict()
+        if self.warehouse_id is not None:
+            body["warehouse_id"] = self.warehouse_id
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DashboardTask into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.dashboard_id is not None:
+            body["dashboard_id"] = self.dashboard_id
+        if self.subscription:
+            body["subscription"] = self.subscription
+        if self.warehouse_id is not None:
+            body["warehouse_id"] = self.warehouse_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> DashboardTask:
+        """Deserializes the DashboardTask from a dictionary."""
+        return cls(
+            dashboard_id=d.get("dashboard_id", None),
+            subscription=_from_dict(d, "subscription", Subscription),
+            warehouse_id=d.get("warehouse_id", None),
+        )
+
+
+@dataclass
+class DashboardTaskOutput:
+    page_snapshots: Optional[List[DashboardPageSnapshot]] = None
+    """Should only be populated for manual PDF download jobs."""
+
+    def as_dict(self) -> dict:
+        """Serializes the DashboardTaskOutput into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.page_snapshots:
+            body["page_snapshots"] = [v.as_dict() for v in self.page_snapshots]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DashboardTaskOutput into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.page_snapshots:
+            body["page_snapshots"] = self.page_snapshots
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> DashboardTaskOutput:
+        """Deserializes the DashboardTaskOutput from a dictionary."""
+        return cls(page_snapshots=_repeated_dict(d, "page_snapshots", DashboardPageSnapshot))
+
+
 @dataclass
 class DbtOutput:
     artifacts_headers: Optional[Dict[str, str]] = None
@@ -1881,8 +1999,6 @@ class Format(Enum):
 
 @dataclass
 class GenAiComputeTask:
-    """Next field: 9"""
-
     dl_runtime_image: str
     """Runtime image"""
 
@@ -1890,7 +2006,6 @@ class GenAiComputeTask:
     """Command launcher to run the actual script, e.g. bash, python etc."""
 
     compute: Optional[ComputeConfig] = None
-    """Next field: 4"""
 
     mlflow_experiment_name: Optional[str] = None
     """Optional string containing the name of the MLflow experiment to log the run to. If name is not
@@ -2183,15 +2298,15 @@ class Job:
     on accessible budget policies of the run_as identity on job creation or modification."""
 
     has_more: Optional[bool] = None
-    """Indicates if the job has more sub-resources (`tasks`, `job_clusters`) that are not shown. They
-    can be accessed via :method:jobs/get endpoint. It is only relevant for API 2.2 :method:jobs/list
-    requests with `expand_tasks=true`."""
+    """Indicates if the job has more array properties (`tasks`, `job_clusters`) that are not shown.
+    They can be accessed via :method:jobs/get endpoint. It is only relevant for API 2.2
+    :method:jobs/list requests with `expand_tasks=true`."""
 
     job_id: Optional[int] = None
     """The canonical identifier for this job."""
 
     next_page_token: Optional[str] = None
-    """A token that can be used to list the next page of sub-resources."""
+    """A token that can be used to list the next page of array properties."""
 
     run_as_user_name: Optional[str] = None
     """The email of an active workspace user or the application ID of a service principal that the job
@@ -2592,8 +2707,11 @@ 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 and jobs' environment
-    for non-notebook task. In this minimal environment spec, only pip dependencies are supported."""
+    """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. (Note: DLT uses a
+    copied version of the Environment proto below, at
+    //spark/pipelines/api/protos/copied/libraries-environments-copy.proto) 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."""
@@ -2977,8 +3095,7 @@ class JobSettings:
     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. If more than 100 job clusters are available, you can paginate through them using
-    :method:jobs/get."""
+    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
@@ -3001,8 +3118,12 @@ class JobSettings:
     """Job-level parameter definitions"""
 
     performance_target: Optional[PerformanceTarget] = None
-    """PerformanceTarget defines how performant or cost efficient the execution of run on serverless
-    should be."""
+    """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."""
@@ -3023,9 +3144,11 @@ class JobSettings:
     be added to the job."""
 
     tasks: Optional[List[Task]] = None
-    """A list of task specifications to be executed by this job. 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."""
+    """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."""
@@ -3659,9 +3782,8 @@ class PerformanceTarget(Enum):
     on serverless compute should be. The performance mode on the job or pipeline should map to a
     performance setting that is passed to Cluster Manager (see cluster-common PerformanceTarget)."""
 
-    BALANCED = "BALANCED"
-    COST_OPTIMIZED = "COST_OPTIMIZED"
     PERFORMANCE_OPTIMIZED = "PERFORMANCE_OPTIMIZED"
+    STANDARD = "STANDARD"
 
 
 @dataclass
@@ -3760,6 +3882,175 @@ class PipelineTask:
         return cls(full_refresh=d.get("full_refresh", None), pipeline_id=d.get("pipeline_id", None))
 
 
+@dataclass
+class PowerBiModel:
+    authentication_method: Optional[AuthenticationMethod] = None
+    """How the published Power BI model authenticates to Databricks"""
+
+    model_name: Optional[str] = None
+    """The name of the Power BI model"""
+
+    overwrite_existing: Optional[bool] = None
+    """Whether to overwrite existing Power BI models"""
+
+    storage_mode: Optional[StorageMode] = None
+    """The default storage mode of the Power BI model"""
+
+    workspace_name: Optional[str] = None
+    """The name of the Power BI workspace of the model"""
+
+    def as_dict(self) -> dict:
+        """Serializes the PowerBiModel into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.authentication_method is not None:
+            body["authentication_method"] = self.authentication_method.value
+        if self.model_name is not None:
+            body["model_name"] = self.model_name
+        if self.overwrite_existing is not None:
+            body["overwrite_existing"] = self.overwrite_existing
+        if self.storage_mode is not None:
+            body["storage_mode"] = self.storage_mode.value
+        if self.workspace_name is not None:
+            body["workspace_name"] = self.workspace_name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PowerBiModel into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.authentication_method is not None:
+            body["authentication_method"] = self.authentication_method
+        if self.model_name is not None:
+            body["model_name"] = self.model_name
+        if self.overwrite_existing is not None:
+            body["overwrite_existing"] = self.overwrite_existing
+        if self.storage_mode is not None:
+            body["storage_mode"] = self.storage_mode
+        if self.workspace_name is not None:
+            body["workspace_name"] = self.workspace_name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> PowerBiModel:
+        """Deserializes the PowerBiModel from a dictionary."""
+        return cls(
+            authentication_method=_enum(d, "authentication_method", AuthenticationMethod),
+            model_name=d.get("model_name", None),
+            overwrite_existing=d.get("overwrite_existing", None),
+            storage_mode=_enum(d, "storage_mode", StorageMode),
+            workspace_name=d.get("workspace_name", None),
+        )
+
+
+@dataclass
+class PowerBiTable:
+    catalog: Optional[str] = None
+    """The catalog name in Databricks"""
+
+    name: Optional[str] = None
+    """The table name in Databricks"""
+
+    schema: Optional[str] = None
+    """The schema name in Databricks"""
+
+    storage_mode: Optional[StorageMode] = None
+    """The Power BI storage mode of the table"""
+
+    def as_dict(self) -> dict:
+        """Serializes the PowerBiTable into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.catalog is not None:
+            body["catalog"] = self.catalog
+        if self.name is not None:
+            body["name"] = self.name
+        if self.schema is not None:
+            body["schema"] = self.schema
+        if self.storage_mode is not None:
+            body["storage_mode"] = self.storage_mode.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PowerBiTable into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.catalog is not None:
+            body["catalog"] = self.catalog
+        if self.name is not None:
+            body["name"] = self.name
+        if self.schema is not None:
+            body["schema"] = self.schema
+        if self.storage_mode is not None:
+            body["storage_mode"] = self.storage_mode
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> PowerBiTable:
+        """Deserializes the PowerBiTable from a dictionary."""
+        return cls(
+            catalog=d.get("catalog", None),
+            name=d.get("name", None),
+            schema=d.get("schema", None),
+            storage_mode=_enum(d, "storage_mode", StorageMode),
+        )
+
+
+@dataclass
+class PowerBiTask:
+    connection_resource_name: Optional[str] = None
+    """The resource name of the UC connection to authenticate from Databricks to Power BI"""
+
+    power_bi_model: Optional[PowerBiModel] = None
+    """The semantic model to update"""
+
+    refresh_after_update: Optional[bool] = None
+    """Whether the model should be refreshed after the update"""
+
+    tables: Optional[List[PowerBiTable]] = None
+    """The tables to be exported to Power BI"""
+
+    warehouse_id: Optional[str] = None
+    """The SQL warehouse ID to use as the Power BI data source"""
+
+    def as_dict(self) -> dict:
+        """Serializes the PowerBiTask into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.connection_resource_name is not None:
+            body["connection_resource_name"] = self.connection_resource_name
+        if self.power_bi_model:
+            body["power_bi_model"] = self.power_bi_model.as_dict()
+        if self.refresh_after_update is not None:
+            body["refresh_after_update"] = self.refresh_after_update
+        if self.tables:
+            body["tables"] = [v.as_dict() for v in self.tables]
+        if self.warehouse_id is not None:
+            body["warehouse_id"] = self.warehouse_id
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PowerBiTask into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.connection_resource_name is not None:
+            body["connection_resource_name"] = self.connection_resource_name
+        if self.power_bi_model:
+            body["power_bi_model"] = self.power_bi_model
+        if self.refresh_after_update is not None:
+            body["refresh_after_update"] = self.refresh_after_update
+        if self.tables:
+            body["tables"] = self.tables
+        if self.warehouse_id is not None:
+            body["warehouse_id"] = self.warehouse_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> PowerBiTask:
+        """Deserializes the PowerBiTask from a dictionary."""
+        return cls(
+            connection_resource_name=d.get("connection_resource_name", None),
+            power_bi_model=_from_dict(d, "power_bi_model", PowerBiModel),
+            refresh_after_update=d.get("refresh_after_update", None),
+            tables=_repeated_dict(d, "tables", PowerBiTable),
+            warehouse_id=d.get("warehouse_id", None),
+        )
+
+
 @dataclass
 class PythonWheelTask:
     package_name: str
@@ -3890,6 +4181,15 @@ class QueueSettings:
 
 @dataclass
 class RepairHistoryItem:
+    effective_performance_target: Optional[PerformanceTarget] = None
+    """The actual performance target used by the serverless run during execution. This can differ from
+    the client-set performance target on the request depending on whether the performance mode is
+    supported by the job type.
+    
+    * `STANDARD`: Enables cost-efficient execution of serverless workloads. *
+    `PERFORMANCE_OPTIMIZED`: Prioritizes fast startup and execution times through rapid scaling and
+    optimized cluster performance."""
+
     end_time: Optional[int] = None
     """The end time of the (repaired) run."""
 
@@ -3914,6 +4214,8 @@ class RepairHistoryItem:
     def as_dict(self) -> dict:
         """Serializes the RepairHistoryItem into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.effective_performance_target is not None:
+            body["effective_performance_target"] = self.effective_performance_target.value
         if self.end_time is not None:
             body["end_time"] = self.end_time
         if self.id is not None:
@@ -3933,6 +4235,8 @@ class RepairHistoryItem:
     def as_shallow_dict(self) -> dict:
         """Serializes the RepairHistoryItem into a shallow dictionary of its immediate attributes."""
         body = {}
+        if self.effective_performance_target is not None:
+            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:
@@ -3953,6 +4257,7 @@ class RepairHistoryItem:
     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),
@@ -4014,6 +4319,15 @@ class RepairRun:
     [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"""
 
@@ -4080,6 +4394,8 @@ class RepairRun:
             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:
@@ -4113,6 +4429,8 @@ class RepairRun:
             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:
@@ -4142,6 +4460,7 @@ class RepairRun:
             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),
@@ -4542,9 +4861,13 @@ class Run:
     """Description of the run"""
 
     effective_performance_target: Optional[PerformanceTarget] = None
-    """effective_performance_target is the actual performance target used by the run during execution.
-    effective_performance_target can differ from the client-set performance_target depending on if
-    the job was eligible to be cost-optimized."""
+    """The actual performance target used by the serverless run during execution. This can differ from
+    the client-set performance target on the request depending on whether the performance mode is
+    supported by the job type.
+    
+    * `STANDARD`: Enables cost-efficient execution of serverless workloads. *
+    `PERFORMANCE_OPTIMIZED`: Prioritizes fast startup and execution times through rapid scaling and
+    optimized cluster performance."""
 
     end_time: Optional[int] = None
     """The time at which this run ended in epoch milliseconds (milliseconds since 1/1/1970 UTC). This
@@ -4568,8 +4891,8 @@ class Run:
     are used, `git_source` must be defined on the job."""
 
     has_more: Optional[bool] = None
-    """Indicates if the run has more sub-resources (`tasks`, `job_clusters`) that are not shown. They
-    can be accessed via :method:jobs/getrun endpoint. It is only relevant for API 2.2
+    """Indicates if the run has more array properties (`tasks`, `job_clusters`) that are not shown.
+    They can be accessed via :method:jobs/getrun endpoint. It is only relevant for API 2.2
     :method:jobs/listruns requests with `expand_tasks=true`."""
 
     iterations: Optional[List[RunTask]] = None
@@ -4593,7 +4916,7 @@ class Run:
     that the task run belongs to."""
 
     next_page_token: Optional[str] = None
-    """A token that can be used to list the next page of sub-resources."""
+    """A token that can be used to list the next page of array properties."""
 
     number_in_job: Optional[int] = None
     """A unique identifier for this job run. This is set to the same value as `run_id`."""
@@ -5266,9 +5589,13 @@ class RunNow:
     job will be run."""
 
     performance_target: Optional[PerformanceTarget] = None
-    """PerformanceTarget defines how performant or cost efficient the execution of run on serverless
-    compute should be. For RunNow, this performance target will override the target defined on the
-    job-level."""
+    """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"""
@@ -5443,6 +5770,9 @@ class RunOutput:
     clean_rooms_notebook_output: Optional[CleanRoomsNotebookTaskCleanRoomsNotebookTaskOutput] = None
     """The output of a clean rooms notebook task, if available"""
 
+    dashboard_output: Optional[DashboardTaskOutput] = None
+    """The output of a dashboard task, if available"""
+
     dbt_output: Optional[DbtOutput] = None
     """The output of a dbt task, if available."""
 
@@ -5489,6 +5819,8 @@ class RunOutput:
         body = {}
         if self.clean_rooms_notebook_output:
             body["clean_rooms_notebook_output"] = self.clean_rooms_notebook_output.as_dict()
+        if self.dashboard_output:
+            body["dashboard_output"] = self.dashboard_output.as_dict()
         if self.dbt_output:
             body["dbt_output"] = self.dbt_output.as_dict()
         if self.error is not None:
@@ -5516,6 +5848,8 @@ class RunOutput:
         body = {}
         if self.clean_rooms_notebook_output:
             body["clean_rooms_notebook_output"] = self.clean_rooms_notebook_output
+        if self.dashboard_output:
+            body["dashboard_output"] = self.dashboard_output
         if self.dbt_output:
             body["dbt_output"] = self.dbt_output
         if self.error is not None:
@@ -5545,6 +5879,7 @@ class RunOutput:
             clean_rooms_notebook_output=_from_dict(
                 d, "clean_rooms_notebook_output", CleanRoomsNotebookTaskCleanRoomsNotebookTaskOutput
             ),
+            dashboard_output=_from_dict(d, "dashboard_output", DashboardTaskOutput),
             dbt_output=_from_dict(d, "dbt_output", DbtOutput),
             error=d.get("error", None),
             error_trace=d.get("error_trace", None),
@@ -5720,13 +6055,14 @@ class RunState:
 
     life_cycle_state: Optional[RunLifeCycleState] = None
     """A value indicating the run's current lifecycle state. This field is always available in the
-    response."""
+    response. Note: Additional states might be introduced in future releases."""
 
     queue_reason: Optional[str] = None
     """The reason indicating why the run was queued."""
 
     result_state: Optional[RunResultState] = None
-    """A value indicating the run's result. This field is only available for terminal lifecycle states."""
+    """A value indicating the run's result. This field is only available for terminal lifecycle states.
+    Note: Additional states might be introduced in future releases."""
 
     state_message: Optional[str] = None
     """A descriptive message for the current state. This field is unstructured, and its exact format is
@@ -5860,6 +6196,9 @@ class RunTask:
     `condition_task` field is present. The condition task does not require a cluster to execute and
     does not support retries or notifications."""
 
+    dashboard_task: Optional[DashboardTask] = None
+    """The task refreshes a dashboard and sends a snapshot to subscribers."""
+
     dbt_task: Optional[DbtTask] = None
     """The task runs one or more dbt commands when the `dbt_task` field is present. The dbt task
     requires both Databricks SQL and the ability to use a serverless or a pro SQL warehouse."""
@@ -5873,13 +6212,16 @@ class RunTask:
     """An optional description for this task."""
 
     disabled: Optional[bool] = None
-    """Denotes whether or not the task was disabled by the user. Disabled tasks do not execute and are
-    immediately skipped as soon as they are unblocked."""
+    """Deprecated, field was never used in production."""
 
     effective_performance_target: Optional[PerformanceTarget] = None
-    """effective_performance_target is the actual performance target used by the run during execution.
-    effective_performance_target can differ from the client-set performance_target depending on if
-    the job was eligible to be cost-optimized."""
+    """The actual performance target used by the serverless run during execution. This can differ from
+    the client-set performance target on the request depending on whether the performance mode is
+    supported by the job type.
+    
+    * `STANDARD`: Enables cost-efficient execution of serverless workloads. *
+    `PERFORMANCE_OPTIMIZED`: Prioritizes fast startup and execution times through rapid scaling and
+    optimized cluster performance."""
 
     email_notifications: Optional[JobEmailNotifications] = None
     """An optional set of email addresses notified when the task run begins or completes. The default
@@ -5910,7 +6252,6 @@ class RunTask:
     present."""
 
     gen_ai_compute_task: Optional[GenAiComputeTask] = None
-    """Next field: 9"""
 
     git_source: Optional[GitSource] = None
     """An optional specification for a remote Git repository containing the source code used by tasks.
@@ -5942,6 +6283,9 @@ class RunTask:
     """The task triggers a pipeline update when the `pipeline_task` field is present. Only pipelines
     configured to use triggered more are supported."""
 
+    power_bi_task: Optional[PowerBiTask] = None
+    """The task triggers a Power BI semantic model update when the `power_bi_task` field is present."""
+
     python_wheel_task: Optional[PythonWheelTask] = None
     """The task runs a Python wheel when the `python_wheel_task` field is present."""
 
@@ -6033,6 +6377,8 @@ class RunTask:
             body["cluster_instance"] = self.cluster_instance.as_dict()
         if self.condition_task:
             body["condition_task"] = self.condition_task.as_dict()
+        if self.dashboard_task:
+            body["dashboard_task"] = self.dashboard_task.as_dict()
         if self.dbt_task:
             body["dbt_task"] = self.dbt_task.as_dict()
         if self.depends_on:
@@ -6071,6 +6417,8 @@ class RunTask:
             body["notification_settings"] = self.notification_settings.as_dict()
         if self.pipeline_task:
             body["pipeline_task"] = self.pipeline_task.as_dict()
+        if self.power_bi_task:
+            body["power_bi_task"] = self.power_bi_task.as_dict()
         if self.python_wheel_task:
             body["python_wheel_task"] = self.python_wheel_task.as_dict()
         if self.queue_duration is not None:
@@ -6124,6 +6472,8 @@ class RunTask:
             body["cluster_instance"] = self.cluster_instance
         if self.condition_task:
             body["condition_task"] = self.condition_task
+        if self.dashboard_task:
+            body["dashboard_task"] = self.dashboard_task
         if self.dbt_task:
             body["dbt_task"] = self.dbt_task
         if self.depends_on:
@@ -6162,6 +6512,8 @@ class RunTask:
             body["notification_settings"] = self.notification_settings
         if self.pipeline_task:
             body["pipeline_task"] = self.pipeline_task
+        if self.power_bi_task:
+            body["power_bi_task"] = self.power_bi_task
         if self.python_wheel_task:
             body["python_wheel_task"] = self.python_wheel_task
         if self.queue_duration is not None:
@@ -6211,6 +6563,7 @@ class RunTask:
             cleanup_duration=d.get("cleanup_duration", None),
             cluster_instance=_from_dict(d, "cluster_instance", ClusterInstance),
             condition_task=_from_dict(d, "condition_task", RunConditionTask),
+            dashboard_task=_from_dict(d, "dashboard_task", DashboardTask),
             dbt_task=_from_dict(d, "dbt_task", DbtTask),
             depends_on=_repeated_dict(d, "depends_on", TaskDependency),
             description=d.get("description", None),
@@ -6230,6 +6583,7 @@ class RunTask:
             notebook_task=_from_dict(d, "notebook_task", NotebookTask),
             notification_settings=_from_dict(d, "notification_settings", TaskNotificationSettings),
             pipeline_task=_from_dict(d, "pipeline_task", PipelineTask),
+            power_bi_task=_from_dict(d, "power_bi_task", PowerBiTask),
             python_wheel_task=_from_dict(d, "python_wheel_task", PythonWheelTask),
             queue_duration=d.get("queue_duration", None),
             resolved_values=_from_dict(d, "resolved_values", ResolvedValues),
@@ -7028,6 +7382,13 @@ class SqlTaskSubscription:
         return cls(destination_id=d.get("destination_id", None), user_name=d.get("user_name", None))
 
 
+class StorageMode(Enum):
+
+    DIRECT_QUERY = "DIRECT_QUERY"
+    DUAL = "DUAL"
+    IMPORT = "IMPORT"
+
+
 @dataclass
 class SubmitRun:
     access_control_list: Optional[List[JobAccessControlRequest]] = None
@@ -7223,6 +7584,9 @@ class SubmitTask:
     `condition_task` field is present. The condition task does not require a cluster to execute and
     does not support retries or notifications."""
 
+    dashboard_task: Optional[DashboardTask] = None
+    """The task refreshes a dashboard and sends a snapshot to subscribers."""
+
     dbt_task: Optional[DbtTask] = None
     """The task runs one or more dbt commands when the `dbt_task` field is present. The dbt task
     requires both Databricks SQL and the ability to use a serverless or a pro SQL warehouse."""
@@ -7253,7 +7617,6 @@ class SubmitTask:
     present."""
 
     gen_ai_compute_task: Optional[GenAiComputeTask] = None
-    """Next field: 9"""
 
     health: Optional[JobsHealthRules] = None
     """An optional set of health rules that can be defined for this job."""
@@ -7276,6 +7639,9 @@ class SubmitTask:
     """The task triggers a pipeline update when the `pipeline_task` field is present. Only pipelines
     configured to use triggered more are supported."""
 
+    power_bi_task: Optional[PowerBiTask] = None
+    """The task triggers a Power BI semantic model update when the `power_bi_task` field is present."""
+
     python_wheel_task: Optional[PythonWheelTask] = None
     """The task runs a Python wheel when the `python_wheel_task` field is present."""
 
@@ -7329,6 +7695,8 @@ class SubmitTask:
             body["clean_rooms_notebook_task"] = self.clean_rooms_notebook_task.as_dict()
         if self.condition_task:
             body["condition_task"] = self.condition_task.as_dict()
+        if self.dashboard_task:
+            body["dashboard_task"] = self.dashboard_task.as_dict()
         if self.dbt_task:
             body["dbt_task"] = self.dbt_task.as_dict()
         if self.depends_on:
@@ -7357,6 +7725,8 @@ class SubmitTask:
             body["notification_settings"] = self.notification_settings.as_dict()
         if self.pipeline_task:
             body["pipeline_task"] = self.pipeline_task.as_dict()
+        if self.power_bi_task:
+            body["power_bi_task"] = self.power_bi_task.as_dict()
         if self.python_wheel_task:
             body["python_wheel_task"] = self.python_wheel_task.as_dict()
         if self.run_if is not None:
@@ -7386,6 +7756,8 @@ class SubmitTask:
             body["clean_rooms_notebook_task"] = self.clean_rooms_notebook_task
         if self.condition_task:
             body["condition_task"] = self.condition_task
+        if self.dashboard_task:
+            body["dashboard_task"] = self.dashboard_task
         if self.dbt_task:
             body["dbt_task"] = self.dbt_task
         if self.depends_on:
@@ -7414,6 +7786,8 @@ class SubmitTask:
             body["notification_settings"] = self.notification_settings
         if self.pipeline_task:
             body["pipeline_task"] = self.pipeline_task
+        if self.power_bi_task:
+            body["power_bi_task"] = self.power_bi_task
         if self.python_wheel_task:
             body["python_wheel_task"] = self.python_wheel_task
         if self.run_if is not None:
@@ -7442,6 +7816,7 @@ class SubmitTask:
         return cls(
             clean_rooms_notebook_task=_from_dict(d, "clean_rooms_notebook_task", CleanRoomsNotebookTask),
             condition_task=_from_dict(d, "condition_task", ConditionTask),
+            dashboard_task=_from_dict(d, "dashboard_task", DashboardTask),
             dbt_task=_from_dict(d, "dbt_task", DbtTask),
             depends_on=_repeated_dict(d, "depends_on", TaskDependency),
             description=d.get("description", None),
@@ -7456,6 +7831,7 @@ class SubmitTask:
             notebook_task=_from_dict(d, "notebook_task", NotebookTask),
             notification_settings=_from_dict(d, "notification_settings", TaskNotificationSettings),
             pipeline_task=_from_dict(d, "pipeline_task", PipelineTask),
+            power_bi_task=_from_dict(d, "power_bi_task", PowerBiTask),
             python_wheel_task=_from_dict(d, "python_wheel_task", PythonWheelTask),
             run_if=_enum(d, "run_if", RunIf),
             run_job_task=_from_dict(d, "run_job_task", RunJobTask),
@@ -7469,6 +7845,83 @@ class SubmitTask:
         )
 
 
+@dataclass
+class Subscription:
+    custom_subject: Optional[str] = None
+    """Optional: Allows users to specify a custom subject line on the email sent to subscribers."""
+
+    paused: Optional[bool] = None
+    """When true, the subscription will not send emails."""
+
+    subscribers: Optional[List[SubscriptionSubscriber]] = None
+    """The list of subscribers to send the snapshot of the dashboard to."""
+
+    def as_dict(self) -> dict:
+        """Serializes the Subscription into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.custom_subject is not None:
+            body["custom_subject"] = self.custom_subject
+        if self.paused is not None:
+            body["paused"] = self.paused
+        if self.subscribers:
+            body["subscribers"] = [v.as_dict() for v in self.subscribers]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Subscription into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.custom_subject is not None:
+            body["custom_subject"] = self.custom_subject
+        if self.paused is not None:
+            body["paused"] = self.paused
+        if self.subscribers:
+            body["subscribers"] = self.subscribers
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> Subscription:
+        """Deserializes the Subscription from a dictionary."""
+        return cls(
+            custom_subject=d.get("custom_subject", None),
+            paused=d.get("paused", None),
+            subscribers=_repeated_dict(d, "subscribers", SubscriptionSubscriber),
+        )
+
+
+@dataclass
+class SubscriptionSubscriber:
+    destination_id: Optional[str] = None
+    """A snapshot of the dashboard will be sent to the destination when the `destination_id` field is
+    present."""
+
+    user_name: Optional[str] = None
+    """A snapshot of the dashboard will be sent to the user's email when the `user_name` field is
+    present."""
+
+    def as_dict(self) -> dict:
+        """Serializes the SubscriptionSubscriber into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.destination_id is not None:
+            body["destination_id"] = self.destination_id
+        if self.user_name is not None:
+            body["user_name"] = self.user_name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SubscriptionSubscriber into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.destination_id is not None:
+            body["destination_id"] = self.destination_id
+        if self.user_name is not None:
+            body["user_name"] = self.user_name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> SubscriptionSubscriber:
+        """Deserializes the SubscriptionSubscriber from a dictionary."""
+        return cls(destination_id=d.get("destination_id", None), user_name=d.get("user_name", None))
+
+
 @dataclass
 class TableUpdateTriggerConfiguration:
     condition: Optional[Condition] = None
@@ -7541,6 +7994,9 @@ class Task:
     `condition_task` field is present. The condition task does not require a cluster to execute and
     does not support retries or notifications."""
 
+    dashboard_task: Optional[DashboardTask] = None
+    """The task refreshes a dashboard and sends a snapshot to subscribers."""
+
     dbt_task: Optional[DbtTask] = None
     """The task runs one or more dbt commands when the `dbt_task` field is present. The dbt task
     requires both Databricks SQL and the ability to use a serverless or a pro SQL warehouse."""
@@ -7575,7 +8031,6 @@ class Task:
     present."""
 
     gen_ai_compute_task: Optional[GenAiComputeTask] = None
-    """Next field: 9"""
 
     health: Optional[JobsHealthRules] = None
     """An optional set of health rules that can be defined for this job."""
@@ -7612,6 +8067,9 @@ class Task:
     """The task triggers a pipeline update when the `pipeline_task` field is present. Only pipelines
     configured to use triggered more are supported."""
 
+    power_bi_task: Optional[PowerBiTask] = None
+    """The task triggers a Power BI semantic model update when the `power_bi_task` field is present."""
+
     python_wheel_task: Optional[PythonWheelTask] = None
     """The task runs a Python wheel when the `python_wheel_task` field is present."""
 
@@ -7672,6 +8130,8 @@ class Task:
             body["clean_rooms_notebook_task"] = self.clean_rooms_notebook_task.as_dict()
         if self.condition_task:
             body["condition_task"] = self.condition_task.as_dict()
+        if self.dashboard_task:
+            body["dashboard_task"] = self.dashboard_task.as_dict()
         if self.dbt_task:
             body["dbt_task"] = self.dbt_task.as_dict()
         if self.depends_on:
@@ -7708,6 +8168,8 @@ class Task:
             body["notification_settings"] = self.notification_settings.as_dict()
         if self.pipeline_task:
             body["pipeline_task"] = self.pipeline_task.as_dict()
+        if self.power_bi_task:
+            body["power_bi_task"] = self.power_bi_task.as_dict()
         if self.python_wheel_task:
             body["python_wheel_task"] = self.python_wheel_task.as_dict()
         if self.retry_on_timeout is not None:
@@ -7739,6 +8201,8 @@ class Task:
             body["clean_rooms_notebook_task"] = self.clean_rooms_notebook_task
         if self.condition_task:
             body["condition_task"] = self.condition_task
+        if self.dashboard_task:
+            body["dashboard_task"] = self.dashboard_task
         if self.dbt_task:
             body["dbt_task"] = self.dbt_task
         if self.depends_on:
@@ -7775,6 +8239,8 @@ class Task:
             body["notification_settings"] = self.notification_settings
         if self.pipeline_task:
             body["pipeline_task"] = self.pipeline_task
+        if self.power_bi_task:
+            body["power_bi_task"] = self.power_bi_task
         if self.python_wheel_task:
             body["python_wheel_task"] = self.python_wheel_task
         if self.retry_on_timeout is not None:
@@ -7805,6 +8271,7 @@ class Task:
         return cls(
             clean_rooms_notebook_task=_from_dict(d, "clean_rooms_notebook_task", CleanRoomsNotebookTask),
             condition_task=_from_dict(d, "condition_task", ConditionTask),
+            dashboard_task=_from_dict(d, "dashboard_task", DashboardTask),
             dbt_task=_from_dict(d, "dbt_task", DbtTask),
             depends_on=_repeated_dict(d, "depends_on", TaskDependency),
             description=d.get("description", None),
@@ -7823,6 +8290,7 @@ class Task:
             notebook_task=_from_dict(d, "notebook_task", NotebookTask),
             notification_settings=_from_dict(d, "notification_settings", TaskNotificationSettings),
             pipeline_task=_from_dict(d, "pipeline_task", PipelineTask),
+            power_bi_task=_from_dict(d, "power_bi_task", PowerBiTask),
             python_wheel_task=_from_dict(d, "python_wheel_task", PythonWheelTask),
             retry_on_timeout=d.get("retry_on_timeout", None),
             run_if=_enum(d, "run_if", RunIf),
@@ -8032,7 +8500,7 @@ class TerminationCodeCode(Enum):
     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.
+    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"""
 
@@ -8041,6 +8509,7 @@ class TerminationCodeCode(Enum):
     CLOUD_FAILURE = "CLOUD_FAILURE"
     CLUSTER_ERROR = "CLUSTER_ERROR"
     CLUSTER_REQUEST_LIMIT_EXCEEDED = "CLUSTER_REQUEST_LIMIT_EXCEEDED"
+    DISABLED = "DISABLED"
     DRIVER_ERROR = "DRIVER_ERROR"
     FEATURE_DISABLED = "FEATURE_DISABLED"
     INTERNAL_ERROR = "INTERNAL_ERROR"
@@ -8096,7 +8565,7 @@ class TerminationDetails:
     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.
+    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"""
 
@@ -8487,6 +8956,30 @@ class WebhookNotifications:
         )
 
 
+@dataclass
+class WidgetErrorDetail:
+    message: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the WidgetErrorDetail into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.message is not None:
+            body["message"] = self.message
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the WidgetErrorDetail into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.message is not None:
+            body["message"] = self.message
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> WidgetErrorDetail:
+        """Deserializes the WidgetErrorDetail from a dictionary."""
+        return cls(message=d.get("message", None))
+
+
 class JobsAPI:
     """The Jobs API allows you to create, edit, and delete jobs.
 
@@ -8672,7 +9165,6 @@ class JobsAPI:
         :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.
-          If more than 100 job clusters are available, you can paginate through them using :method:jobs/get.
         :param max_concurrent_runs: int (optional)
           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
@@ -8690,8 +9182,12 @@ class JobsAPI:
         :param parameters: List[:class:`JobParameterDefinition`] (optional)
           Job-level parameter definitions
         :param performance_target: :class:`PerformanceTarget` (optional)
-          PerformanceTarget defines how performant or cost efficient the execution of run on serverless should
-          be.
+          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.
         :param queue: :class:`QueueSettings` (optional)
           The queue settings of the job.
         :param run_as: :class:`JobRunAs` (optional)
@@ -8707,9 +9203,11 @@ class JobsAPI:
           clusters, and are subject to the same limitations as cluster tags. A maximum of 25 tags can be added
           to the job.
         :param tasks: List[:class:`Task`] (optional)
-          A list of task specifications to be executed by this job. 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.
+          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.
         :param timeout_seconds: int (optional)
           An optional timeout applied to each run of this job. A value of `0` means no timeout.
         :param trigger: :class:`TriggerSettings` (optional)
@@ -8848,16 +9346,18 @@ class JobsAPI:
 
         Retrieves the details for a single job.
 
-        In Jobs API 2.2, requests for a single job support pagination of `tasks` and `job_clusters` when
-        either exceeds 100 elements. Use the `next_page_token` field to check for more results and pass its
-        value as the `page_token` in subsequent requests. Arrays with fewer than 100 elements in a page will
-        be empty on later pages.
+        Large arrays in the results will be paginated when they exceed 100 elements. A request for a single
+        job will return all properties for that job, and the first 100 elements of array properties (`tasks`,
+        `job_clusters`, `environments` and `parameters`). Use the `next_page_token` field to check for more
+        results and pass its value as the `page_token` in subsequent requests. If any array properties have
+        more than 100 elements, additional results will be returned on subsequent requests. Arrays without
+        additional results will be empty on later pages.
 
         :param job_id: int
           The canonical identifier of the job to retrieve information about. This field is required.
         :param page_token: str (optional)
-          Use `next_page_token` returned from the previous GetJob to request the next page of the job's
-          sub-resources.
+          Use `next_page_token` returned from the previous GetJob response to request the next page of the
+          job's array properties.
 
         :returns: :class:`Job`
         """
@@ -8922,10 +9422,12 @@ class JobsAPI:
 
         Retrieves the metadata of a run.
 
-        In Jobs API 2.2, requests for a single job run support pagination of `tasks` and `job_clusters` when
-        either exceeds 100 elements. Use the `next_page_token` field to check for more results and pass its
-        value as the `page_token` in subsequent requests. Arrays with fewer than 100 elements in a page will
-        be empty on later pages.
+        Large arrays in the results will be paginated when they exceed 100 elements. A request for a single
+        run will return all properties for that run, and the first 100 elements of array properties (`tasks`,
+        `job_clusters`, `job_parameters` and `repair_history`). Use the next_page_token field to check for
+        more results and pass its value as the page_token in subsequent requests. If any array properties have
+        more than 100 elements, additional results will be returned on subsequent requests. Arrays without
+        additional results will be empty on later pages.
 
         :param run_id: int
           The canonical identifier of the run for which to retrieve the metadata. This field is required.
@@ -8934,8 +9436,8 @@ class JobsAPI:
         :param include_resolved_values: bool (optional)
           Whether to include resolved parameter values in the response.
         :param page_token: str (optional)
-          Use `next_page_token` returned from the previous GetRun to request the next page of the run's
-          sub-resources.
+          Use `next_page_token` returned from the previous GetRun response to request the next page of the
+          run's array properties.
 
         :returns: :class:`Run`
         """
@@ -8998,8 +9500,8 @@ class JobsAPI:
         Retrieves a list of jobs.
 
         :param expand_tasks: bool (optional)
-          Whether to include task and cluster details in the response. Note that in API 2.2, only the first
-          100 elements will be shown. Use :method:jobs/get to paginate through all tasks and clusters.
+          Whether to include task and cluster details in the response. Note that only the first 100 elements
+          will be shown. Use :method:jobs/get to paginate through all tasks and clusters.
         :param limit: int (optional)
           The number of jobs to return. This value must be greater than 0 and less or equal to 100. The
           default value is 20.
@@ -9065,8 +9567,8 @@ class JobsAPI:
           If completed_only is `true`, only completed runs are included in the results; otherwise, lists both
           active and completed runs. This field cannot be `true` when active_only is `true`.
         :param expand_tasks: bool (optional)
-          Whether to include task and cluster details in the response. Note that in API 2.2, only the first
-          100 elements will be shown. Use :method:jobs/getrun to paginate through all tasks and clusters.
+          Whether to include task and cluster details in the response. Note that only the first 100 elements
+          will be shown. Use :method:jobs/getrun to paginate through all tasks and clusters.
         :param job_id: int (optional)
           The job for which to list runs. If omitted, the Jobs service lists runs from all jobs.
         :param limit: int (optional)
@@ -9133,6 +9635,7 @@ class JobsAPI:
         job_parameters: Optional[Dict[str, str]] = None,
         latest_repair_id: Optional[int] = None,
         notebook_params: Optional[Dict[str, str]] = None,
+        performance_target: Optional[PerformanceTarget] = None,
         pipeline_params: Optional[PipelineParams] = None,
         python_named_params: Optional[Dict[str, str]] = None,
         python_params: Optional[List[str]] = None,
@@ -9183,6 +9686,14 @@ class JobsAPI:
 
           [Task parameter variables]: https://docs.databricks.com/jobs.html#parameter-variables
           [dbutils.widgets.get]: https://docs.databricks.com/dev-tools/databricks-utils.html
+        :param performance_target: :class:`PerformanceTarget` (optional)
+          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.
         :param pipeline_params: :class:`PipelineParams` (optional)
           Controls whether the pipeline should perform a full refresh
         :param python_named_params: Dict[str,str] (optional)
@@ -9243,6 +9754,8 @@ class JobsAPI:
             body["latest_repair_id"] = latest_repair_id
         if notebook_params is not None:
             body["notebook_params"] = notebook_params
+        if performance_target is not None:
+            body["performance_target"] = performance_target.value
         if pipeline_params is not None:
             body["pipeline_params"] = pipeline_params.as_dict()
         if python_named_params is not None:
@@ -9282,6 +9795,7 @@ class JobsAPI:
         job_parameters: Optional[Dict[str, str]] = None,
         latest_repair_id: Optional[int] = None,
         notebook_params: Optional[Dict[str, str]] = None,
+        performance_target: Optional[PerformanceTarget] = None,
         pipeline_params: Optional[PipelineParams] = None,
         python_named_params: Optional[Dict[str, str]] = None,
         python_params: Optional[List[str]] = None,
@@ -9298,6 +9812,7 @@ class JobsAPI:
             job_parameters=job_parameters,
             latest_repair_id=latest_repair_id,
             notebook_params=notebook_params,
+            performance_target=performance_target,
             pipeline_params=pipeline_params,
             python_named_params=python_named_params,
             python_params=python_params,
@@ -9408,9 +9923,13 @@ class JobsAPI:
           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.
         :param performance_target: :class:`PerformanceTarget` (optional)
-          PerformanceTarget defines how performant or cost efficient the execution of run on serverless
-          compute should be. For RunNow, this performance target will override the target defined on the
-          job-level.
+          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.
         :param pipeline_params: :class:`PipelineParams` (optional)
           Controls whether the pipeline should perform a full refresh
         :param python_named_params: Dict[str,str] (optional)