diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/CHANGELOG.md b/sdk/containerservice/azure-mgmt-containerservicefleet/CHANGELOG.md index 0a6377fd952c..6dba8ceca84c 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/CHANGELOG.md +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/CHANGELOG.md @@ -1,5 +1,113 @@ # Release History +## 4.0.0 (2026-08-03) + +### Features Added + + - Client `ContainerServiceFleetMgmtClient` added parameter `cloud_setting` in method `__init__` + - Client `ContainerServiceFleetMgmtClient` added method `send_request` + - Client `ContainerServiceFleetMgmtClient` added operation group `fleet_managed_namespaces` + - Client `ContainerServiceFleetMgmtClient` added operation group `gates` + - Model `UpdateGroup` added property `after_gates` + - Model `UpdateGroup` added property `before_gates` + - Model `UpdateGroup` added property `max_concurrency` + - Model `UpdateGroupStatus` added property `after_gates` + - Model `UpdateGroupStatus` added property `before_gates` + - Model `UpdateGroupStatus` added property `max_concurrency` + - Model `UpdateStage` added property `after_gates` + - Model `UpdateStage` added property `before_gates` + - Model `UpdateStage` added property `max_concurrency` + - Model `UpdateStageStatus` added property `after_gates` + - Model `UpdateStageStatus` added property `before_gates` + - Model `UpdateStageStatus` added property `max_concurrency` + - Enum `UpdateState` added member `PENDING` + - Enum `UpgradeChannel` added member `TARGET_KUBERNETES_VERSION` + - Added enum `AdoptionPolicy` + - Added model `Affinity` + - Added model `ClusterAffinity` + - Added model `ClusterResourcePlacementSpec` + - Added model `ClusterSelector` + - Added model `ClusterSelectorTerm` + - Added enum `DeletePolicy` + - Added model `FleetManagedNamespace` + - Added model `FleetManagedNamespacePatch` + - Added model `FleetManagedNamespaceProperties` + - Added enum `FleetManagedNamespaceProvisioningState` + - Added model `FleetManagedNamespaceStatus` + - Added model `Gate` + - Added model `GateConfiguration` + - Added model `GatePatch` + - Added model `GatePatchProperties` + - Added model `GateProperties` + - Added enum `GateProvisioningState` + - Added enum `GateState` + - Added model `GateTarget` + - Added enum `GateType` + - Added model `LabelSelector` + - Added enum `LabelSelectorOperator` + - Added model `LabelSelectorRequirement` + - Added model `ManagedNamespaceProperties` + - Added model `NetworkPolicy` + - Added model `PlacementPolicy` + - Added model `PlacementProfile` + - Added enum `PlacementType` + - Added enum `PolicyRule` + - Added model `PropagationPolicy` + - Added enum `PropagationType` + - Added model `PropertySelector` + - Added enum `PropertySelectorOperator` + - Added model `PropertySelectorRequirement` + - Added model `ResourceQuota` + - Added enum `TaintEffect` + - Added enum `Timing` + - Added model `Toleration` + - Added enum `TolerationOperator` + - Added model `UpdateRunGateStatus` + - Added model `UpdateRunGateTargetProperties` + - Operation group `AutoUpgradeProfilesOperations` added parameter `skip_token` in method `list_by_fleet` + - Operation group `AutoUpgradeProfilesOperations` added parameter `top` in method `list_by_fleet` + - Operation group `FleetMembersOperations` added parameter `filter` in method `list_by_fleet` + - Operation group `FleetMembersOperations` added parameter `skip_token` in method `list_by_fleet` + - Operation group `FleetMembersOperations` added parameter `top` in method `list_by_fleet` + - Operation group `FleetUpdateStrategiesOperations` added parameter `skip_token` in method `list_by_fleet` + - Operation group `FleetUpdateStrategiesOperations` added parameter `top` in method `list_by_fleet` + - Operation group `FleetsOperations` added parameter `skip_token` in method `list_by_subscription` + - Operation group `FleetsOperations` added parameter `top` in method `list_by_subscription` + - Operation group `UpdateRunsOperations` added parameter `skip_token` in method `list_by_fleet` + - Operation group `UpdateRunsOperations` added parameter `top` in method `list_by_fleet` + - Added operation group `FleetManagedNamespacesOperations` + - Added operation group `GatesOperations` + +### Breaking Changes + + - For the method breakings, please refer to https://aka.ms/azsdk/python/migrate/operations for migration. + - This version introduces new hybrid models which have dual dictionary and model nature. Please follow https://aka.ms/azsdk/python/migrate/hybrid-models for migration. + - Model `AutoUpgradeProfile` moved instance variable `auto_upgrade_profile_status`, `channel`, `disabled`, `node_image_selection`, `provisioning_state` and `update_strategy_id` under property `properties` whose type is `AutoUpgradeProfileProperties` + - Model `Fleet` moved instance variable `hub_profile`, `provisioning_state` and `status` under property `properties` whose type is `FleetProperties` + - Model `FleetMember` moved instance variable `cluster_resource_id`, `group`, `provisioning_state` and `status` under property `properties` whose type is `FleetMemberProperties` + - Model `FleetMemberUpdate` moved instance variable `group` under property `properties` whose type is `FleetMemberUpdateProperties` + - Model `FleetUpdateStrategy` moved instance variable `provisioning_state` and `strategy` under property `properties` whose type is `FleetUpdateStrategyProperties` + - Model `UpdateRun` moved instance variable `auto_upgrade_profile_id`, `managed_cluster_update`, `provisioning_state`, `status`, `strategy` and `update_strategy_id` under property `properties` whose type is `UpdateRunProperties` + - Method `AutoUpgradeProfilesOperations.begin_create_or_update` replaced positional_or_keyword parameters `if_match`/`if_none_match` with keyword_only parameters `etag`/`match_condition` + - Method `AutoUpgradeProfilesOperations.begin_delete` replaced positional_or_keyword parameter `if_match` with keyword_only parameters `etag`/`match_condition` + - Method `FleetMembersOperations.begin_create` replaced positional_or_keyword parameters `if_match`/`if_none_match` with keyword_only parameters `etag`/`match_condition` + - Method `FleetMembersOperations.begin_delete` replaced positional_or_keyword parameter `if_match` with keyword_only parameters `etag`/`match_condition` + - Method `FleetMembersOperations.begin_update` replaced positional_or_keyword parameter `if_match` with keyword_only parameters `etag`/`match_condition` + - Method `FleetUpdateStrategiesOperations.begin_create_or_update` replaced positional_or_keyword parameters `if_match`/`if_none_match` with keyword_only parameters `etag`/`match_condition` + - Method `FleetUpdateStrategiesOperations.begin_delete` replaced positional_or_keyword parameter `if_match` with keyword_only parameters `etag`/`match_condition` + - Method `FleetsOperations.begin_create_or_update` replaced positional_or_keyword parameters `if_match`/`if_none_match` with keyword_only parameters `etag`/`match_condition` + - Method `FleetsOperations.begin_delete` replaced positional_or_keyword parameter `if_match` with keyword_only parameters `etag`/`match_condition` + - Method `FleetsOperations.begin_update` replaced positional_or_keyword parameter `if_match` with keyword_only parameters `etag`/`match_condition` + - Method `UpdateRunsOperations.begin_create_or_update` replaced positional_or_keyword parameters `if_match`/`if_none_match` with keyword_only parameters `etag`/`match_condition` + - Method `UpdateRunsOperations.begin_delete` replaced positional_or_keyword parameter `if_match` with keyword_only parameters `etag`/`match_condition` + - Method `UpdateRunsOperations.begin_skip` replaced positional_or_keyword parameter `if_match` with keyword_only parameters `etag`/`match_condition` + - Method `UpdateRunsOperations.begin_start` replaced positional_or_keyword parameter `if_match` with keyword_only parameters `etag`/`match_condition` + - Method `UpdateRunsOperations.begin_stop` replaced positional_or_keyword parameter `if_match` with keyword_only parameters `etag`/`match_condition` + +### Other Changes + + - Deleted model `AutoUpgradeProfileListResult`/`FleetListResult`/`FleetMemberListResult`/`FleetUpdateStrategyListResult`/`OperationListResult`/`UpdateRunListResult` which actually were not used by SDK users + ## 4.0.0b4 (2026-05-28) ### Features Added diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/README.md b/sdk/containerservice/azure-mgmt-containerservicefleet/README.md index a1c12b6ea79d..ce4696570f0b 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/README.md +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/README.md @@ -24,7 +24,7 @@ pip install azure-identity ### Authentication -By default, [Azure Active Directory](https://aka.ms/awps/aad) token authentication depends on correct configuration of the following environment variables. +By default, [Microsoft Entra](https://learn.microsoft.com/entra/fundamentals/what-is-entra) token authentication depends on correct configuration of the following environment variables. - `AZURE_CLIENT_ID` for Azure client ID. - `AZURE_TENANT_ID` for Azure tenant ID. diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/_metadata.json b/sdk/containerservice/azure-mgmt-containerservicefleet/_metadata.json index 34f878bf7478..77b215668c1e 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/_metadata.json +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/_metadata.json @@ -1,10 +1,11 @@ { - "apiVersion": "2026-03-02-preview", + "apiVersion": "2026-06-01", "apiVersions": { - "Microsoft.ContainerService": "2026-03-02-preview" + "Microsoft.ContainerService": "2026-06-01" }, - "commit": "cb62053a18882dd258d9922be9770702b7ef6ac9", + "commit": "3fe4c3b986995e48ec87d3bc809fcdafe47d2aac", "repository_url": "https://github.com/Azure/azure-rest-api-specs", "typespec_src": "specification/containerservice/resource-manager/Microsoft.ContainerService/fleet", - "emitterVersion": "0.62.1" + "emitterVersion": "0.63.3", + "httpClientPythonVersion": "^0.35.1" } \ No newline at end of file diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/api.md b/sdk/containerservice/azure-mgmt-containerservicefleet/api.md new file mode 100644 index 000000000000..5b85d1283f2e --- /dev/null +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/api.md @@ -0,0 +1,3699 @@ +```py +namespace azure.mgmt.containerservicefleet + + class azure.mgmt.containerservicefleet.ContainerServiceFleetMgmtClient: implements ContextManager + auto_upgrade_profile_operations: AutoUpgradeProfileOperationsOperations + auto_upgrade_profiles: AutoUpgradeProfilesOperations + fleet_managed_namespaces: FleetManagedNamespacesOperations + fleet_members: FleetMembersOperations + fleet_update_strategies: FleetUpdateStrategiesOperations + fleets: FleetsOperations + gates: GatesOperations + operations: Operations + update_runs: UpdateRunsOperations + + def __init__( + self, + credential: TokenCredential, + subscription_id: str, + base_url: Optional[str] = None, + *, + api_version: str = ..., + cloud_setting: Optional[AzureClouds] = ..., + polling_interval: Optional[int] = ..., + **kwargs: Any + ) -> None: ... + + def close(self) -> None: ... + + def send_request( + self, + request: HttpRequest, + *, + stream: bool = False, + **kwargs: Any + ) -> HttpResponse: ... + + +namespace azure.mgmt.containerservicefleet.aio + + class azure.mgmt.containerservicefleet.aio.ContainerServiceFleetMgmtClient: implements AsyncContextManager + auto_upgrade_profile_operations: AutoUpgradeProfileOperationsOperations + auto_upgrade_profiles: AutoUpgradeProfilesOperations + fleet_managed_namespaces: FleetManagedNamespacesOperations + fleet_members: FleetMembersOperations + fleet_update_strategies: FleetUpdateStrategiesOperations + fleets: FleetsOperations + gates: GatesOperations + operations: Operations + update_runs: UpdateRunsOperations + + def __init__( + self, + credential: AsyncTokenCredential, + subscription_id: str, + base_url: Optional[str] = None, + *, + api_version: str = ..., + cloud_setting: Optional[AzureClouds] = ..., + polling_interval: Optional[int] = ..., + **kwargs: Any + ) -> None: ... + + async def close(self) -> None: ... + + def send_request( + self, + request: HttpRequest, + *, + stream: bool = False, + **kwargs: Any + ) -> Awaitable[AsyncHttpResponse]: ... + + +namespace azure.mgmt.containerservicefleet.aio.operations + + class azure.mgmt.containerservicefleet.aio.operations.AutoUpgradeProfileOperationsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2025-03-01', params_added_on={'2025-03-01': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'auto_upgrade_profile_name', 'accept']}, api_versions_list=['2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + async def begin_generate_update_run( + self, + resource_group_name: str, + fleet_name: str, + auto_upgrade_profile_name: str, + **kwargs: Any + ) -> AsyncLROPoller[GenerateResponse]: ... + + + class azure.mgmt.containerservicefleet.aio.operations.AutoUpgradeProfilesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + auto_upgrade_profile_name: str, + resource: AutoUpgradeProfile, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[AutoUpgradeProfile]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + auto_upgrade_profile_name: str, + resource: AutoUpgradeProfile, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[AutoUpgradeProfile]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + auto_upgrade_profile_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[AutoUpgradeProfile]: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2024-05-02-preview', params_added_on={'2024-05-02-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'auto_upgrade_profile_name', 'etag', 'match_condition']}, api_versions_list=['2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + async def begin_delete( + self, + resource_group_name: str, + fleet_name: str, + auto_upgrade_profile_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2024-05-02-preview', params_added_on={'2024-05-02-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'auto_upgrade_profile_name', 'accept']}, api_versions_list=['2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + async def get( + self, + resource_group_name: str, + fleet_name: str, + auto_upgrade_profile_name: str, + **kwargs: Any + ) -> AutoUpgradeProfile: ... + + @distributed_trace + @api_version_validation(method_added_on='2024-05-02-preview', params_added_on={'2024-05-02-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'top', 'skip_token', 'accept']}, api_versions_list=['2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def list_by_fleet( + self, + resource_group_name: str, + fleet_name: str, + *, + skip_token: Optional[str] = ..., + top: Optional[int] = ..., + **kwargs: Any + ) -> AsyncItemPaged[AutoUpgradeProfile]: ... + + + class azure.mgmt.containerservicefleet.aio.operations.FleetManagedNamespacesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + resource: FleetManagedNamespace, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetManagedNamespace]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + resource: FleetManagedNamespace, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetManagedNamespace]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetManagedNamespace]: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2025-08-01-preview', params_added_on={'2025-08-01-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'managed_namespace_name', 'etag', 'match_condition']}, api_versions_list=['2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + async def begin_delete( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + properties: FleetManagedNamespacePatch, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetManagedNamespace]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + properties: FleetManagedNamespacePatch, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetManagedNamespace]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetManagedNamespace]: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2025-08-01-preview', params_added_on={'2025-08-01-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'managed_namespace_name', 'accept']}, api_versions_list=['2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + async def get( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + **kwargs: Any + ) -> FleetManagedNamespace: ... + + @distributed_trace + @api_version_validation(method_added_on='2025-08-01-preview', params_added_on={'2025-08-01-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'accept']}, api_versions_list=['2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def list_by_fleet( + self, + resource_group_name: str, + fleet_name: str, + **kwargs: Any + ) -> AsyncItemPaged[FleetManagedNamespace]: ... + + + class azure.mgmt.containerservicefleet.aio.operations.FleetMembersOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + resource: FleetMember, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetMember]: ... + + @overload + async def begin_create( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + resource: FleetMember, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetMember]: ... + + @overload + async def begin_create( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetMember]: ... + + @distributed_trace_async + async def begin_delete( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + properties: FleetMemberUpdate, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetMember]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + properties: FleetMemberUpdate, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetMember]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetMember]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + **kwargs: Any + ) -> FleetMember: ... + + @distributed_trace + def list_by_fleet( + self, + resource_group_name: str, + fleet_name: str, + *, + filter: Optional[str] = ..., + skip_token: Optional[str] = ..., + top: Optional[int] = ..., + **kwargs: Any + ) -> AsyncItemPaged[FleetMember]: ... + + + class azure.mgmt.containerservicefleet.aio.operations.FleetUpdateStrategiesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + update_strategy_name: str, + resource: FleetUpdateStrategy, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetUpdateStrategy]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + update_strategy_name: str, + resource: FleetUpdateStrategy, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetUpdateStrategy]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + update_strategy_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[FleetUpdateStrategy]: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2023-08-15-preview', params_added_on={'2023-08-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'update_strategy_name', 'etag', 'match_condition']}, api_versions_list=['2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + async def begin_delete( + self, + resource_group_name: str, + fleet_name: str, + update_strategy_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2023-08-15-preview', params_added_on={'2023-08-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'update_strategy_name', 'accept']}, api_versions_list=['2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + async def get( + self, + resource_group_name: str, + fleet_name: str, + update_strategy_name: str, + **kwargs: Any + ) -> FleetUpdateStrategy: ... + + @distributed_trace + @api_version_validation(method_added_on='2023-08-15-preview', params_added_on={'2023-08-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'top', 'skip_token', 'accept']}, api_versions_list=['2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def list_by_fleet( + self, + resource_group_name: str, + fleet_name: str, + *, + skip_token: Optional[str] = ..., + top: Optional[int] = ..., + **kwargs: Any + ) -> AsyncItemPaged[FleetUpdateStrategy]: ... + + + class azure.mgmt.containerservicefleet.aio.operations.FleetsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + resource: Fleet, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[Fleet]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + resource: Fleet, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[Fleet]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[Fleet]: ... + + @distributed_trace_async + async def begin_delete( + self, + resource_group_name: str, + fleet_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + fleet_name: str, + properties: FleetPatch, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[Fleet]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + fleet_name: str, + properties: FleetPatch, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[Fleet]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + fleet_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[Fleet]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + fleet_name: str, + **kwargs: Any + ) -> Fleet: ... + + @distributed_trace + def list_by_resource_group( + self, + resource_group_name: str, + **kwargs: Any + ) -> AsyncItemPaged[Fleet]: ... + + @distributed_trace + def list_by_subscription( + self, + *, + skip_token: Optional[str] = ..., + top: Optional[int] = ..., + **kwargs: Any + ) -> AsyncItemPaged[Fleet]: ... + + @distributed_trace_async + async def list_credentials( + self, + resource_group_name: str, + fleet_name: str, + **kwargs: Any + ) -> FleetCredentialResults: ... + + + class azure.mgmt.containerservicefleet.aio.operations.GatesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + fleet_name: str, + gate_name: str, + properties: GatePatch, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[Gate]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + fleet_name: str, + gate_name: str, + properties: GatePatch, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[Gate]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + fleet_name: str, + gate_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[Gate]: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2025-04-01-preview', params_added_on={'2025-04-01-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'gate_name', 'accept']}, api_versions_list=['2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + async def get( + self, + resource_group_name: str, + fleet_name: str, + gate_name: str, + **kwargs: Any + ) -> Gate: ... + + @distributed_trace + @api_version_validation(method_added_on='2025-04-01-preview', params_added_on={'2025-04-01-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'filter', 'top', 'skip_token', 'accept']}, api_versions_list=['2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def list_by_fleet( + self, + resource_group_name: str, + fleet_name: str, + *, + filter: Optional[str] = ..., + skip_token: Optional[str] = ..., + top: Optional[int] = ..., + **kwargs: Any + ) -> AsyncItemPaged[Gate]: ... + + + class azure.mgmt.containerservicefleet.aio.operations.Operations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list(self, **kwargs: Any) -> AsyncItemPaged[Operation]: ... + + + class azure.mgmt.containerservicefleet.aio.operations.UpdateRunsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + resource: UpdateRun, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[UpdateRun]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + resource: UpdateRun, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[UpdateRun]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[UpdateRun]: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2023-03-15-preview', params_added_on={'2023-03-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'update_run_name', 'etag', 'match_condition']}, api_versions_list=['2023-03-15-preview', '2023-06-15-preview', '2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + async def begin_delete( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @overload + async def begin_skip( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + body: SkipProperties, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[UpdateRun]: ... + + @overload + async def begin_skip( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + body: SkipProperties, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[UpdateRun]: ... + + @overload + async def begin_skip( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + body: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[UpdateRun]: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2023-03-15-preview', params_added_on={'2023-03-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'update_run_name', 'accept', 'etag', 'match_condition']}, api_versions_list=['2023-03-15-preview', '2023-06-15-preview', '2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + async def begin_start( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[UpdateRun]: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2023-03-15-preview', params_added_on={'2023-03-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'update_run_name', 'accept', 'etag', 'match_condition']}, api_versions_list=['2023-03-15-preview', '2023-06-15-preview', '2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + async def begin_stop( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> AsyncLROPoller[UpdateRun]: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2023-03-15-preview', params_added_on={'2023-03-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'update_run_name', 'accept']}, api_versions_list=['2023-03-15-preview', '2023-06-15-preview', '2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + async def get( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + **kwargs: Any + ) -> UpdateRun: ... + + @distributed_trace + @api_version_validation(method_added_on='2023-03-15-preview', params_added_on={'2023-03-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'top', 'skip_token', 'accept']}, api_versions_list=['2023-03-15-preview', '2023-06-15-preview', '2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def list_by_fleet( + self, + resource_group_name: str, + fleet_name: str, + *, + skip_token: Optional[str] = ..., + top: Optional[int] = ..., + **kwargs: Any + ) -> AsyncItemPaged[UpdateRun]: ... + + +namespace azure.mgmt.containerservicefleet.models + + class azure.mgmt.containerservicefleet.models.APIServerAccessProfile(_Model): + enable_private_cluster: Optional[bool] + enable_vnet_integration: Optional[bool] + subnet_id: Optional[str] + + @overload + def __init__( + self, + *, + enable_private_cluster: Optional[bool] = ..., + enable_vnet_integration: Optional[bool] = ..., + subnet_id: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.ActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INTERNAL = "Internal" + + + class azure.mgmt.containerservicefleet.models.AdoptionPolicy(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ALWAYS = "Always" + IF_IDENTICAL = "IfIdentical" + NEVER = "Never" + + + class azure.mgmt.containerservicefleet.models.Affinity(_Model): + cluster_affinity: Optional[ClusterAffinity] + + @overload + def __init__( + self, + *, + cluster_affinity: Optional[ClusterAffinity] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.AgentProfile(_Model): + subnet_id: Optional[str] + vm_size: Optional[str] + + @overload + def __init__( + self, + *, + subnet_id: Optional[str] = ..., + vm_size: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.AutoUpgradeLastTriggerStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + FAILED = "Failed" + SUCCEEDED = "Succeeded" + + + class azure.mgmt.containerservicefleet.models.AutoUpgradeNodeImageSelection(_Model): + type: Union[str, AutoUpgradeNodeImageSelectionType] + + @overload + def __init__( + self, + *, + type: Union[str, AutoUpgradeNodeImageSelectionType] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.AutoUpgradeNodeImageSelectionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CONSISTENT = "Consistent" + LATEST = "Latest" + + + class azure.mgmt.containerservicefleet.models.AutoUpgradeProfile(ProxyResource): + e_tag: Optional[str] + id: str + name: str + properties: Optional[AutoUpgradeProfileProperties] + system_data: SystemData + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + properties: Optional[AutoUpgradeProfileProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.containerservicefleet.models.AutoUpgradeProfileProperties(_Model): + auto_upgrade_profile_status: Optional[AutoUpgradeProfileStatus] + channel: Union[str, UpgradeChannel] + disabled: Optional[bool] + long_term_support: Optional[bool] + node_image_selection: Optional[AutoUpgradeNodeImageSelection] + provisioning_state: Optional[Union[str, AutoUpgradeProfileProvisioningState]] + target_kubernetes_version: Optional[str] + update_strategy_id: Optional[str] + + @overload + def __init__( + self, + *, + auto_upgrade_profile_status: Optional[AutoUpgradeProfileStatus] = ..., + channel: Union[str, UpgradeChannel], + disabled: Optional[bool] = ..., + long_term_support: Optional[bool] = ..., + node_image_selection: Optional[AutoUpgradeNodeImageSelection] = ..., + target_kubernetes_version: Optional[str] = ..., + update_strategy_id: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.AutoUpgradeProfileProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CANCELED = "Canceled" + FAILED = "Failed" + SUCCEEDED = "Succeeded" + + + class azure.mgmt.containerservicefleet.models.AutoUpgradeProfileStatus(_Model): + last_trigger_error: Optional[ErrorDetail] + last_trigger_status: Optional[Union[str, AutoUpgradeLastTriggerStatus]] + last_trigger_upgrade_versions: Optional[list[str]] + last_triggered_at: Optional[datetime] + + + class azure.mgmt.containerservicefleet.models.ClusterAffinity(_Model): + required_during_scheduling_ignored_during_execution: Optional[ClusterSelector] + + @overload + def __init__( + self, + *, + required_during_scheduling_ignored_during_execution: Optional[ClusterSelector] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.ClusterResourcePlacementSpec(_Model): + policy: Optional[PlacementPolicy] + + @overload + def __init__( + self, + *, + policy: Optional[PlacementPolicy] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.ClusterSelector(_Model): + cluster_selector_terms: list[ClusterSelectorTerm] + + @overload + def __init__( + self, + *, + cluster_selector_terms: list[ClusterSelectorTerm] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.ClusterSelectorTerm(_Model): + label_selector: Optional[LabelSelector] + property_selector: Optional[PropertySelector] + + @overload + def __init__( + self, + *, + label_selector: Optional[LabelSelector] = ..., + property_selector: Optional[PropertySelector] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.CreatedByType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + APPLICATION = "Application" + KEY = "Key" + MANAGED_IDENTITY = "ManagedIdentity" + USER = "User" + + + class azure.mgmt.containerservicefleet.models.DeletePolicy(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DELETE = "Delete" + KEEP = "Keep" + + + class azure.mgmt.containerservicefleet.models.ErrorAdditionalInfo(_Model): + info: Optional[Any] + type: Optional[str] + + + class azure.mgmt.containerservicefleet.models.ErrorDetail(_Model): + additional_info: Optional[list[ErrorAdditionalInfo]] + code: Optional[str] + details: Optional[list[ErrorDetail]] + message: Optional[str] + target: Optional[str] + + + class azure.mgmt.containerservicefleet.models.ErrorResponse(_Model): + error: Optional[ErrorDetail] + + @overload + def __init__( + self, + *, + error: Optional[ErrorDetail] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.Fleet(TrackedResource): + e_tag: Optional[str] + id: str + identity: Optional[ManagedServiceIdentity] + location: str + name: str + properties: Optional[FleetProperties] + system_data: SystemData + tags: dict[str, str] + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + identity: Optional[ManagedServiceIdentity] = ..., + location: str, + properties: Optional[FleetProperties] = ..., + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.containerservicefleet.models.FleetCredentialResult(_Model): + name: Optional[str] + value: Optional[bytes] + + + class azure.mgmt.containerservicefleet.models.FleetCredentialResults(_Model): + kubeconfigs: Optional[list[FleetCredentialResult]] + + + class azure.mgmt.containerservicefleet.models.FleetHubProfile(_Model): + agent_profile: Optional[AgentProfile] + api_server_access_profile: Optional[APIServerAccessProfile] + dns_prefix: Optional[str] + fqdn: Optional[str] + kubernetes_version: Optional[str] + portal_fqdn: Optional[str] + + @overload + def __init__( + self, + *, + agent_profile: Optional[AgentProfile] = ..., + api_server_access_profile: Optional[APIServerAccessProfile] = ..., + dns_prefix: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.FleetManagedNamespace(TrackedResource): + e_tag: Optional[str] + id: str + location: str + name: str + properties: Optional[FleetManagedNamespaceProperties] + system_data: SystemData + tags: dict[str, str] + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + location: str, + properties: Optional[FleetManagedNamespaceProperties] = ..., + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.containerservicefleet.models.FleetManagedNamespacePatch(_Model): + tags: Optional[dict[str, str]] + + @overload + def __init__( + self, + *, + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.FleetManagedNamespaceProperties(_Model): + adoption_policy: Union[str, AdoptionPolicy] + delete_policy: Union[str, DeletePolicy] + managed_namespace_properties: Optional[ManagedNamespaceProperties] + portal_fqdn: Optional[str] + propagation_policy: Optional[PropagationPolicy] + provisioning_state: Optional[Union[str, FleetManagedNamespaceProvisioningState]] + status: Optional[FleetManagedNamespaceStatus] + + @overload + def __init__( + self, + *, + adoption_policy: Union[str, AdoptionPolicy], + delete_policy: Union[str, DeletePolicy], + managed_namespace_properties: Optional[ManagedNamespaceProperties] = ..., + propagation_policy: Optional[PropagationPolicy] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.FleetManagedNamespaceProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CANCELED = "Canceled" + CREATING = "Creating" + DELETING = "Deleting" + FAILED = "Failed" + SUCCEEDED = "Succeeded" + UPDATING = "Updating" + + + class azure.mgmt.containerservicefleet.models.FleetManagedNamespaceStatus(_Model): + last_operation_error: Optional[ErrorDetail] + last_operation_id: Optional[str] + + + class azure.mgmt.containerservicefleet.models.FleetMember(ProxyResource): + e_tag: Optional[str] + id: str + name: str + properties: Optional[FleetMemberProperties] + system_data: SystemData + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + properties: Optional[FleetMemberProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.containerservicefleet.models.FleetMemberProperties(_Model): + cluster_resource_id: str + group: Optional[str] + labels: Optional[dict[str, str]] + provisioning_state: Optional[Union[str, FleetMemberProvisioningState]] + status: Optional[FleetMemberStatus] + + @overload + def __init__( + self, + *, + cluster_resource_id: str, + group: Optional[str] = ..., + labels: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.FleetMemberProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CANCELED = "Canceled" + FAILED = "Failed" + JOINING = "Joining" + LEAVING = "Leaving" + SUCCEEDED = "Succeeded" + UPDATING = "Updating" + + + class azure.mgmt.containerservicefleet.models.FleetMemberStatus(_Model): + last_operation_error: Optional[ErrorDetail] + last_operation_id: Optional[str] + + + class azure.mgmt.containerservicefleet.models.FleetMemberUpdate(_Model): + properties: Optional[FleetMemberUpdateProperties] + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + properties: Optional[FleetMemberUpdateProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.containerservicefleet.models.FleetMemberUpdateProperties(_Model): + group: Optional[str] + labels: Optional[dict[str, str]] + + @overload + def __init__( + self, + *, + group: Optional[str] = ..., + labels: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.FleetPatch(_Model): + identity: Optional[ManagedServiceIdentity] + tags: Optional[dict[str, str]] + + @overload + def __init__( + self, + *, + identity: Optional[ManagedServiceIdentity] = ..., + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.FleetProperties(_Model): + hub_profile: Optional[FleetHubProfile] + provisioning_state: Optional[Union[str, FleetProvisioningState]] + status: Optional[FleetStatus] + + @overload + def __init__( + self, + *, + hub_profile: Optional[FleetHubProfile] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.FleetProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CANCELED = "Canceled" + CREATING = "Creating" + DELETING = "Deleting" + FAILED = "Failed" + SUCCEEDED = "Succeeded" + UPDATING = "Updating" + + + class azure.mgmt.containerservicefleet.models.FleetStatus(_Model): + last_operation_error: Optional[ErrorDetail] + last_operation_id: Optional[str] + + + class azure.mgmt.containerservicefleet.models.FleetUpdateStrategy(ProxyResource): + e_tag: Optional[str] + id: str + name: str + properties: Optional[FleetUpdateStrategyProperties] + system_data: SystemData + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + properties: Optional[FleetUpdateStrategyProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.containerservicefleet.models.FleetUpdateStrategyProperties(_Model): + provisioning_state: Optional[Union[str, FleetUpdateStrategyProvisioningState]] + strategy: UpdateRunStrategy + + @overload + def __init__( + self, + *, + strategy: UpdateRunStrategy + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.FleetUpdateStrategyProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CANCELED = "Canceled" + FAILED = "Failed" + SUCCEEDED = "Succeeded" + + + class azure.mgmt.containerservicefleet.models.Gate(ProxyResource): + e_tag: Optional[str] + id: str + name: str + properties: Optional[GateProperties] + system_data: SystemData + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + properties: Optional[GateProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.containerservicefleet.models.GateConfiguration(_Model): + display_name: Optional[str] + type: Union[str, GateType] + + @overload + def __init__( + self, + *, + display_name: Optional[str] = ..., + type: Union[str, GateType] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.GatePatch(_Model): + properties: GatePatchProperties + + @overload + def __init__( + self, + *, + properties: GatePatchProperties + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.GatePatchProperties(_Model): + state: Union[str, GateState] + + @overload + def __init__( + self, + *, + state: Union[str, GateState] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.GateProperties(_Model): + display_name: Optional[str] + gate_type: Union[str, GateType] + provisioning_state: Optional[Union[str, GateProvisioningState]] + state: Union[str, GateState] + target: GateTarget + + @overload + def __init__( + self, + *, + display_name: Optional[str] = ..., + gate_type: Union[str, GateType], + state: Union[str, GateState], + target: GateTarget + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.GateProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CANCELED = "Canceled" + FAILED = "Failed" + SUCCEEDED = "Succeeded" + + + class azure.mgmt.containerservicefleet.models.GateState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + COMPLETED = "Completed" + PENDING = "Pending" + SKIPPED = "Skipped" + + + class azure.mgmt.containerservicefleet.models.GateTarget(_Model): + id: str + update_run_properties: Optional[UpdateRunGateTargetProperties] + + @overload + def __init__( + self, + *, + id: str, + update_run_properties: Optional[UpdateRunGateTargetProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.GateType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + APPROVAL = "Approval" + + + class azure.mgmt.containerservicefleet.models.GenerateResponse(_Model): + id: str + + + class azure.mgmt.containerservicefleet.models.LabelSelector(_Model): + match_expressions: Optional[list[LabelSelectorRequirement]] + match_labels: Optional[dict[str, str]] + + @overload + def __init__( + self, + *, + match_expressions: Optional[list[LabelSelectorRequirement]] = ..., + match_labels: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.LabelSelectorOperator(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DOES_NOT_EXIST = "DoesNotExist" + EXISTS = "Exists" + IN = "In" + NOT_IN = "NotIn" + + + class azure.mgmt.containerservicefleet.models.LabelSelectorRequirement(_Model): + key: str + operator: Union[str, LabelSelectorOperator] + values_property: Optional[list[str]] + + @overload + def __init__( + self, + *, + key: str, + operator: Union[str, LabelSelectorOperator], + values_property: Optional[list[str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.ManagedClusterUpdate(_Model): + node_image_selection: Optional[NodeImageSelection] + upgrade: ManagedClusterUpgradeSpec + + @overload + def __init__( + self, + *, + node_image_selection: Optional[NodeImageSelection] = ..., + upgrade: ManagedClusterUpgradeSpec + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.ManagedClusterUpgradeSpec(_Model): + kubernetes_version: Optional[str] + type: Union[str, ManagedClusterUpgradeType] + + @overload + def __init__( + self, + *, + kubernetes_version: Optional[str] = ..., + type: Union[str, ManagedClusterUpgradeType] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.ManagedClusterUpgradeType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CONTROL_PLANE_ONLY = "ControlPlaneOnly" + FULL = "Full" + NODE_IMAGE_ONLY = "NodeImageOnly" + + + class azure.mgmt.containerservicefleet.models.ManagedNamespaceProperties(_Model): + annotations: Optional[dict[str, str]] + default_network_policy: Optional[NetworkPolicy] + default_resource_quota: Optional[ResourceQuota] + labels: Optional[dict[str, str]] + + @overload + def __init__( + self, + *, + annotations: Optional[dict[str, str]] = ..., + default_network_policy: Optional[NetworkPolicy] = ..., + default_resource_quota: Optional[ResourceQuota] = ..., + labels: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.ManagedServiceIdentity(_Model): + principal_id: Optional[str] + tenant_id: Optional[str] + type: Union[str, ManagedServiceIdentityType] + user_assigned_identities: Optional[dict[str, UserAssignedIdentity]] + + @overload + def __init__( + self, + *, + type: Union[str, ManagedServiceIdentityType], + user_assigned_identities: Optional[dict[str, UserAssignedIdentity]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.ManagedServiceIdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + NONE = "None" + SYSTEM_ASSIGNED = "SystemAssigned" + SYSTEM_ASSIGNED_USER_ASSIGNED = "SystemAssigned, UserAssigned" + USER_ASSIGNED = "UserAssigned" + + + class azure.mgmt.containerservicefleet.models.MemberUpdateStatus(_Model): + cluster_resource_id: Optional[str] + message: Optional[str] + name: Optional[str] + operation_id: Optional[str] + status: Optional[UpdateStatus] + + + class azure.mgmt.containerservicefleet.models.NetworkPolicy(_Model): + egress: Optional[Union[str, PolicyRule]] + ingress: Optional[Union[str, PolicyRule]] + + @overload + def __init__( + self, + *, + egress: Optional[Union[str, PolicyRule]] = ..., + ingress: Optional[Union[str, PolicyRule]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.NodeImageSelection(_Model): + custom_node_image_versions: Optional[list[NodeImageVersion]] + type: Union[str, NodeImageSelectionType] + + @overload + def __init__( + self, + *, + custom_node_image_versions: Optional[list[NodeImageVersion]] = ..., + type: Union[str, NodeImageSelectionType] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.NodeImageSelectionStatus(_Model): + selected_node_image_versions: Optional[list[NodeImageVersion]] + + + class azure.mgmt.containerservicefleet.models.NodeImageSelectionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CONSISTENT = "Consistent" + CUSTOM = "Custom" + LATEST = "Latest" + + + class azure.mgmt.containerservicefleet.models.NodeImageVersion(_Model): + version: Optional[str] + + + class azure.mgmt.containerservicefleet.models.Operation(_Model): + action_type: Optional[Union[str, ActionType]] + display: Optional[OperationDisplay] + is_data_action: Optional[bool] + name: Optional[str] + origin: Optional[Union[str, Origin]] + + @overload + def __init__( + self, + *, + display: Optional[OperationDisplay] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.OperationDisplay(_Model): + description: Optional[str] + operation: Optional[str] + provider: Optional[str] + resource: Optional[str] + + + class azure.mgmt.containerservicefleet.models.Origin(str, Enum, metaclass=CaseInsensitiveEnumMeta): + SYSTEM = "system" + USER = "user" + USER_SYSTEM = "user,system" + + + class azure.mgmt.containerservicefleet.models.PlacementPolicy(_Model): + affinity: Optional[Affinity] + cluster_names: Optional[list[str]] + placement_type: Optional[Union[str, PlacementType]] + tolerations: Optional[list[Toleration]] + + @overload + def __init__( + self, + *, + affinity: Optional[Affinity] = ..., + cluster_names: Optional[list[str]] = ..., + placement_type: Optional[Union[str, PlacementType]] = ..., + tolerations: Optional[list[Toleration]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.PlacementProfile(_Model): + default_cluster_resource_placement: Optional[ClusterResourcePlacementSpec] + + @overload + def __init__( + self, + *, + default_cluster_resource_placement: Optional[ClusterResourcePlacementSpec] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.PlacementType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + PICK_ALL = "PickAll" + PICK_FIXED = "PickFixed" + + + class azure.mgmt.containerservicefleet.models.PolicyRule(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ALLOW_ALL = "AllowAll" + ALLOW_SAME_NAMESPACE = "AllowSameNamespace" + DENY_ALL = "DenyAll" + + + class azure.mgmt.containerservicefleet.models.PropagationPolicy(_Model): + placement_profile: Optional[PlacementProfile] + type: Union[str, PropagationType] + + @overload + def __init__( + self, + *, + placement_profile: Optional[PlacementProfile] = ..., + type: Union[str, PropagationType] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.PropagationType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + PLACEMENT = "Placement" + + + class azure.mgmt.containerservicefleet.models.PropertySelector(_Model): + match_expressions: list[PropertySelectorRequirement] + + @overload + def __init__( + self, + *, + match_expressions: list[PropertySelectorRequirement] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.PropertySelectorOperator(str, Enum, metaclass=CaseInsensitiveEnumMeta): + EQ = "Eq" + GE = "Ge" + GT = "Gt" + LE = "Le" + LT = "Lt" + NE = "Ne" + + + class azure.mgmt.containerservicefleet.models.PropertySelectorRequirement(_Model): + name: str + operator: Union[str, PropertySelectorOperator] + values_property: list[str] + + @overload + def __init__( + self, + *, + name: str, + operator: Union[str, PropertySelectorOperator], + values_property: list[str] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.ProxyResource(Resource): + id: str + name: str + system_data: SystemData + type: str + + + class azure.mgmt.containerservicefleet.models.Resource(_Model): + id: Optional[str] + name: Optional[str] + system_data: Optional[SystemData] + type: Optional[str] + + + class azure.mgmt.containerservicefleet.models.ResourceQuota(_Model): + cpu_limit: Optional[str] + cpu_request: Optional[str] + memory_limit: Optional[str] + memory_request: Optional[str] + + @overload + def __init__( + self, + *, + cpu_limit: Optional[str] = ..., + cpu_request: Optional[str] = ..., + memory_limit: Optional[str] = ..., + memory_request: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.SkipProperties(_Model): + targets: list[SkipTarget] + + @overload + def __init__( + self, + *, + targets: list[SkipTarget] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.SkipTarget(_Model): + name: str + type: Union[str, TargetType] + + @overload + def __init__( + self, + *, + name: str, + type: Union[str, TargetType] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.SystemData(_Model): + created_at: Optional[datetime] + created_by: Optional[str] + created_by_type: Optional[Union[str, CreatedByType]] + last_modified_at: Optional[datetime] + last_modified_by: Optional[str] + last_modified_by_type: Optional[Union[str, CreatedByType]] + + @overload + def __init__( + self, + *, + created_at: Optional[datetime] = ..., + created_by: Optional[str] = ..., + created_by_type: Optional[Union[str, CreatedByType]] = ..., + last_modified_at: Optional[datetime] = ..., + last_modified_by: Optional[str] = ..., + last_modified_by_type: Optional[Union[str, CreatedByType]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.TaintEffect(str, Enum, metaclass=CaseInsensitiveEnumMeta): + NO_SCHEDULE = "NoSchedule" + + + class azure.mgmt.containerservicefleet.models.TargetType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + AFTER_STAGE_WAIT = "AfterStageWait" + GROUP = "Group" + MEMBER = "Member" + STAGE = "Stage" + + + class azure.mgmt.containerservicefleet.models.Timing(str, Enum, metaclass=CaseInsensitiveEnumMeta): + AFTER = "After" + BEFORE = "Before" + + + class azure.mgmt.containerservicefleet.models.Toleration(_Model): + effect: Optional[Union[str, TaintEffect]] + key: Optional[str] + operator: Optional[Union[str, TolerationOperator]] + value: Optional[str] + + @overload + def __init__( + self, + *, + effect: Optional[Union[str, TaintEffect]] = ..., + key: Optional[str] = ..., + operator: Optional[Union[str, TolerationOperator]] = ..., + value: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.TolerationOperator(str, Enum, metaclass=CaseInsensitiveEnumMeta): + EQUAL = "Equal" + EXISTS = "Exists" + + + class azure.mgmt.containerservicefleet.models.TrackedResource(Resource): + id: str + location: str + name: str + system_data: SystemData + tags: Optional[dict[str, str]] + type: str + + @overload + def __init__( + self, + *, + location: str, + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.UpdateGroup(_Model): + after_gates: Optional[list[GateConfiguration]] + before_gates: Optional[list[GateConfiguration]] + max_concurrency: Optional[str] + name: str + + @overload + def __init__( + self, + *, + after_gates: Optional[list[GateConfiguration]] = ..., + before_gates: Optional[list[GateConfiguration]] = ..., + max_concurrency: Optional[str] = ..., + name: str + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.UpdateGroupStatus(_Model): + after_gates: Optional[list[UpdateRunGateStatus]] + before_gates: Optional[list[UpdateRunGateStatus]] + max_concurrency: Optional[int] + members: Optional[list[MemberUpdateStatus]] + name: Optional[str] + status: Optional[UpdateStatus] + + + class azure.mgmt.containerservicefleet.models.UpdateRun(ProxyResource): + e_tag: Optional[str] + id: str + name: str + properties: Optional[UpdateRunProperties] + system_data: SystemData + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + properties: Optional[UpdateRunProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.containerservicefleet.models.UpdateRunGateStatus(_Model): + display_name: Optional[str] + gate_id: Optional[str] + status: Optional[UpdateStatus] + + + class azure.mgmt.containerservicefleet.models.UpdateRunGateTargetProperties(_Model): + group: Optional[str] + name: str + stage: Optional[str] + timing: Union[str, Timing] + + @overload + def __init__( + self, + *, + timing: Union[str, Timing] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.UpdateRunProperties(_Model): + auto_upgrade_profile_id: Optional[str] + managed_cluster_update: ManagedClusterUpdate + provisioning_state: Optional[Union[str, UpdateRunProvisioningState]] + status: Optional[UpdateRunStatus] + strategy: Optional[UpdateRunStrategy] + update_strategy_id: Optional[str] + + @overload + def __init__( + self, + *, + managed_cluster_update: ManagedClusterUpdate, + strategy: Optional[UpdateRunStrategy] = ..., + update_strategy_id: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.UpdateRunProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CANCELED = "Canceled" + FAILED = "Failed" + SUCCEEDED = "Succeeded" + + + class azure.mgmt.containerservicefleet.models.UpdateRunStatus(_Model): + node_image_selection: Optional[NodeImageSelectionStatus] + stages: Optional[list[UpdateStageStatus]] + status: Optional[UpdateStatus] + + + class azure.mgmt.containerservicefleet.models.UpdateRunStrategy(_Model): + stages: list[UpdateStage] + + @overload + def __init__( + self, + *, + stages: list[UpdateStage] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.UpdateStage(_Model): + after_gates: Optional[list[GateConfiguration]] + after_stage_wait_in_seconds: Optional[int] + before_gates: Optional[list[GateConfiguration]] + groups: Optional[list[UpdateGroup]] + max_concurrency: Optional[str] + name: str + + @overload + def __init__( + self, + *, + after_gates: Optional[list[GateConfiguration]] = ..., + after_stage_wait_in_seconds: Optional[int] = ..., + before_gates: Optional[list[GateConfiguration]] = ..., + groups: Optional[list[UpdateGroup]] = ..., + max_concurrency: Optional[str] = ..., + name: str + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.containerservicefleet.models.UpdateStageStatus(_Model): + after_gates: Optional[list[UpdateRunGateStatus]] + after_stage_wait_status: Optional[WaitStatus] + before_gates: Optional[list[UpdateRunGateStatus]] + groups: Optional[list[UpdateGroupStatus]] + max_concurrency: Optional[int] + name: Optional[str] + status: Optional[UpdateStatus] + + + class azure.mgmt.containerservicefleet.models.UpdateState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + COMPLETED = "Completed" + FAILED = "Failed" + NOT_STARTED = "NotStarted" + PENDING = "Pending" + RUNNING = "Running" + SKIPPED = "Skipped" + STOPPED = "Stopped" + STOPPING = "Stopping" + + + class azure.mgmt.containerservicefleet.models.UpdateStatus(_Model): + completed_time: Optional[datetime] + error: Optional[ErrorDetail] + start_time: Optional[datetime] + state: Optional[Union[str, UpdateState]] + + + class azure.mgmt.containerservicefleet.models.UpgradeChannel(str, Enum, metaclass=CaseInsensitiveEnumMeta): + NODE_IMAGE = "NodeImage" + RAPID = "Rapid" + STABLE = "Stable" + TARGET_KUBERNETES_VERSION = "TargetKubernetesVersion" + + + class azure.mgmt.containerservicefleet.models.UserAssignedIdentity(_Model): + client_id: Optional[str] + principal_id: Optional[str] + + + class azure.mgmt.containerservicefleet.models.WaitStatus(_Model): + status: Optional[UpdateStatus] + wait_duration_in_seconds: Optional[int] + + +namespace azure.mgmt.containerservicefleet.operations + + class azure.mgmt.containerservicefleet.operations.AutoUpgradeProfileOperationsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + @api_version_validation(method_added_on='2025-03-01', params_added_on={'2025-03-01': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'auto_upgrade_profile_name', 'accept']}, api_versions_list=['2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def begin_generate_update_run( + self, + resource_group_name: str, + fleet_name: str, + auto_upgrade_profile_name: str, + **kwargs: Any + ) -> LROPoller[GenerateResponse]: ... + + + class azure.mgmt.containerservicefleet.operations.AutoUpgradeProfilesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + auto_upgrade_profile_name: str, + resource: AutoUpgradeProfile, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[AutoUpgradeProfile]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + auto_upgrade_profile_name: str, + resource: AutoUpgradeProfile, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[AutoUpgradeProfile]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + auto_upgrade_profile_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[AutoUpgradeProfile]: ... + + @distributed_trace + @api_version_validation(method_added_on='2024-05-02-preview', params_added_on={'2024-05-02-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'auto_upgrade_profile_name', 'etag', 'match_condition']}, api_versions_list=['2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def begin_delete( + self, + resource_group_name: str, + fleet_name: str, + auto_upgrade_profile_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[None]: ... + + @distributed_trace + @api_version_validation(method_added_on='2024-05-02-preview', params_added_on={'2024-05-02-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'auto_upgrade_profile_name', 'accept']}, api_versions_list=['2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def get( + self, + resource_group_name: str, + fleet_name: str, + auto_upgrade_profile_name: str, + **kwargs: Any + ) -> AutoUpgradeProfile: ... + + @distributed_trace + @api_version_validation(method_added_on='2024-05-02-preview', params_added_on={'2024-05-02-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'top', 'skip_token', 'accept']}, api_versions_list=['2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def list_by_fleet( + self, + resource_group_name: str, + fleet_name: str, + *, + skip_token: Optional[str] = ..., + top: Optional[int] = ..., + **kwargs: Any + ) -> ItemPaged[AutoUpgradeProfile]: ... + + + class azure.mgmt.containerservicefleet.operations.FleetManagedNamespacesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + resource: FleetManagedNamespace, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetManagedNamespace]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + resource: FleetManagedNamespace, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetManagedNamespace]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetManagedNamespace]: ... + + @distributed_trace + @api_version_validation(method_added_on='2025-08-01-preview', params_added_on={'2025-08-01-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'managed_namespace_name', 'etag', 'match_condition']}, api_versions_list=['2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def begin_delete( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[None]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + properties: FleetManagedNamespacePatch, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetManagedNamespace]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + properties: FleetManagedNamespacePatch, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetManagedNamespace]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetManagedNamespace]: ... + + @distributed_trace + @api_version_validation(method_added_on='2025-08-01-preview', params_added_on={'2025-08-01-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'managed_namespace_name', 'accept']}, api_versions_list=['2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def get( + self, + resource_group_name: str, + fleet_name: str, + managed_namespace_name: str, + **kwargs: Any + ) -> FleetManagedNamespace: ... + + @distributed_trace + @api_version_validation(method_added_on='2025-08-01-preview', params_added_on={'2025-08-01-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'accept']}, api_versions_list=['2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def list_by_fleet( + self, + resource_group_name: str, + fleet_name: str, + **kwargs: Any + ) -> ItemPaged[FleetManagedNamespace]: ... + + + class azure.mgmt.containerservicefleet.operations.FleetMembersOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + resource: FleetMember, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetMember]: ... + + @overload + def begin_create( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + resource: FleetMember, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetMember]: ... + + @overload + def begin_create( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetMember]: ... + + @distributed_trace + def begin_delete( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[None]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + properties: FleetMemberUpdate, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetMember]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + properties: FleetMemberUpdate, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetMember]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetMember]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + fleet_name: str, + fleet_member_name: str, + **kwargs: Any + ) -> FleetMember: ... + + @distributed_trace + def list_by_fleet( + self, + resource_group_name: str, + fleet_name: str, + *, + filter: Optional[str] = ..., + skip_token: Optional[str] = ..., + top: Optional[int] = ..., + **kwargs: Any + ) -> ItemPaged[FleetMember]: ... + + + class azure.mgmt.containerservicefleet.operations.FleetUpdateStrategiesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + update_strategy_name: str, + resource: FleetUpdateStrategy, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetUpdateStrategy]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + update_strategy_name: str, + resource: FleetUpdateStrategy, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetUpdateStrategy]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + update_strategy_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[FleetUpdateStrategy]: ... + + @distributed_trace + @api_version_validation(method_added_on='2023-08-15-preview', params_added_on={'2023-08-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'update_strategy_name', 'etag', 'match_condition']}, api_versions_list=['2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def begin_delete( + self, + resource_group_name: str, + fleet_name: str, + update_strategy_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[None]: ... + + @distributed_trace + @api_version_validation(method_added_on='2023-08-15-preview', params_added_on={'2023-08-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'update_strategy_name', 'accept']}, api_versions_list=['2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def get( + self, + resource_group_name: str, + fleet_name: str, + update_strategy_name: str, + **kwargs: Any + ) -> FleetUpdateStrategy: ... + + @distributed_trace + @api_version_validation(method_added_on='2023-08-15-preview', params_added_on={'2023-08-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'top', 'skip_token', 'accept']}, api_versions_list=['2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def list_by_fleet( + self, + resource_group_name: str, + fleet_name: str, + *, + skip_token: Optional[str] = ..., + top: Optional[int] = ..., + **kwargs: Any + ) -> ItemPaged[FleetUpdateStrategy]: ... + + + class azure.mgmt.containerservicefleet.operations.FleetsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + resource: Fleet, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[Fleet]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + resource: Fleet, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[Fleet]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[Fleet]: ... + + @distributed_trace + def begin_delete( + self, + resource_group_name: str, + fleet_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[None]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + fleet_name: str, + properties: FleetPatch, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[Fleet]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + fleet_name: str, + properties: FleetPatch, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[Fleet]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + fleet_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[Fleet]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + fleet_name: str, + **kwargs: Any + ) -> Fleet: ... + + @distributed_trace + def list_by_resource_group( + self, + resource_group_name: str, + **kwargs: Any + ) -> ItemPaged[Fleet]: ... + + @distributed_trace + def list_by_subscription( + self, + *, + skip_token: Optional[str] = ..., + top: Optional[int] = ..., + **kwargs: Any + ) -> ItemPaged[Fleet]: ... + + @distributed_trace + def list_credentials( + self, + resource_group_name: str, + fleet_name: str, + **kwargs: Any + ) -> FleetCredentialResults: ... + + + class azure.mgmt.containerservicefleet.operations.GatesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_update( + self, + resource_group_name: str, + fleet_name: str, + gate_name: str, + properties: GatePatch, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[Gate]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + fleet_name: str, + gate_name: str, + properties: GatePatch, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[Gate]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + fleet_name: str, + gate_name: str, + properties: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[Gate]: ... + + @distributed_trace + @api_version_validation(method_added_on='2025-04-01-preview', params_added_on={'2025-04-01-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'gate_name', 'accept']}, api_versions_list=['2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def get( + self, + resource_group_name: str, + fleet_name: str, + gate_name: str, + **kwargs: Any + ) -> Gate: ... + + @distributed_trace + @api_version_validation(method_added_on='2025-04-01-preview', params_added_on={'2025-04-01-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'filter', 'top', 'skip_token', 'accept']}, api_versions_list=['2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def list_by_fleet( + self, + resource_group_name: str, + fleet_name: str, + *, + filter: Optional[str] = ..., + skip_token: Optional[str] = ..., + top: Optional[int] = ..., + **kwargs: Any + ) -> ItemPaged[Gate]: ... + + + class azure.mgmt.containerservicefleet.operations.Operations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list(self, **kwargs: Any) -> ItemPaged[Operation]: ... + + + class azure.mgmt.containerservicefleet.operations.UpdateRunsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + resource: UpdateRun, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[UpdateRun]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + resource: UpdateRun, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[UpdateRun]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + resource: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[UpdateRun]: ... + + @distributed_trace + @api_version_validation(method_added_on='2023-03-15-preview', params_added_on={'2023-03-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'update_run_name', 'etag', 'match_condition']}, api_versions_list=['2023-03-15-preview', '2023-06-15-preview', '2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def begin_delete( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[None]: ... + + @overload + def begin_skip( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + body: SkipProperties, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[UpdateRun]: ... + + @overload + def begin_skip( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + body: SkipProperties, + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[UpdateRun]: ... + + @overload + def begin_skip( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + body: IO[bytes], + *, + content_type: str = "application/json", + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[UpdateRun]: ... + + @distributed_trace + @api_version_validation(method_added_on='2023-03-15-preview', params_added_on={'2023-03-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'update_run_name', 'accept', 'etag', 'match_condition']}, api_versions_list=['2023-03-15-preview', '2023-06-15-preview', '2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def begin_start( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[UpdateRun]: ... + + @distributed_trace + @api_version_validation(method_added_on='2023-03-15-preview', params_added_on={'2023-03-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'update_run_name', 'accept', 'etag', 'match_condition']}, api_versions_list=['2023-03-15-preview', '2023-06-15-preview', '2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def begin_stop( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + *, + etag: Optional[str] = ..., + match_condition: Optional[MatchConditions] = ..., + **kwargs: Any + ) -> LROPoller[UpdateRun]: ... + + @distributed_trace + @api_version_validation(method_added_on='2023-03-15-preview', params_added_on={'2023-03-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'update_run_name', 'accept']}, api_versions_list=['2023-03-15-preview', '2023-06-15-preview', '2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def get( + self, + resource_group_name: str, + fleet_name: str, + update_run_name: str, + **kwargs: Any + ) -> UpdateRun: ... + + @distributed_trace + @api_version_validation(method_added_on='2023-03-15-preview', params_added_on={'2023-03-15-preview': ['api_version', 'subscription_id', 'resource_group_name', 'fleet_name', 'top', 'skip_token', 'accept']}, api_versions_list=['2023-03-15-preview', '2023-06-15-preview', '2023-08-15-preview', '2023-10-15', '2024-02-02-preview', '2024-04-01', '2024-05-02-preview', '2025-03-01', '2025-04-01-preview', '2025-08-01-preview', '2026-02-01-preview', '2026-03-02-preview', '2026-06-01']) + def list_by_fleet( + self, + resource_group_name: str, + fleet_name: str, + *, + skip_token: Optional[str] = ..., + top: Optional[int] = ..., + **kwargs: Any + ) -> ItemPaged[UpdateRun]: ... + + +namespace azure.mgmt.containerservicefleet.types + + class azure.mgmt.containerservicefleet.types.APIServerAccessProfile(TypedDict, total=False): + key "enablePrivateCluster": bool + key "enableVnetIntegration": bool + key "subnetId": str + enablePrivateCluster: bool + enableVnetIntegration: bool + subnetId: str + + + class azure.mgmt.containerservicefleet.types.Affinity(TypedDict, total=False): + key "clusterAffinity": ForwardRef('ClusterAffinity', module='types') + clusterAffinity: ClusterAffinity + + + class azure.mgmt.containerservicefleet.types.AgentProfile(TypedDict, total=False): + key "subnetId": str + key "vmSize": str + subnetId: str + vmSize: str + + + class azure.mgmt.containerservicefleet.types.AutoUpgradeNodeImageSelection(TypedDict, total=False): + key "type": Required[Union[str, AutoUpgradeNodeImageSelectionType]] + type: Union[str, AutoUpgradeNodeImageSelectionType] + + + class azure.mgmt.containerservicefleet.types.AutoUpgradeProfile(ProxyResource): + key "eTag": str + key "id": str + key "name": str + key "properties": ForwardRef('AutoUpgradeProfileProperties', module='types') + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + eTag: str + id: str + name: str + properties: AutoUpgradeProfileProperties + systemData: SystemData + type: str + + + class azure.mgmt.containerservicefleet.types.AutoUpgradeProfileProperties(TypedDict, total=False): + key "autoUpgradeProfileStatus": ForwardRef('AutoUpgradeProfileStatus', module='types') + key "channel": Required[Union[str, UpgradeChannel]] + key "disabled": bool + key "longTermSupport": bool + key "nodeImageSelection": ForwardRef('AutoUpgradeNodeImageSelection', module='types') + key "provisioningState": Union[str, AutoUpgradeProfileProvisioningState] + key "targetKubernetesVersion": str + key "updateStrategyId": str + autoUpgradeProfileStatus: AutoUpgradeProfileStatus + channel: Union[str, UpgradeChannel] + disabled: bool + longTermSupport: bool + nodeImageSelection: AutoUpgradeNodeImageSelection + provisioningState: Union[str, AutoUpgradeProfileProvisioningState] + targetKubernetesVersion: str + updateStrategyId: str + + + class azure.mgmt.containerservicefleet.types.AutoUpgradeProfileStatus(TypedDict, total=False): + key "lastTriggerError": ForwardRef('ErrorDetail', module='types') + key "lastTriggerStatus": Union[str, AutoUpgradeLastTriggerStatus] + key "lastTriggeredAt": str + lastTriggerError: ErrorDetail + lastTriggerStatus: Union[str, AutoUpgradeLastTriggerStatus] + lastTriggerUpgradeVersions: list[str] + lastTriggeredAt: str + + + class azure.mgmt.containerservicefleet.types.ClusterAffinity(TypedDict, total=False): + key "requiredDuringSchedulingIgnoredDuringExecution": ForwardRef('ClusterSelector', module='types') + requiredDuringSchedulingIgnoredDuringExecution: ClusterSelector + + + class azure.mgmt.containerservicefleet.types.ClusterResourcePlacementSpec(TypedDict, total=False): + key "policy": ForwardRef('PlacementPolicy', module='types') + policy: PlacementPolicy + + + class azure.mgmt.containerservicefleet.types.ClusterSelector(TypedDict, total=False): + key "clusterSelectorTerms": Required[list[ClusterSelectorTerm]] + clusterSelectorTerms: list[ClusterSelectorTerm] + + + class azure.mgmt.containerservicefleet.types.ClusterSelectorTerm(TypedDict, total=False): + key "labelSelector": ForwardRef('LabelSelector', module='types') + key "propertySelector": ForwardRef('PropertySelector', module='types') + labelSelector: LabelSelector + propertySelector: PropertySelector + + + class azure.mgmt.containerservicefleet.types.ErrorAdditionalInfo(TypedDict, total=False): + key "info": Any + key "type": str + info: Any + type: str + + + class azure.mgmt.containerservicefleet.types.ErrorDetail(TypedDict, total=False): + key "code": str + key "message": str + key "target": str + additionalInfo: list[ErrorAdditionalInfo] + code: str + details: list[ErrorDetail] + message: str + target: str + + + class azure.mgmt.containerservicefleet.types.Fleet(TrackedResource): + key "eTag": str + key "id": str + key "identity": ForwardRef('ManagedServiceIdentity', module='types') + key "location": Required[str] + key "name": str + key "properties": ForwardRef('FleetProperties', module='types') + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + eTag: str + id: str + identity: ManagedServiceIdentity + location: str + name: str + properties: FleetProperties + systemData: SystemData + tags: dict[str, str] + type: str + + + class azure.mgmt.containerservicefleet.types.FleetHubProfile(TypedDict, total=False): + key "agentProfile": ForwardRef('AgentProfile', module='types') + key "apiServerAccessProfile": ForwardRef('APIServerAccessProfile', module='types') + key "dnsPrefix": str + key "fqdn": str + key "kubernetesVersion": str + key "portalFqdn": str + agentProfile: AgentProfile + apiServerAccessProfile: APIServerAccessProfile + dnsPrefix: str + fqdn: str + kubernetesVersion: str + portalFqdn: str + + + class azure.mgmt.containerservicefleet.types.FleetManagedNamespace(TrackedResource): + key "eTag": str + key "id": str + key "location": Required[str] + key "name": str + key "properties": ForwardRef('FleetManagedNamespaceProperties', module='types') + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + eTag: str + id: str + location: str + name: str + properties: FleetManagedNamespaceProperties + systemData: SystemData + tags: dict[str, str] + type: str + + + class azure.mgmt.containerservicefleet.types.FleetManagedNamespacePatch(TypedDict, total=False): + tags: dict[str, str] + + + class azure.mgmt.containerservicefleet.types.FleetManagedNamespaceProperties(TypedDict, total=False): + key "adoptionPolicy": Required[Union[str, AdoptionPolicy]] + key "deletePolicy": Required[Union[str, DeletePolicy]] + key "managedNamespaceProperties": ForwardRef('ManagedNamespaceProperties', module='types') + key "portalFqdn": str + key "propagationPolicy": ForwardRef('PropagationPolicy', module='types') + key "provisioningState": Union[str, FleetManagedNamespaceProvisioningState] + key "status": ForwardRef('FleetManagedNamespaceStatus', module='types') + adoptionPolicy: Union[str, AdoptionPolicy] + deletePolicy: Union[str, DeletePolicy] + managedNamespaceProperties: ManagedNamespaceProperties + portalFqdn: str + propagationPolicy: PropagationPolicy + provisioningState: Union[str, FleetManagedNamespaceProvisioningState] + status: FleetManagedNamespaceStatus + + + class azure.mgmt.containerservicefleet.types.FleetManagedNamespaceStatus(TypedDict, total=False): + key "lastOperationError": ForwardRef('ErrorDetail', module='types') + key "lastOperationId": str + lastOperationError: ErrorDetail + lastOperationId: str + + + class azure.mgmt.containerservicefleet.types.FleetMember(ProxyResource): + key "eTag": str + key "id": str + key "name": str + key "properties": ForwardRef('FleetMemberProperties', module='types') + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + eTag: str + id: str + name: str + properties: FleetMemberProperties + systemData: SystemData + type: str + + + class azure.mgmt.containerservicefleet.types.FleetMemberProperties(TypedDict, total=False): + key "clusterResourceId": Required[str] + key "group": str + key "provisioningState": Union[str, FleetMemberProvisioningState] + key "status": ForwardRef('FleetMemberStatus', module='types') + clusterResourceId: str + group: str + labels: dict[str, str] + provisioningState: Union[str, FleetMemberProvisioningState] + status: FleetMemberStatus + + + class azure.mgmt.containerservicefleet.types.FleetMemberStatus(TypedDict, total=False): + key "lastOperationError": ForwardRef('ErrorDetail', module='types') + key "lastOperationId": str + lastOperationError: ErrorDetail + lastOperationId: str + + + class azure.mgmt.containerservicefleet.types.FleetMemberUpdate(TypedDict, total=False): + key "properties": ForwardRef('FleetMemberUpdateProperties', module='types') + properties: FleetMemberUpdateProperties + + + class azure.mgmt.containerservicefleet.types.FleetMemberUpdateProperties(TypedDict, total=False): + key "group": str + group: str + labels: dict[str, str] + + + class azure.mgmt.containerservicefleet.types.FleetPatch(TypedDict, total=False): + key "identity": ForwardRef('ManagedServiceIdentity', module='types') + identity: ManagedServiceIdentity + tags: dict[str, str] + + + class azure.mgmt.containerservicefleet.types.FleetProperties(TypedDict, total=False): + key "hubProfile": ForwardRef('FleetHubProfile', module='types') + key "provisioningState": Union[str, FleetProvisioningState] + key "status": ForwardRef('FleetStatus', module='types') + hubProfile: FleetHubProfile + provisioningState: Union[str, FleetProvisioningState] + status: FleetStatus + + + class azure.mgmt.containerservicefleet.types.FleetStatus(TypedDict, total=False): + key "lastOperationError": ForwardRef('ErrorDetail', module='types') + key "lastOperationId": str + lastOperationError: ErrorDetail + lastOperationId: str + + + class azure.mgmt.containerservicefleet.types.FleetUpdateStrategy(ProxyResource): + key "eTag": str + key "id": str + key "name": str + key "properties": ForwardRef('FleetUpdateStrategyProperties', module='types') + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + eTag: str + id: str + name: str + properties: FleetUpdateStrategyProperties + systemData: SystemData + type: str + + + class azure.mgmt.containerservicefleet.types.FleetUpdateStrategyProperties(TypedDict, total=False): + key "provisioningState": Union[str, FleetUpdateStrategyProvisioningState] + key "strategy": Required[UpdateRunStrategy] + provisioningState: Union[str, FleetUpdateStrategyProvisioningState] + strategy: UpdateRunStrategy + + + class azure.mgmt.containerservicefleet.types.GateConfiguration(TypedDict, total=False): + key "displayName": str + key "type": Required[Union[str, GateType]] + displayName: str + type: Union[str, GateType] + + + class azure.mgmt.containerservicefleet.types.GatePatch(TypedDict, total=False): + key "properties": Required[GatePatchProperties] + properties: GatePatchProperties + + + class azure.mgmt.containerservicefleet.types.GatePatchProperties(TypedDict, total=False): + key "state": Required[Union[str, GateState]] + state: Union[str, GateState] + + + class azure.mgmt.containerservicefleet.types.LabelSelector(TypedDict, total=False): + matchExpressions: list[LabelSelectorRequirement] + matchLabels: dict[str, str] + + + class azure.mgmt.containerservicefleet.types.LabelSelectorRequirement(TypedDict, total=False): + key "key": Required[str] + key "operator": Required[Union[str, LabelSelectorOperator]] + key: str + operator: Union[str, LabelSelectorOperator] + values: list[str] + + + class azure.mgmt.containerservicefleet.types.ManagedClusterUpdate(TypedDict, total=False): + key "nodeImageSelection": ForwardRef('NodeImageSelection', module='types') + key "upgrade": Required[ManagedClusterUpgradeSpec] + nodeImageSelection: NodeImageSelection + upgrade: ManagedClusterUpgradeSpec + + + class azure.mgmt.containerservicefleet.types.ManagedClusterUpgradeSpec(TypedDict, total=False): + key "kubernetesVersion": str + key "type": Required[Union[str, ManagedClusterUpgradeType]] + kubernetesVersion: str + type: Union[str, ManagedClusterUpgradeType] + + + class azure.mgmt.containerservicefleet.types.ManagedNamespaceProperties(TypedDict, total=False): + key "defaultNetworkPolicy": ForwardRef('NetworkPolicy', module='types') + key "defaultResourceQuota": ForwardRef('ResourceQuota', module='types') + annotations: dict[str, str] + defaultNetworkPolicy: NetworkPolicy + defaultResourceQuota: ResourceQuota + labels: dict[str, str] + + + class azure.mgmt.containerservicefleet.types.ManagedServiceIdentity(TypedDict, total=False): + key "principalId": str + key "tenantId": str + key "type": Required[Union[str, ManagedServiceIdentityType]] + principalId: str + tenantId: str + type: Union[str, ManagedServiceIdentityType] + userAssignedIdentities: dict[str, UserAssignedIdentity] + + + class azure.mgmt.containerservicefleet.types.MemberUpdateStatus(TypedDict, total=False): + key "clusterResourceId": str + key "message": str + key "name": str + key "operationId": str + key "status": ForwardRef('UpdateStatus', module='types') + clusterResourceId: str + message: str + name: str + operationId: str + status: UpdateStatus + + + class azure.mgmt.containerservicefleet.types.NetworkPolicy(TypedDict, total=False): + key "egress": Union[str, PolicyRule] + key "ingress": Union[str, PolicyRule] + egress: Union[str, PolicyRule] + ingress: Union[str, PolicyRule] + + + class azure.mgmt.containerservicefleet.types.NodeImageSelection(TypedDict, total=False): + key "type": Required[Union[str, NodeImageSelectionType]] + customNodeImageVersions: list[NodeImageVersion] + type: Union[str, NodeImageSelectionType] + + + class azure.mgmt.containerservicefleet.types.NodeImageSelectionStatus(TypedDict, total=False): + selectedNodeImageVersions: list[NodeImageVersion] + + + class azure.mgmt.containerservicefleet.types.NodeImageVersion(TypedDict, total=False): + key "version": str + version: str + + + class azure.mgmt.containerservicefleet.types.PlacementPolicy(TypedDict, total=False): + key "affinity": ForwardRef('Affinity', module='types') + key "placementType": Union[str, PlacementType] + affinity: Affinity + clusterNames: list[str] + placementType: Union[str, PlacementType] + tolerations: list[Toleration] + + + class azure.mgmt.containerservicefleet.types.PlacementProfile(TypedDict, total=False): + key "defaultClusterResourcePlacement": ForwardRef('ClusterResourcePlacementSpec', module='types') + defaultClusterResourcePlacement: ClusterResourcePlacementSpec + + + class azure.mgmt.containerservicefleet.types.PropagationPolicy(TypedDict, total=False): + key "placementProfile": ForwardRef('PlacementProfile', module='types') + key "type": Required[Union[str, PropagationType]] + placementProfile: PlacementProfile + type: Union[str, PropagationType] + + + class azure.mgmt.containerservicefleet.types.PropertySelector(TypedDict, total=False): + key "matchExpressions": Required[list[PropertySelectorRequirement]] + matchExpressions: list[PropertySelectorRequirement] + + + class azure.mgmt.containerservicefleet.types.PropertySelectorRequirement(TypedDict, total=False): + key "name": Required[str] + key "operator": Required[Union[str, PropertySelectorOperator]] + key "values": Required[list[str]] + name: str + operator: Union[str, PropertySelectorOperator] + values: list[str] + + + class azure.mgmt.containerservicefleet.types.ProxyResource(Resource): + key "id": str + key "name": str + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + name: str + systemData: SystemData + type: str + + + class azure.mgmt.containerservicefleet.types.Resource(TypedDict, total=False): + key "id": str + key "name": str + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + name: str + systemData: SystemData + type: str + + + class azure.mgmt.containerservicefleet.types.ResourceQuota(TypedDict, total=False): + key "cpuLimit": str + key "cpuRequest": str + key "memoryLimit": str + key "memoryRequest": str + cpuLimit: str + cpuRequest: str + memoryLimit: str + memoryRequest: str + + + class azure.mgmt.containerservicefleet.types.SkipProperties(TypedDict, total=False): + key "targets": Required[list[SkipTarget]] + targets: list[SkipTarget] + + + class azure.mgmt.containerservicefleet.types.SkipTarget(TypedDict, total=False): + key "name": Required[str] + key "type": Required[Union[str, TargetType]] + name: str + type: Union[str, TargetType] + + + class azure.mgmt.containerservicefleet.types.SystemData(TypedDict, total=False): + key "createdAt": str + key "createdBy": str + key "createdByType": Union[str, CreatedByType] + key "lastModifiedAt": str + key "lastModifiedBy": str + key "lastModifiedByType": Union[str, CreatedByType] + createdAt: str + createdBy: str + createdByType: Union[str, CreatedByType] + lastModifiedAt: str + lastModifiedBy: str + lastModifiedByType: Union[str, CreatedByType] + + + class azure.mgmt.containerservicefleet.types.Toleration(TypedDict, total=False): + key "effect": Union[str, TaintEffect] + key "key": str + key "operator": Union[str, TolerationOperator] + key "value": str + effect: Union[str, TaintEffect] + key: str + operator: Union[str, TolerationOperator] + value: str + + + class azure.mgmt.containerservicefleet.types.TrackedResource(Resource): + key "id": str + key "location": Required[str] + key "name": str + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + location: str + name: str + systemData: SystemData + tags: dict[str, str] + type: str + + + class azure.mgmt.containerservicefleet.types.UpdateGroup(TypedDict, total=False): + key "maxConcurrency": str + key "name": Required[str] + afterGates: list[GateConfiguration] + beforeGates: list[GateConfiguration] + maxConcurrency: str + name: str + + + class azure.mgmt.containerservicefleet.types.UpdateGroupStatus(TypedDict, total=False): + key "maxConcurrency": int + key "name": str + key "status": ForwardRef('UpdateStatus', module='types') + afterGates: list[UpdateRunGateStatus] + beforeGates: list[UpdateRunGateStatus] + maxConcurrency: int + members: list[MemberUpdateStatus] + name: str + status: UpdateStatus + + + class azure.mgmt.containerservicefleet.types.UpdateRun(ProxyResource): + key "eTag": str + key "id": str + key "name": str + key "properties": ForwardRef('UpdateRunProperties', module='types') + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + eTag: str + id: str + name: str + properties: UpdateRunProperties + systemData: SystemData + type: str + + + class azure.mgmt.containerservicefleet.types.UpdateRunGateStatus(TypedDict, total=False): + key "displayName": str + key "gateId": str + key "status": ForwardRef('UpdateStatus', module='types') + displayName: str + gateId: str + status: UpdateStatus + + + class azure.mgmt.containerservicefleet.types.UpdateRunProperties(TypedDict, total=False): + key "autoUpgradeProfileId": str + key "managedClusterUpdate": Required[ManagedClusterUpdate] + key "provisioningState": Union[str, UpdateRunProvisioningState] + key "status": ForwardRef('UpdateRunStatus', module='types') + key "strategy": ForwardRef('UpdateRunStrategy', module='types') + key "updateStrategyId": str + autoUpgradeProfileId: str + managedClusterUpdate: ManagedClusterUpdate + provisioningState: Union[str, UpdateRunProvisioningState] + status: UpdateRunStatus + strategy: UpdateRunStrategy + updateStrategyId: str + + + class azure.mgmt.containerservicefleet.types.UpdateRunStatus(TypedDict, total=False): + key "nodeImageSelection": ForwardRef('NodeImageSelectionStatus', module='types') + key "status": ForwardRef('UpdateStatus', module='types') + nodeImageSelection: NodeImageSelectionStatus + stages: list[UpdateStageStatus] + status: UpdateStatus + + + class azure.mgmt.containerservicefleet.types.UpdateRunStrategy(TypedDict, total=False): + key "stages": Required[list[UpdateStage]] + stages: list[UpdateStage] + + + class azure.mgmt.containerservicefleet.types.UpdateStage(TypedDict, total=False): + key "afterStageWaitInSeconds": int + key "maxConcurrency": str + key "name": Required[str] + afterGates: list[GateConfiguration] + afterStageWaitInSeconds: int + beforeGates: list[GateConfiguration] + groups: list[UpdateGroup] + maxConcurrency: str + name: str + + + class azure.mgmt.containerservicefleet.types.UpdateStageStatus(TypedDict, total=False): + key "afterStageWaitStatus": ForwardRef('WaitStatus', module='types') + key "maxConcurrency": int + key "name": str + key "status": ForwardRef('UpdateStatus', module='types') + afterGates: list[UpdateRunGateStatus] + afterStageWaitStatus: WaitStatus + beforeGates: list[UpdateRunGateStatus] + groups: list[UpdateGroupStatus] + maxConcurrency: int + name: str + status: UpdateStatus + + + class azure.mgmt.containerservicefleet.types.UpdateStatus(TypedDict, total=False): + key "completedTime": str + key "error": ForwardRef('ErrorDetail', module='types') + key "startTime": str + key "state": Union[str, UpdateState] + completedTime: str + error: ErrorDetail + startTime: str + state: Union[str, UpdateState] + + + class azure.mgmt.containerservicefleet.types.UserAssignedIdentity(TypedDict, total=False): + key "clientId": str + key "principalId": str + clientId: str + principalId: str + + + class azure.mgmt.containerservicefleet.types.WaitStatus(TypedDict, total=False): + key "status": ForwardRef('UpdateStatus', module='types') + key "waitDurationInSeconds": int + status: UpdateStatus + waitDurationInSeconds: int + + +``` \ No newline at end of file diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/api.metadata.yml b/sdk/containerservice/azure-mgmt-containerservicefleet/api.metadata.yml new file mode 100644 index 000000000000..c59b8a8e7bbf --- /dev/null +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/api.metadata.yml @@ -0,0 +1,3 @@ +apiMdSha256: 9da19610851910ae30c7b3cdb1609beaee3f16c05ccb5173f45453020f7909e8 +parserVersion: 0.3.30 +pythonVersion: 3.13.14 diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/apiview-properties.json b/sdk/containerservice/azure-mgmt-containerservicefleet/apiview-properties.json index ee0177855560..7d33f2fe08f2 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/apiview-properties.json +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/apiview-properties.json @@ -10,11 +10,7 @@ "azure.mgmt.containerservicefleet.models.AutoUpgradeProfile": "Microsoft.ContainerService.AutoUpgradeProfile", "azure.mgmt.containerservicefleet.models.AutoUpgradeProfileProperties": "Microsoft.ContainerService.AutoUpgradeProfileProperties", "azure.mgmt.containerservicefleet.models.AutoUpgradeProfileStatus": "Microsoft.ContainerService.AutoUpgradeProfileStatus", - "azure.mgmt.containerservicefleet.models.CiliumProperties": "Microsoft.ContainerService.CiliumProperties", "azure.mgmt.containerservicefleet.models.ClusterAffinity": "Placement.V1.ClusterAffinity", - "azure.mgmt.containerservicefleet.models.ClusterMeshProfile": "Microsoft.ContainerService.ClusterMeshProfile", - "azure.mgmt.containerservicefleet.models.ClusterMeshProfileProperties": "Microsoft.ContainerService.ClusterMeshProfileProperties", - "azure.mgmt.containerservicefleet.models.ClusterMeshProfileStatus": "Microsoft.ContainerService.ClusterMeshProfileStatus", "azure.mgmt.containerservicefleet.models.ClusterResourcePlacementSpec": "Placement.V1.ClusterResourcePlacementSpec", "azure.mgmt.containerservicefleet.models.ClusterSelector": "Placement.V1.ClusterSelector", "azure.mgmt.containerservicefleet.models.ClusterSelectorTerm": "Placement.V1.ClusterSelectorTerm", @@ -53,10 +49,7 @@ "azure.mgmt.containerservicefleet.models.ManagedClusterUpgradeSpec": "Microsoft.ContainerService.ManagedClusterUpgradeSpec", "azure.mgmt.containerservicefleet.models.ManagedNamespaceProperties": "Microsoft.ContainerService.ManagedNamespaceProperties", "azure.mgmt.containerservicefleet.models.ManagedServiceIdentity": "Azure.ResourceManager.Legacy.ManagedServiceIdentityV4", - "azure.mgmt.containerservicefleet.models.MemberSelector": "Microsoft.ContainerService.MemberSelector", "azure.mgmt.containerservicefleet.models.MemberUpdateStatus": "Microsoft.ContainerService.MemberUpdateStatus", - "azure.mgmt.containerservicefleet.models.MeshMemberStatus": "Microsoft.ContainerService.MeshMemberStatus", - "azure.mgmt.containerservicefleet.models.MeshProperties": "Microsoft.ContainerService.MeshProperties", "azure.mgmt.containerservicefleet.models.NetworkPolicy": "Microsoft.ContainerService.NetworkPolicy", "azure.mgmt.containerservicefleet.models.NodeImageSelection": "Microsoft.ContainerService.NodeImageSelection", "azure.mgmt.containerservicefleet.models.NodeImageSelectionStatus": "Microsoft.ContainerService.NodeImageSelectionStatus", @@ -89,12 +82,9 @@ "azure.mgmt.containerservicefleet.models.Origin": "Azure.ResourceManager.CommonTypes.Origin", "azure.mgmt.containerservicefleet.models.ActionType": "Azure.ResourceManager.CommonTypes.ActionType", "azure.mgmt.containerservicefleet.models.CreatedByType": "Azure.ResourceManager.CommonTypes.createdByType", - "azure.mgmt.containerservicefleet.models.ClusterMeshProfileProvisioningState": "Microsoft.ContainerService.ClusterMeshProfileProvisioningState", - "azure.mgmt.containerservicefleet.models.ClusterMeshState": "Microsoft.ContainerService.ClusterMeshState", "azure.mgmt.containerservicefleet.models.FleetProvisioningState": "Microsoft.ContainerService.FleetProvisioningState", "azure.mgmt.containerservicefleet.models.ManagedServiceIdentityType": "Azure.ResourceManager.Legacy.ManagedServiceIdentityType", "azure.mgmt.containerservicefleet.models.FleetMemberProvisioningState": "Microsoft.ContainerService.FleetMemberProvisioningState", - "azure.mgmt.containerservicefleet.models.MeshMemberState": "Microsoft.ContainerService.MeshMemberState", "azure.mgmt.containerservicefleet.models.FleetManagedNamespaceProvisioningState": "Microsoft.ContainerService.FleetManagedNamespaceProvisioningState", "azure.mgmt.containerservicefleet.models.PolicyRule": "Microsoft.ContainerService.PolicyRule", "azure.mgmt.containerservicefleet.models.AdoptionPolicy": "Microsoft.ContainerService.AdoptionPolicy", @@ -121,16 +111,6 @@ "azure.mgmt.containerservicefleet.models.AutoUpgradeLastTriggerStatus": "Microsoft.ContainerService.AutoUpgradeLastTriggerStatus", "azure.mgmt.containerservicefleet.operations.Operations.list": "Azure.ResourceManager.Operations.list", "azure.mgmt.containerservicefleet.aio.operations.Operations.list": "Azure.ResourceManager.Operations.list", - "azure.mgmt.containerservicefleet.operations.ClusterMeshProfilesOperations.get": "Microsoft.ContainerService.ClusterMeshProfiles.get", - "azure.mgmt.containerservicefleet.aio.operations.ClusterMeshProfilesOperations.get": "Microsoft.ContainerService.ClusterMeshProfiles.get", - "azure.mgmt.containerservicefleet.operations.ClusterMeshProfilesOperations.begin_create_or_update": "Microsoft.ContainerService.ClusterMeshProfiles.createOrUpdate", - "azure.mgmt.containerservicefleet.aio.operations.ClusterMeshProfilesOperations.begin_create_or_update": "Microsoft.ContainerService.ClusterMeshProfiles.createOrUpdate", - "azure.mgmt.containerservicefleet.operations.ClusterMeshProfilesOperations.begin_delete": "Microsoft.ContainerService.ClusterMeshProfiles.delete", - "azure.mgmt.containerservicefleet.aio.operations.ClusterMeshProfilesOperations.begin_delete": "Microsoft.ContainerService.ClusterMeshProfiles.delete", - "azure.mgmt.containerservicefleet.operations.ClusterMeshProfilesOperations.list_by_fleet": "Microsoft.ContainerService.ClusterMeshProfiles.listByFleet", - "azure.mgmt.containerservicefleet.aio.operations.ClusterMeshProfilesOperations.list_by_fleet": "Microsoft.ContainerService.ClusterMeshProfiles.listByFleet", - "azure.mgmt.containerservicefleet.operations.ClusterMeshProfilesOperations.begin_apply": "Microsoft.ContainerService.ClusterMeshProfiles.apply", - "azure.mgmt.containerservicefleet.aio.operations.ClusterMeshProfilesOperations.begin_apply": "Microsoft.ContainerService.ClusterMeshProfiles.apply", "azure.mgmt.containerservicefleet.operations.FleetsOperations.get": "Microsoft.ContainerService.Fleets.get", "azure.mgmt.containerservicefleet.aio.operations.FleetsOperations.get": "Microsoft.ContainerService.Fleets.get", "azure.mgmt.containerservicefleet.operations.FleetsOperations.begin_create_or_update": "Microsoft.ContainerService.Fleets.create", @@ -204,5 +184,5 @@ "azure.mgmt.containerservicefleet.operations.AutoUpgradeProfileOperationsOperations.begin_generate_update_run": "Microsoft.ContainerService.AutoUpgradeProfileOperations.generateUpdateRun", "azure.mgmt.containerservicefleet.aio.operations.AutoUpgradeProfileOperationsOperations.begin_generate_update_run": "Microsoft.ContainerService.AutoUpgradeProfileOperations.generateUpdateRun" }, - "CrossLanguageVersion": "0f77f98b69c7" + "CrossLanguageVersion": "d42627c730d2" } \ No newline at end of file diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_client.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_client.py index 003072a12ace..c7dce9383ad7 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_client.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_client.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -22,7 +23,6 @@ from .operations import ( AutoUpgradeProfileOperationsOperations, AutoUpgradeProfilesOperations, - ClusterMeshProfilesOperations, FleetManagedNamespacesOperations, FleetMembersOperations, FleetUpdateStrategiesOperations, @@ -42,14 +42,11 @@ from azure.core.credentials import TokenCredential -class ContainerServiceFleetMgmtClient: # pylint: disable=too-many-instance-attributes +class ContainerServiceFleetMgmtClient: # pylint: disable=too-many-instance-attributes,docstring-keyword-should-match-keyword-only """Azure Kubernetes Fleet Manager api client. :ivar operations: Operations operations :vartype operations: azure.mgmt.containerservicefleet.operations.Operations - :ivar cluster_mesh_profiles: ClusterMeshProfilesOperations operations - :vartype cluster_mesh_profiles: - azure.mgmt.containerservicefleet.operations.ClusterMeshProfilesOperations :ivar fleets: FleetsOperations operations :vartype fleets: azure.mgmt.containerservicefleet.operations.FleetsOperations :ivar fleet_members: FleetMembersOperations operations @@ -79,10 +76,9 @@ class ContainerServiceFleetMgmtClient: # pylint: disable=too-many-instance-attr :keyword cloud_setting: The cloud setting for which to get the ARM endpoint. Default value is None. :paramtype cloud_setting: ~azure.core.AzureClouds - :keyword api_version: The API version to use for this operation. Known values are - "2026-03-02-preview" and None. Default value is None. If not set, the operation's default API - version will be used. Note that overriding this default value may result in unsupported - behavior. + :keyword api_version: The API version to use for this operation. Known values are "2026-06-01" + and None. Default value is None. If not set, the operation's default API version will be used. + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. @@ -136,9 +132,6 @@ def __init__( self._deserialize = Deserializer() self._serialize.client_side_validation = False self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) - self.cluster_mesh_profiles = ClusterMeshProfilesOperations( - self._client, self._config, self._serialize, self._deserialize - ) self.fleets = FleetsOperations(self._client, self._config, self._serialize, self._deserialize) self.fleet_members = FleetMembersOperations(self._client, self._config, self._serialize, self._deserialize) self.fleet_managed_namespaces = FleetManagedNamespacesOperations( diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_configuration.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_configuration.py index af1ba60a4525..edb24edcc51b 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_configuration.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_configuration.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -18,7 +19,7 @@ from azure.core.credentials import TokenCredential -class ContainerServiceFleetMgmtClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long +class ContainerServiceFleetMgmtClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long,docstring-keyword-should-match-keyword-only """Configuration for ContainerServiceFleetMgmtClient. Note that all parameters used to create this instance are saved as instance @@ -33,10 +34,9 @@ class ContainerServiceFleetMgmtClientConfiguration: # pylint: disable=too-many- :param cloud_setting: The cloud setting for which to get the ARM endpoint. Default value is None. :type cloud_setting: ~azure.core.AzureClouds - :keyword api_version: The API version to use for this operation. Known values are - "2026-03-02-preview" and None. Default value is None. If not set, the operation's default API - version will be used. Note that overriding this default value may result in unsupported - behavior. + :keyword api_version: The API version to use for this operation. Known values are "2026-06-01" + and None. Default value is None. If not set, the operation's default API version will be used. + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ @@ -48,7 +48,7 @@ def __init__( cloud_setting: Optional["AzureClouds"] = None, **kwargs: Any ) -> None: - api_version: str = kwargs.pop("api_version", "2026-03-02-preview") + api_version: str = kwargs.pop("api_version", "2026-06-01") if credential is None: raise ValueError("Parameter 'credential' must not be None.") diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_patch.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_patch.py index ea765788358a..87676c65a8f0 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_patch.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_patch.py @@ -8,6 +8,7 @@ Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ + __all__: list[str] = [] # Add all objects you want publicly available to users at this package level diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_utils/model_base.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_utils/model_base.py index bd5b9caf1022..88aaf1823543 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_utils/model_base.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_utils/model_base.py @@ -109,6 +109,29 @@ def _serialize_bytes(o, format: typing.Optional[str] = None) -> str: return encoded +def _serialize_duration(td: timedelta, format: typing.Optional[str] = None): + """Serialize a timedelta to its wire representation. + + For the ``seconds``/``milliseconds`` encodings the value is converted to a + numeric value, otherwise it falls back to an ISO 8601 duration string. + + :param timedelta td: The timedelta to serialize. + :param str format: The duration encoding format. + :rtype: int or float or str + :return: serialized duration + """ + seconds = td.total_seconds() + if format == "duration-seconds-int": + return int(seconds) + if format == "duration-seconds-float": + return seconds + if format == "duration-milliseconds-int": + return int(seconds * 1000) + if format == "duration-milliseconds-float": + return seconds * 1000 + return _timedelta_as_isostr(td) + + def _serialize_datetime(o, format: typing.Optional[str] = None): if hasattr(o, "year") and hasattr(o, "hour"): if format == "rfc7231": @@ -135,7 +158,15 @@ def _is_readonly(p): class SdkJSONEncoder(JSONEncoder): - """A JSON encoder that's capable of serializing datetime objects and bytes.""" + """A JSON encoder that's capable of serializing datetime objects and bytes. + + :param args: Additional positional arguments passed to the base ``JSONEncoder``. + :type args: typing.Any + :keyword exclude_readonly: Whether to exclude readonly properties. Defaults to False. + :paramtype exclude_readonly: bool + :keyword format: The format to use for serialization. Defaults to None. + :paramtype format: typing.Optional[str] + """ def __init__(self, *args, exclude_readonly: bool = False, format: typing.Optional[str] = None, **kwargs): super().__init__(*args, **kwargs) @@ -301,6 +332,12 @@ def _deserialize_duration(attr): return isodate.parse_duration(attr) +def _deserialize_duration_numeric(attr, unit): + if isinstance(attr, timedelta): + return attr + return timedelta(**{unit: float(attr)}) + + def _deserialize_decimal(attr): if isinstance(attr, decimal.Decimal): return attr @@ -313,6 +350,12 @@ def _deserialize_int_as_str(attr): return int(attr) +def _deserialize_bool_as_str(attr): + if isinstance(attr, bool): + return attr + return attr.lower() == "true" + + _DESERIALIZE_MAPPING = { datetime: _deserialize_datetime, date: _deserialize_date, @@ -330,12 +373,18 @@ def _deserialize_int_as_str(attr): "unix-timestamp": _deserialize_datetime_unix_timestamp, "base64": _deserialize_bytes, "base64url": _deserialize_bytes_base64, + "duration-seconds-int": functools.partial(_deserialize_duration_numeric, unit="seconds"), + "duration-seconds-float": functools.partial(_deserialize_duration_numeric, unit="seconds"), + "duration-milliseconds-int": functools.partial(_deserialize_duration_numeric, unit="milliseconds"), + "duration-milliseconds-float": functools.partial(_deserialize_duration_numeric, unit="milliseconds"), } def get_deserializer(annotation: typing.Any, rf: typing.Optional["_RestField"] = None): if annotation is int and rf and rf._format == "str": return _deserialize_int_as_str + if annotation is bool and rf and rf._format == "str": + return _deserialize_bool_as_str if annotation is str and rf and rf._format in _ARRAY_ENCODE_MAPPING: return functools.partial(_deserialize_array_encoded, _ARRAY_ENCODE_MAPPING[rf._format]) if rf and rf._format: @@ -425,21 +474,21 @@ def __ne__(self, other: typing.Any) -> bool: def keys(self) -> typing.KeysView[str]: """ - :returns: a set-like object providing a view on D's keys + :returns: a set-like object providing a view on the mapping's keys :rtype: ~typing.KeysView """ return self._data.keys() def values(self) -> typing.ValuesView[typing.Any]: """ - :returns: an object providing a view on D's values + :returns: an object providing a view on the mapping's values :rtype: ~typing.ValuesView """ return self._data.values() def items(self) -> typing.ItemsView[str, typing.Any]: """ - :returns: set-like object providing a view on D's items + :returns: a set-like object providing a view on the mapping's items :rtype: ~typing.ItemsView """ return self._data.items() @@ -449,7 +498,7 @@ def get(self, key: str, default: typing.Any = None) -> typing.Any: Get the value for key if key is in the dictionary, else default. :param str key: The key to look up. :param any default: The value to return if key is not in the dictionary. Defaults to None - :returns: D[k] if k in D, else d. + :returns: The value for key if key is in the dictionary, else default. :rtype: any """ try: @@ -484,19 +533,19 @@ def popitem(self) -> tuple[str, typing.Any]: Removes and returns some (key, value) pair :returns: The (key, value) pair. :rtype: tuple - :raises KeyError: if D is empty. + :raises KeyError: if the dictionary is empty. """ return self._data.popitem() def clear(self) -> None: """ - Remove all items from D. + Remove all items from the dictionary. """ self._data.clear() def update(self, *args: typing.Any, **kwargs: typing.Any) -> None: # pylint: disable=arguments-differ """ - Updates D from mapping/iterable E and F. + Update the dictionary from a mapping or an iterable of key-value pairs. :param any args: Either a mapping object or an iterable of key-value pairs. """ self._data.update(*args, **kwargs) @@ -509,10 +558,11 @@ def setdefault(self, key: str, default: typing.Any) -> typing.Any: ... # pylint def setdefault(self, key: str, default: typing.Any = _UNSET) -> typing.Any: """ - Same as calling D.get(k, d), and setting D[k]=d if k not found + Return the value for key if key is in the dictionary; otherwise set the key to + default and return default. :param str key: The key to look up. :param any default: The value to set if key is not in the dictionary - :returns: D[k] if k in D, else d. + :returns: The value for key if key is in the dictionary, else default. :rtype: any """ if default is _UNSET: @@ -564,7 +614,7 @@ def _serialize(o, format: typing.Optional[str] = None): # pylint: disable=too-m pass # Last, try datetime.timedelta try: - return _timedelta_as_isostr(o) + return _serialize_duration(o, format) except AttributeError: # This will be raised when it hits value.total_seconds in the method above pass diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_utils/serialization.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_utils/serialization.py index a088671e9c51..ae08f9d89f74 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_utils/serialization.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_utils/serialization.py @@ -480,7 +480,11 @@ def _decode_attribute_map_key(key): class Serializer: # pylint: disable=too-many-public-methods - """Request object model serializer.""" + """Request object model serializer. + + :param classes: Mapping of model names to model types, used to resolve models during serialization. + :type classes: typing.Optional[typing.Mapping[str, type]] + """ basic_types = {str: "str", int: "int", bool: "bool", float: "float"} @@ -520,6 +524,10 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: "rfc-1123": Serializer.serialize_rfc, "unix-time": Serializer.serialize_unix, "duration": Serializer.serialize_duration, + "duration-seconds-int": Serializer.serialize_duration_seconds_int, + "duration-seconds-float": Serializer.serialize_duration_seconds_float, + "duration-milliseconds-int": Serializer.serialize_duration_milliseconds_int, + "duration-milliseconds-float": Serializer.serialize_duration_milliseconds_float, "date": Serializer.serialize_date, "time": Serializer.serialize_time, "decimal": Serializer.serialize_decimal, @@ -1109,6 +1117,61 @@ def serialize_duration(attr, **kwargs): # pylint: disable=unused-argument attr = isodate.parse_duration(attr) return isodate.duration_isoformat(attr) + @staticmethod + def _serialize_duration_numeric(attr, scale, as_int): + """Serialize a TimeDelta into a numeric value scaled to the wire unit. + + :param TimeDelta attr: Object to be serialized. + :param int scale: Multiplier applied to total seconds (1 for seconds, 1000 for milliseconds). + :param bool as_int: Whether to truncate the result to an int. + :rtype: int or float + :return: serialized duration + """ + if isinstance(attr, str): + attr = isodate.parse_duration(attr) + value = attr.total_seconds() * scale if isinstance(attr, datetime.timedelta) else attr + return int(value) if as_int else float(value) + + @staticmethod + def serialize_duration_seconds_int(attr, **kwargs): # pylint: disable=unused-argument + """Serialize TimeDelta object into an integer number of seconds. + + :param TimeDelta attr: Object to be serialized. + :rtype: int + :return: serialized duration + """ + return Serializer._serialize_duration_numeric(attr, 1, True) + + @staticmethod + def serialize_duration_seconds_float(attr, **kwargs): # pylint: disable=unused-argument + """Serialize TimeDelta object into a floating point number of seconds. + + :param TimeDelta attr: Object to be serialized. + :rtype: float + :return: serialized duration + """ + return Serializer._serialize_duration_numeric(attr, 1, False) + + @staticmethod + def serialize_duration_milliseconds_int(attr, **kwargs): # pylint: disable=unused-argument + """Serialize TimeDelta object into an integer number of milliseconds. + + :param TimeDelta attr: Object to be serialized. + :rtype: int + :return: serialized duration + """ + return Serializer._serialize_duration_numeric(attr, 1000, True) + + @staticmethod + def serialize_duration_milliseconds_float(attr, **kwargs): # pylint: disable=unused-argument + """Serialize TimeDelta object into a floating point number of milliseconds. + + :param TimeDelta attr: Object to be serialized. + :rtype: float + :return: serialized duration + """ + return Serializer._serialize_duration_numeric(attr, 1000, False) + @staticmethod def serialize_rfc(attr, **kwargs): # pylint: disable=unused-argument """Serialize Datetime object into RFC-1123 formatted string. @@ -1381,6 +1444,10 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: "rfc-1123": Deserializer.deserialize_rfc, "unix-time": Deserializer.deserialize_unix, "duration": Deserializer.deserialize_duration, + "duration-seconds-int": Deserializer.deserialize_duration_seconds, + "duration-seconds-float": Deserializer.deserialize_duration_seconds, + "duration-milliseconds-int": Deserializer.deserialize_duration_milliseconds, + "duration-milliseconds-float": Deserializer.deserialize_duration_milliseconds, "date": Deserializer.deserialize_date, "time": Deserializer.deserialize_time, "decimal": Deserializer.deserialize_decimal, @@ -1393,6 +1460,10 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: } self.deserialize_expected_types = { "duration": (isodate.Duration, datetime.timedelta), + "duration-seconds-int": (isodate.Duration, datetime.timedelta), + "duration-seconds-float": (isodate.Duration, datetime.timedelta), + "duration-milliseconds-int": (isodate.Duration, datetime.timedelta), + "duration-milliseconds-float": (isodate.Duration, datetime.timedelta), "iso-8601": (datetime.datetime), } self.dependencies: dict[str, type] = dict(classes) if classes else {} @@ -1954,6 +2025,48 @@ def deserialize_duration(attr): raise DeserializationError(msg) from err return duration + @staticmethod + def _deserialize_duration_numeric(attr, unit): + """Deserialize a numeric duration value into a TimeDelta object. + + :param float attr: response value to be deserialized. + :param str unit: The wire unit, used as the ``timedelta`` keyword + (``"seconds"`` or ``"milliseconds"``). + :return: Deserialized duration + :rtype: TimeDelta + :raises DeserializationError: if value is invalid. + """ + if isinstance(attr, ET.Element): + attr = attr.text + try: + duration = datetime.timedelta(**{unit: float(attr)}) # type: ignore + except (ValueError, OverflowError, TypeError) as err: + msg = "Cannot deserialize duration object." + raise DeserializationError(msg) from err + return duration + + @staticmethod + def deserialize_duration_seconds(attr): + """Deserialize a numeric number of seconds into a TimeDelta object. + + :param float attr: response value to be deserialized. + :return: Deserialized duration + :rtype: TimeDelta + :raises DeserializationError: if value is invalid. + """ + return Deserializer._deserialize_duration_numeric(attr, "seconds") + + @staticmethod + def deserialize_duration_milliseconds(attr): + """Deserialize a numeric number of milliseconds into a TimeDelta object. + + :param float attr: response value to be deserialized. + :return: Deserialized duration + :rtype: TimeDelta + :raises DeserializationError: if value is invalid. + """ + return Deserializer._deserialize_duration_numeric(attr, "milliseconds") + @staticmethod def deserialize_date(attr): """Deserialize ISO-8601 formatted string into Date object. diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_version.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_version.py index 1ddada2289f6..4594e838eeb4 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_version.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "4.0.0b4" +VERSION = "4.0.0" diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/_client.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/_client.py index 3da4dfe3c235..26183ae3acae 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/_client.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/_client.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -22,7 +23,6 @@ from .operations import ( AutoUpgradeProfileOperationsOperations, AutoUpgradeProfilesOperations, - ClusterMeshProfilesOperations, FleetManagedNamespacesOperations, FleetMembersOperations, FleetUpdateStrategiesOperations, @@ -42,14 +42,11 @@ from azure.core.credentials_async import AsyncTokenCredential -class ContainerServiceFleetMgmtClient: # pylint: disable=too-many-instance-attributes +class ContainerServiceFleetMgmtClient: # pylint: disable=too-many-instance-attributes,docstring-keyword-should-match-keyword-only """Azure Kubernetes Fleet Manager api client. :ivar operations: Operations operations :vartype operations: azure.mgmt.containerservicefleet.aio.operations.Operations - :ivar cluster_mesh_profiles: ClusterMeshProfilesOperations operations - :vartype cluster_mesh_profiles: - azure.mgmt.containerservicefleet.aio.operations.ClusterMeshProfilesOperations :ivar fleets: FleetsOperations operations :vartype fleets: azure.mgmt.containerservicefleet.aio.operations.FleetsOperations :ivar fleet_members: FleetMembersOperations operations @@ -79,10 +76,9 @@ class ContainerServiceFleetMgmtClient: # pylint: disable=too-many-instance-attr :keyword cloud_setting: The cloud setting for which to get the ARM endpoint. Default value is None. :paramtype cloud_setting: ~azure.core.AzureClouds - :keyword api_version: The API version to use for this operation. Known values are - "2026-03-02-preview" and None. Default value is None. If not set, the operation's default API - version will be used. Note that overriding this default value may result in unsupported - behavior. + :keyword api_version: The API version to use for this operation. Known values are "2026-06-01" + and None. Default value is None. If not set, the operation's default API version will be used. + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. @@ -138,9 +134,6 @@ def __init__( self._deserialize = Deserializer() self._serialize.client_side_validation = False self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) - self.cluster_mesh_profiles = ClusterMeshProfilesOperations( - self._client, self._config, self._serialize, self._deserialize - ) self.fleets = FleetsOperations(self._client, self._config, self._serialize, self._deserialize) self.fleet_members = FleetMembersOperations(self._client, self._config, self._serialize, self._deserialize) self.fleet_managed_namespaces = FleetManagedNamespacesOperations( diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/_configuration.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/_configuration.py index 8bd022d5cfba..1b517ad55d38 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/_configuration.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/_configuration.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -18,7 +19,7 @@ from azure.core.credentials_async import AsyncTokenCredential -class ContainerServiceFleetMgmtClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long +class ContainerServiceFleetMgmtClientConfiguration: # pylint: disable=too-many-instance-attributes,name-too-long,docstring-keyword-should-match-keyword-only """Configuration for ContainerServiceFleetMgmtClient. Note that all parameters used to create this instance are saved as instance @@ -33,10 +34,9 @@ class ContainerServiceFleetMgmtClientConfiguration: # pylint: disable=too-many- :param cloud_setting: The cloud setting for which to get the ARM endpoint. Default value is None. :type cloud_setting: ~azure.core.AzureClouds - :keyword api_version: The API version to use for this operation. Known values are - "2026-03-02-preview" and None. Default value is None. If not set, the operation's default API - version will be used. Note that overriding this default value may result in unsupported - behavior. + :keyword api_version: The API version to use for this operation. Known values are "2026-06-01" + and None. Default value is None. If not set, the operation's default API version will be used. + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ @@ -48,7 +48,7 @@ def __init__( cloud_setting: Optional["AzureClouds"] = None, **kwargs: Any ) -> None: - api_version: str = kwargs.pop("api_version", "2026-03-02-preview") + api_version: str = kwargs.pop("api_version", "2026-06-01") if credential is None: raise ValueError("Parameter 'credential' must not be None.") diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/_patch.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/_patch.py index ea765788358a..87676c65a8f0 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/_patch.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/_patch.py @@ -8,6 +8,7 @@ Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ + __all__: list[str] = [] # Add all objects you want publicly available to users at this package level diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/operations/__init__.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/operations/__init__.py index 0ceec5058a9b..4c46bb360e8d 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/operations/__init__.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/operations/__init__.py @@ -13,7 +13,6 @@ from ._patch import * # pylint: disable=unused-wildcard-import from ._operations import Operations # type: ignore -from ._operations import ClusterMeshProfilesOperations # type: ignore from ._operations import FleetsOperations # type: ignore from ._operations import FleetMembersOperations # type: ignore from ._operations import FleetManagedNamespacesOperations # type: ignore @@ -29,7 +28,6 @@ __all__ = [ "Operations", - "ClusterMeshProfilesOperations", "FleetsOperations", "FleetMembersOperations", "FleetManagedNamespacesOperations", diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/operations/_operations.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/operations/_operations.py index 8b6dd89c100e..a9046c4d7122 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/operations/_operations.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/operations/_operations.py @@ -34,7 +34,7 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling -from ... import models as _models +from ... import models as _models, types as _types from ..._utils.model_base import SdkJSONEncoder, _deserialize, _failsafe_deserialize from ..._utils.serialization import Deserializer, Serializer from ..._validation import api_version_validation @@ -44,11 +44,6 @@ build_auto_upgrade_profiles_delete_request, build_auto_upgrade_profiles_get_request, build_auto_upgrade_profiles_list_by_fleet_request, - build_cluster_mesh_profiles_apply_request, - build_cluster_mesh_profiles_create_or_update_request, - build_cluster_mesh_profiles_delete_request, - build_cluster_mesh_profiles_get_request, - build_cluster_mesh_profiles_list_by_fleet_request, build_fleet_managed_namespaces_create_or_update_request, build_fleet_managed_namespaces_delete_request, build_fleet_managed_namespaces_get_request, @@ -86,11 +81,10 @@ T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, dict[str, Any]], Any]] -JSON = MutableMapping[str, Any] List = list -class Operations: +class Operations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -203,930 +197,7 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) -class ClusterMeshProfilesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.containerservicefleet.aio.ContainerServiceFleetMgmtClient`'s - :attr:`cluster_mesh_profiles` attribute. - """ - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: ContainerServiceFleetMgmtClientConfiguration = ( - input_args.pop(0) if input_args else kwargs.pop("config") - ) - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "fleet_name", - "cluster_mesh_profile_name", - "accept", - ] - }, - api_versions_list=["2026-03-02-preview"], - ) - async def get( - self, resource_group_name: str, fleet_name: str, cluster_mesh_profile_name: str, **kwargs: Any - ) -> _models.ClusterMeshProfile: - """Get a ClusterMeshProfile. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :param cluster_mesh_profile_name: The name of the ClusterMeshProfile resource. Required. - :type cluster_mesh_profile_name: str - :return: ClusterMeshProfile. The ClusterMeshProfile is compatible with MutableMapping - :rtype: ~azure.mgmt.containerservicefleet.models.ClusterMeshProfile - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.ClusterMeshProfile] = kwargs.pop("cls", None) - - _request = build_cluster_mesh_profiles_get_request( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - cluster_mesh_profile_name=cluster_mesh_profile_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _decompress = kwargs.pop("decompress", True) - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - if _stream: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize( - _models.ErrorResponse, - response, - ) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() if _decompress else response.iter_raw() - else: - deserialized = _deserialize(_models.ClusterMeshProfile, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "fleet_name", - "cluster_mesh_profile_name", - "content_type", - "accept", - "etag", - "match_condition", - ] - }, - api_versions_list=["2026-03-02-preview"], - ) - async def _create_or_update_initial( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - resource: Union[_models.ClusterMeshProfile, JSON, IO[bytes]], - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - if match_condition == MatchConditions.IfNotModified: - error_map[412] = ResourceModifiedError - elif match_condition == MatchConditions.IfPresent: - error_map[412] = ResourceNotFoundError - elif match_condition == MatchConditions.IfMissing: - error_map[412] = ResourceExistsError - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _content = None - if isinstance(resource, (IOBase, bytes)): - _content = resource - else: - _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore - - _request = build_cluster_mesh_profiles_create_or_update_request( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - cluster_mesh_profile_name=cluster_mesh_profile_name, - subscription_id=self._config.subscription_id, - etag=etag, - match_condition=match_condition, - content_type=content_type, - api_version=self._config.api_version, - content=_content, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _decompress = kwargs.pop("decompress", True) - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize( - _models.ErrorResponse, - response, - ) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 201: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() if _decompress else response.iter_raw() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - resource: _models.ClusterMeshProfile, - *, - content_type: str = "application/json", - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> AsyncLROPoller[_models.ClusterMeshProfile]: - """Create a ClusterMeshProfile. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :param cluster_mesh_profile_name: The name of the ClusterMeshProfile resource. Required. - :type cluster_mesh_profile_name: str - :param resource: Resource create parameters. Required. - :type resource: ~azure.mgmt.containerservicefleet.models.ClusterMeshProfile - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is - None. - :paramtype etag: str - :keyword match_condition: The match condition to use upon the etag. Default value is None. - :paramtype match_condition: ~azure.core.MatchConditions - :return: An instance of AsyncLROPoller that returns ClusterMeshProfile. The ClusterMeshProfile - is compatible with MutableMapping - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.containerservicefleet.models.ClusterMeshProfile] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - resource: JSON, - *, - content_type: str = "application/json", - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> AsyncLROPoller[_models.ClusterMeshProfile]: - """Create a ClusterMeshProfile. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :param cluster_mesh_profile_name: The name of the ClusterMeshProfile resource. Required. - :type cluster_mesh_profile_name: str - :param resource: Resource create parameters. Required. - :type resource: JSON - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is - None. - :paramtype etag: str - :keyword match_condition: The match condition to use upon the etag. Default value is None. - :paramtype match_condition: ~azure.core.MatchConditions - :return: An instance of AsyncLROPoller that returns ClusterMeshProfile. The ClusterMeshProfile - is compatible with MutableMapping - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.containerservicefleet.models.ClusterMeshProfile] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def begin_create_or_update( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - resource: IO[bytes], - *, - content_type: str = "application/json", - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> AsyncLROPoller[_models.ClusterMeshProfile]: - """Create a ClusterMeshProfile. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :param cluster_mesh_profile_name: The name of the ClusterMeshProfile resource. Required. - :type cluster_mesh_profile_name: str - :param resource: Resource create parameters. Required. - :type resource: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is - None. - :paramtype etag: str - :keyword match_condition: The match condition to use upon the etag. Default value is None. - :paramtype match_condition: ~azure.core.MatchConditions - :return: An instance of AsyncLROPoller that returns ClusterMeshProfile. The ClusterMeshProfile - is compatible with MutableMapping - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.containerservicefleet.models.ClusterMeshProfile] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "fleet_name", - "cluster_mesh_profile_name", - "content_type", - "accept", - "etag", - "match_condition", - ] - }, - api_versions_list=["2026-03-02-preview"], - ) - async def begin_create_or_update( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - resource: Union[_models.ClusterMeshProfile, JSON, IO[bytes]], - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> AsyncLROPoller[_models.ClusterMeshProfile]: - """Create a ClusterMeshProfile. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :param cluster_mesh_profile_name: The name of the ClusterMeshProfile resource. Required. - :type cluster_mesh_profile_name: str - :param resource: Resource create parameters. Is one of the following types: ClusterMeshProfile, - JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.containerservicefleet.models.ClusterMeshProfile or JSON or - IO[bytes] - :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is - None. - :paramtype etag: str - :keyword match_condition: The match condition to use upon the etag. Default value is None. - :paramtype match_condition: ~azure.core.MatchConditions - :return: An instance of AsyncLROPoller that returns ClusterMeshProfile. The ClusterMeshProfile - is compatible with MutableMapping - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.containerservicefleet.models.ClusterMeshProfile] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ClusterMeshProfile] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._create_or_update_initial( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - cluster_mesh_profile_name=cluster_mesh_profile_name, - resource=resource, - etag=etag, - match_condition=match_condition, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - response = pipeline_response.http_response - deserialized = _deserialize(_models.ClusterMeshProfile, response.json()) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: AsyncPollingMethod = cast( - AsyncPollingMethod, AsyncARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.ClusterMeshProfile].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.ClusterMeshProfile]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "fleet_name", - "cluster_mesh_profile_name", - "etag", - "match_condition", - ] - }, - api_versions_list=["2026-03-02-preview"], - ) - async def _delete_initial( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - if match_condition == MatchConditions.IfNotModified: - error_map[412] = ResourceModifiedError - elif match_condition == MatchConditions.IfPresent: - error_map[412] = ResourceNotFoundError - elif match_condition == MatchConditions.IfMissing: - error_map[412] = ResourceExistsError - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_cluster_mesh_profiles_delete_request( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - cluster_mesh_profile_name=cluster_mesh_profile_name, - subscription_id=self._config.subscription_id, - etag=etag, - match_condition=match_condition, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _decompress = kwargs.pop("decompress", True) - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202, 204]: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize( - _models.ErrorResponse, - response, - ) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() if _decompress else response.iter_raw() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "fleet_name", - "cluster_mesh_profile_name", - "etag", - "match_condition", - ] - }, - api_versions_list=["2026-03-02-preview"], - ) - async def begin_delete( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> AsyncLROPoller[None]: - """Delete a ClusterMeshProfile. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :param cluster_mesh_profile_name: The name of the ClusterMeshProfile resource. Required. - :type cluster_mesh_profile_name: str - :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is - None. - :paramtype etag: str - :keyword match_condition: The match condition to use upon the etag. Default value is None. - :paramtype match_condition: ~azure.core.MatchConditions - :return: An instance of AsyncLROPoller that returns None - :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._delete_initial( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - cluster_mesh_profile_name=cluster_mesh_profile_name, - etag=etag, - match_condition=match_condition, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: AsyncPollingMethod = cast( - AsyncPollingMethod, AsyncARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore - - @distributed_trace - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": ["api_version", "subscription_id", "resource_group_name", "fleet_name", "accept"] - }, - api_versions_list=["2026-03-02-preview"], - ) - def list_by_fleet( - self, resource_group_name: str, fleet_name: str, **kwargs: Any - ) -> AsyncItemPaged["_models.ClusterMeshProfile"]: - """List ClusterMeshProfile resources by Fleet. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :return: An iterator like instance of ClusterMeshProfile - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.containerservicefleet.models.ClusterMeshProfile] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.ClusterMeshProfile]] = kwargs.pop("cls", None) - - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_cluster_mesh_profiles_list_by_fleet_request( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - _request = HttpRequest( - "GET", - urllib.parse.urljoin(next_link, _parsed_next_link.path), - headers=_headers, - params=_next_request_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - return _request - - async def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize( - List[_models.ClusterMeshProfile], - deserialized.get("value", []), - ) - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, AsyncList(list_of_elem) - - async def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize( - _models.ErrorResponse, - response, - ) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return AsyncItemPaged(get_next, extract_data) - - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "fleet_name", - "cluster_mesh_profile_name", - "accept", - "etag", - "match_condition", - ] - }, - api_versions_list=["2026-03-02-preview"], - ) - async def _apply_initial( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> AsyncIterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - if match_condition == MatchConditions.IfNotModified: - error_map[412] = ResourceModifiedError - elif match_condition == MatchConditions.IfPresent: - error_map[412] = ResourceNotFoundError - elif match_condition == MatchConditions.IfMissing: - error_map[412] = ResourceExistsError - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _request = build_cluster_mesh_profiles_apply_request( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - cluster_mesh_profile_name=cluster_mesh_profile_name, - subscription_id=self._config.subscription_id, - etag=etag, - match_condition=match_condition, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _decompress = kwargs.pop("decompress", True) - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize( - _models.ErrorResponse, - response, - ) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() if _decompress else response.iter_raw() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "fleet_name", - "cluster_mesh_profile_name", - "accept", - "etag", - "match_condition", - ] - }, - api_versions_list=["2026-03-02-preview"], - ) - async def begin_apply( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> AsyncLROPoller[_models.ClusterMeshProfile]: - """Applies the cluster mesh profile to selected fleet members. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :param cluster_mesh_profile_name: The name of the ClusterMeshProfile resource. Required. - :type cluster_mesh_profile_name: str - :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is - None. - :paramtype etag: str - :keyword match_condition: The match condition to use upon the etag. Default value is None. - :paramtype match_condition: ~azure.core.MatchConditions - :return: An instance of AsyncLROPoller that returns ClusterMeshProfile. The ClusterMeshProfile - is compatible with MutableMapping - :rtype: - ~azure.core.polling.AsyncLROPoller[~azure.mgmt.containerservicefleet.models.ClusterMeshProfile] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.ClusterMeshProfile] = kwargs.pop("cls", None) - polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = await self._apply_initial( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - cluster_mesh_profile_name=cluster_mesh_profile_name, - etag=etag, - match_condition=match_condition, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - await raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - response = pipeline_response.http_response - deserialized = _deserialize(_models.ClusterMeshProfile, response.json()) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: AsyncPollingMethod = cast( - AsyncPollingMethod, AsyncARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) - else: - polling_method = polling - if cont_token: - return AsyncLROPoller[_models.ClusterMeshProfile].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return AsyncLROPoller[_models.ClusterMeshProfile]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - -class FleetsOperations: +class FleetsOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -1219,7 +290,7 @@ async def _begin_create_or_update_initial( self, resource_group_name: str, fleet_name: str, - resource: Union[_models.Fleet, JSON, IO[bytes]], + resource: Union[_models.Fleet, _types.Fleet, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -1340,7 +411,7 @@ async def begin_create_or_update( self, resource_group_name: str, fleet_name: str, - resource: JSON, + resource: _types.Fleet, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -1355,7 +426,7 @@ async def begin_create_or_update( :param fleet_name: The name of the Fleet resource. Required. :type fleet_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.containerservicefleet.types.Fleet :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -1410,7 +481,7 @@ async def begin_create_or_update( self, resource_group_name: str, fleet_name: str, - resource: Union[_models.Fleet, JSON, IO[bytes]], + resource: Union[_models.Fleet, _types.Fleet, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -1423,9 +494,10 @@ async def begin_create_or_update( :type resource_group_name: str :param fleet_name: The name of the Fleet resource. Required. :type fleet_name: str - :param resource: Resource create parameters. Is one of the following types: Fleet, JSON, - IO[bytes] Required. - :type resource: ~azure.mgmt.containerservicefleet.models.Fleet or JSON or IO[bytes] + :param resource: Resource create parameters. Is either a Fleet type or a IO[bytes] type. + Required. + :type resource: ~azure.mgmt.containerservicefleet.models.Fleet or + ~azure.mgmt.containerservicefleet.types.Fleet or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -1516,13 +588,14 @@ def get_long_running_output(pipeline_response): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def _begin_update_initial( self, resource_group_name: str, fleet_name: str, - properties: Union[_models.FleetPatch, JSON, IO[bytes]], + properties: Union[_models.FleetPatch, _types.FleetPatch, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -1644,7 +717,7 @@ async def begin_update( self, resource_group_name: str, fleet_name: str, - properties: JSON, + properties: _types.FleetPatch, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -1659,7 +732,7 @@ async def begin_update( :param fleet_name: The name of the Fleet resource. Required. :type fleet_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.containerservicefleet.types.FleetPatch :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -1736,13 +809,14 @@ async def begin_update( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def begin_update( self, resource_group_name: str, fleet_name: str, - properties: Union[_models.FleetPatch, JSON, IO[bytes]], + properties: Union[_models.FleetPatch, _types.FleetPatch, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -1755,9 +829,10 @@ async def begin_update( :type resource_group_name: str :param fleet_name: The name of the Fleet resource. Required. :type fleet_name: str - :param properties: The resource properties to be updated. Is one of the following types: - FleetPatch, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.containerservicefleet.models.FleetPatch or JSON or IO[bytes] + :param properties: The resource properties to be updated. Is either a FleetPatch type or a + IO[bytes] type. Required. + :type properties: ~azure.mgmt.containerservicefleet.models.FleetPatch or + ~azure.mgmt.containerservicefleet.types.FleetPatch or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -2241,7 +1316,7 @@ async def list_credentials( return deserialized # type: ignore -class FleetMembersOperations: +class FleetMembersOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -2340,7 +1415,7 @@ async def _create_initial( resource_group_name: str, fleet_name: str, fleet_member_name: str, - resource: Union[_models.FleetMember, JSON, IO[bytes]], + resource: Union[_models.FleetMember, _types.FleetMember, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -2467,7 +1542,7 @@ async def begin_create( resource_group_name: str, fleet_name: str, fleet_member_name: str, - resource: JSON, + resource: _types.FleetMember, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -2484,7 +1559,7 @@ async def begin_create( :param fleet_member_name: The name of the Fleet member resource. Required. :type fleet_member_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.containerservicefleet.types.FleetMember :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -2545,7 +1620,7 @@ async def begin_create( resource_group_name: str, fleet_name: str, fleet_member_name: str, - resource: Union[_models.FleetMember, JSON, IO[bytes]], + resource: Union[_models.FleetMember, _types.FleetMember, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -2560,9 +1635,10 @@ async def begin_create( :type fleet_name: str :param fleet_member_name: The name of the Fleet member resource. Required. :type fleet_member_name: str - :param resource: Resource create parameters. Is one of the following types: FleetMember, JSON, - IO[bytes] Required. - :type resource: ~azure.mgmt.containerservicefleet.models.FleetMember or JSON or IO[bytes] + :param resource: Resource create parameters. Is either a FleetMember type or a IO[bytes] type. + Required. + :type resource: ~azure.mgmt.containerservicefleet.models.FleetMember or + ~azure.mgmt.containerservicefleet.types.FleetMember or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -2656,6 +1732,7 @@ def get_long_running_output(pipeline_response): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def _begin_update_initial( @@ -2663,7 +1740,7 @@ async def _begin_update_initial( resource_group_name: str, fleet_name: str, fleet_member_name: str, - properties: Union[_models.FleetMemberUpdate, JSON, IO[bytes]], + properties: Union[_models.FleetMemberUpdate, _types.FleetMemberUpdate, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -2791,7 +1868,7 @@ async def begin_update( resource_group_name: str, fleet_name: str, fleet_member_name: str, - properties: JSON, + properties: _types.FleetMemberUpdate, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -2808,7 +1885,7 @@ async def begin_update( :param fleet_member_name: The name of the Fleet member resource. Required. :type fleet_member_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.containerservicefleet.types.FleetMemberUpdate :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -2891,6 +1968,7 @@ async def begin_update( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def begin_update( @@ -2898,7 +1976,7 @@ async def begin_update( resource_group_name: str, fleet_name: str, fleet_member_name: str, - properties: Union[_models.FleetMemberUpdate, JSON, IO[bytes]], + properties: Union[_models.FleetMemberUpdate, _types.FleetMemberUpdate, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -2913,10 +1991,10 @@ async def begin_update( :type fleet_name: str :param fleet_member_name: The name of the Fleet member resource. Required. :type fleet_member_name: str - :param properties: The resource properties to be updated. Is one of the following types: - FleetMemberUpdate, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.containerservicefleet.models.FleetMemberUpdate or JSON or - IO[bytes] + :param properties: The resource properties to be updated. Is either a FleetMemberUpdate type or + a IO[bytes] type. Required. + :type properties: ~azure.mgmt.containerservicefleet.models.FleetMemberUpdate or + ~azure.mgmt.containerservicefleet.types.FleetMemberUpdate or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -3257,7 +2335,7 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) -class FleetManagedNamespacesOperations: +class FleetManagedNamespacesOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -3289,7 +2367,7 @@ def __init__(self, *args, **kwargs) -> None: "accept", ] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) async def get( self, resource_group_name: str, fleet_name: str, managed_namespace_name: str, **kwargs: Any @@ -3380,14 +2458,14 @@ async def get( "match_condition", ] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) async def _create_or_update_initial( self, resource_group_name: str, fleet_name: str, managed_namespace_name: str, - resource: Union[_models.FleetManagedNamespace, JSON, IO[bytes]], + resource: Union[_models.FleetManagedNamespace, _types.FleetManagedNamespace, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -3517,7 +2595,7 @@ async def begin_create_or_update( resource_group_name: str, fleet_name: str, managed_namespace_name: str, - resource: JSON, + resource: _types.FleetManagedNamespace, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -3534,7 +2612,7 @@ async def begin_create_or_update( :param managed_namespace_name: The name of the fleet managed namespace resource. Required. :type managed_namespace_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.containerservicefleet.types.FleetManagedNamespace :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -3605,14 +2683,14 @@ async def begin_create_or_update( "match_condition", ] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) async def begin_create_or_update( self, resource_group_name: str, fleet_name: str, managed_namespace_name: str, - resource: Union[_models.FleetManagedNamespace, JSON, IO[bytes]], + resource: Union[_models.FleetManagedNamespace, _types.FleetManagedNamespace, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -3627,10 +2705,10 @@ async def begin_create_or_update( :type fleet_name: str :param managed_namespace_name: The name of the fleet managed namespace resource. Required. :type managed_namespace_name: str - :param resource: Resource create parameters. Is one of the following types: - FleetManagedNamespace, JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.containerservicefleet.models.FleetManagedNamespace or JSON or - IO[bytes] + :param resource: Resource create parameters. Is either a FleetManagedNamespace type or a + IO[bytes] type. Required. + :type resource: ~azure.mgmt.containerservicefleet.models.FleetManagedNamespace or + ~azure.mgmt.containerservicefleet.types.FleetManagedNamespace or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -3710,7 +2788,7 @@ def get_long_running_output(pipeline_response): "match_condition", ] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) async def _delete_initial( self, @@ -3803,7 +2881,7 @@ async def _delete_initial( "match_condition", ] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) async def begin_delete( self, @@ -3886,7 +2964,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- params_added_on={ "2025-08-01-preview": ["api_version", "subscription_id", "resource_group_name", "fleet_name", "accept"] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) def list_by_fleet( self, resource_group_name: str, fleet_name: str, **kwargs: Any @@ -4005,14 +3083,14 @@ async def get_next(next_link=None): "match_condition", ] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) async def _update_initial( self, resource_group_name: str, fleet_name: str, managed_namespace_name: str, - properties: Union[_models.FleetManagedNamespacePatch, JSON, IO[bytes]], + properties: Union[_models.FleetManagedNamespacePatch, _types.FleetManagedNamespacePatch, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -4140,7 +3218,7 @@ async def begin_update( resource_group_name: str, fleet_name: str, managed_namespace_name: str, - properties: JSON, + properties: _types.FleetManagedNamespacePatch, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -4157,7 +3235,7 @@ async def begin_update( :param managed_namespace_name: The name of the fleet managed namespace resource. Required. :type managed_namespace_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.containerservicefleet.types.FleetManagedNamespacePatch :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -4228,14 +3306,14 @@ async def begin_update( "match_condition", ] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) async def begin_update( self, resource_group_name: str, fleet_name: str, managed_namespace_name: str, - properties: Union[_models.FleetManagedNamespacePatch, JSON, IO[bytes]], + properties: Union[_models.FleetManagedNamespacePatch, _types.FleetManagedNamespacePatch, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -4250,10 +3328,10 @@ async def begin_update( :type fleet_name: str :param managed_namespace_name: The name of the fleet managed namespace resource. Required. :type managed_namespace_name: str - :param properties: The resource properties to be updated. Is one of the following types: - FleetManagedNamespacePatch, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.containerservicefleet.models.FleetManagedNamespacePatch or JSON - or IO[bytes] + :param properties: The resource properties to be updated. Is either a + FleetManagedNamespacePatch type or a IO[bytes] type. Required. + :type properties: ~azure.mgmt.containerservicefleet.models.FleetManagedNamespacePatch or + ~azure.mgmt.containerservicefleet.types.FleetManagedNamespacePatch or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -4321,7 +3399,7 @@ def get_long_running_output(pipeline_response): ) -class GatesOperations: +class GatesOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -4353,7 +3431,13 @@ def __init__(self, *args, **kwargs) -> None: "accept", ] }, - api_versions_list=["2025-04-01-preview", "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=[ + "2025-04-01-preview", + "2025-08-01-preview", + "2026-02-01-preview", + "2026-03-02-preview", + "2026-06-01", + ], ) async def get(self, resource_group_name: str, fleet_name: str, gate_name: str, **kwargs: Any) -> _models.Gate: """Get a Gate. @@ -4442,14 +3526,20 @@ async def get(self, resource_group_name: str, fleet_name: str, gate_name: str, * "match_condition", ] }, - api_versions_list=["2025-04-01-preview", "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=[ + "2025-04-01-preview", + "2025-08-01-preview", + "2026-02-01-preview", + "2026-03-02-preview", + "2026-06-01", + ], ) async def _update_initial( self, resource_group_name: str, fleet_name: str, gate_name: str, - properties: Union[_models.GatePatch, JSON, IO[bytes]], + properties: Union[_models.GatePatch, _types.GatePatch, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -4576,7 +3666,7 @@ async def begin_update( resource_group_name: str, fleet_name: str, gate_name: str, - properties: JSON, + properties: _types.GatePatch, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -4593,7 +3683,7 @@ async def begin_update( :param gate_name: The name of the Gate resource, a GUID. Required. :type gate_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.containerservicefleet.types.GatePatch :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -4662,14 +3752,20 @@ async def begin_update( "match_condition", ] }, - api_versions_list=["2025-04-01-preview", "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=[ + "2025-04-01-preview", + "2025-08-01-preview", + "2026-02-01-preview", + "2026-03-02-preview", + "2026-06-01", + ], ) async def begin_update( self, resource_group_name: str, fleet_name: str, gate_name: str, - properties: Union[_models.GatePatch, JSON, IO[bytes]], + properties: Union[_models.GatePatch, _types.GatePatch, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -4684,9 +3780,10 @@ async def begin_update( :type fleet_name: str :param gate_name: The name of the Gate resource, a GUID. Required. :type gate_name: str - :param properties: The resource properties to be updated. Is one of the following types: - GatePatch, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.containerservicefleet.models.GatePatch or JSON or IO[bytes] + :param properties: The resource properties to be updated. Is either a GatePatch type or a + IO[bytes] type. Required. + :type properties: ~azure.mgmt.containerservicefleet.models.GatePatch or + ~azure.mgmt.containerservicefleet.types.GatePatch or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -4767,7 +3864,13 @@ def get_long_running_output(pipeline_response): "accept", ] }, - api_versions_list=["2025-04-01-preview", "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=[ + "2025-04-01-preview", + "2025-08-01-preview", + "2026-02-01-preview", + "2026-03-02-preview", + "2026-06-01", + ], ) def list_by_fleet( self, @@ -4888,7 +3991,7 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) -class UpdateRunsOperations: +class UpdateRunsOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -4933,6 +4036,7 @@ def __init__(self, *args, **kwargs) -> None: "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def get( @@ -5037,6 +4141,7 @@ async def get( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def _create_or_update_initial( @@ -5044,7 +4149,7 @@ async def _create_or_update_initial( resource_group_name: str, fleet_name: str, update_run_name: str, - resource: Union[_models.UpdateRun, JSON, IO[bytes]], + resource: Union[_models.UpdateRun, _types.UpdateRun, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -5170,7 +4275,7 @@ async def begin_create_or_update( resource_group_name: str, fleet_name: str, update_run_name: str, - resource: JSON, + resource: _types.UpdateRun, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -5187,7 +4292,7 @@ async def begin_create_or_update( :param update_run_name: The name of the UpdateRun resource. Required. :type update_run_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.containerservicefleet.types.UpdateRun :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -5269,6 +4374,7 @@ async def begin_create_or_update( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def begin_create_or_update( @@ -5276,7 +4382,7 @@ async def begin_create_or_update( resource_group_name: str, fleet_name: str, update_run_name: str, - resource: Union[_models.UpdateRun, JSON, IO[bytes]], + resource: Union[_models.UpdateRun, _types.UpdateRun, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -5291,9 +4397,10 @@ async def begin_create_or_update( :type fleet_name: str :param update_run_name: The name of the UpdateRun resource. Required. :type update_run_name: str - :param resource: Resource create parameters. Is one of the following types: UpdateRun, JSON, - IO[bytes] Required. - :type resource: ~azure.mgmt.containerservicefleet.models.UpdateRun or JSON or IO[bytes] + :param resource: Resource create parameters. Is either a UpdateRun type or a IO[bytes] type. + Required. + :type resource: ~azure.mgmt.containerservicefleet.models.UpdateRun or + ~azure.mgmt.containerservicefleet.types.UpdateRun or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -5385,6 +4492,7 @@ def get_long_running_output(pipeline_response): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def _delete_initial( @@ -5491,6 +4599,7 @@ async def _delete_initial( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def begin_delete( @@ -5595,6 +4704,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def list_by_fleet( @@ -5739,6 +4849,7 @@ async def get_next(next_link=None): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def _start_initial( @@ -5846,6 +4957,7 @@ async def _start_initial( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def begin_start( @@ -5956,6 +5068,7 @@ def get_long_running_output(pipeline_response): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def _stop_initial( @@ -6063,6 +5176,7 @@ async def _stop_initial( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def begin_stop( @@ -6170,6 +5284,7 @@ def get_long_running_output(pipeline_response): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def _skip_initial( @@ -6177,7 +5292,7 @@ async def _skip_initial( resource_group_name: str, fleet_name: str, update_run_name: str, - body: Union[_models.SkipProperties, JSON, IO[bytes]], + body: Union[_models.SkipProperties, _types.SkipProperties, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -6304,7 +5419,7 @@ async def begin_skip( resource_group_name: str, fleet_name: str, update_run_name: str, - body: JSON, + body: _types.SkipProperties, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -6321,7 +5436,7 @@ async def begin_skip( :param update_run_name: The name of the UpdateRun resource. Required. :type update_run_name: str :param body: The content of the action request. Required. - :type body: JSON + :type body: ~azure.mgmt.containerservicefleet.types.SkipProperties :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -6399,6 +5514,7 @@ async def begin_skip( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def begin_skip( @@ -6406,7 +5522,7 @@ async def begin_skip( resource_group_name: str, fleet_name: str, update_run_name: str, - body: Union[_models.SkipProperties, JSON, IO[bytes]], + body: Union[_models.SkipProperties, _types.SkipProperties, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -6421,9 +5537,10 @@ async def begin_skip( :type fleet_name: str :param update_run_name: The name of the UpdateRun resource. Required. :type update_run_name: str - :param body: The content of the action request. Is one of the following types: SkipProperties, - JSON, IO[bytes] Required. - :type body: ~azure.mgmt.containerservicefleet.models.SkipProperties or JSON or IO[bytes] + :param body: The content of the action request. Is either a SkipProperties type or a IO[bytes] + type. Required. + :type body: ~azure.mgmt.containerservicefleet.models.SkipProperties or + ~azure.mgmt.containerservicefleet.types.SkipProperties or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -6490,7 +5607,7 @@ def get_long_running_output(pipeline_response): ) -class FleetUpdateStrategiesOperations: +class FleetUpdateStrategiesOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -6533,6 +5650,7 @@ def __init__(self, *args, **kwargs) -> None: "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def get( @@ -6635,6 +5753,7 @@ async def get( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def _create_or_update_initial( @@ -6642,7 +5761,7 @@ async def _create_or_update_initial( resource_group_name: str, fleet_name: str, update_strategy_name: str, - resource: Union[_models.FleetUpdateStrategy, JSON, IO[bytes]], + resource: Union[_models.FleetUpdateStrategy, _types.FleetUpdateStrategy, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -6769,7 +5888,7 @@ async def begin_create_or_update( resource_group_name: str, fleet_name: str, update_strategy_name: str, - resource: JSON, + resource: _types.FleetUpdateStrategy, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -6786,7 +5905,7 @@ async def begin_create_or_update( :param update_strategy_name: The name of the UpdateStrategy resource. Required. :type update_strategy_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.containerservicefleet.types.FleetUpdateStrategy :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -6868,6 +5987,7 @@ async def begin_create_or_update( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def begin_create_or_update( @@ -6875,7 +5995,7 @@ async def begin_create_or_update( resource_group_name: str, fleet_name: str, update_strategy_name: str, - resource: Union[_models.FleetUpdateStrategy, JSON, IO[bytes]], + resource: Union[_models.FleetUpdateStrategy, _types.FleetUpdateStrategy, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -6890,10 +6010,10 @@ async def begin_create_or_update( :type fleet_name: str :param update_strategy_name: The name of the UpdateStrategy resource. Required. :type update_strategy_name: str - :param resource: Resource create parameters. Is one of the following types: - FleetUpdateStrategy, JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.containerservicefleet.models.FleetUpdateStrategy or JSON or - IO[bytes] + :param resource: Resource create parameters. Is either a FleetUpdateStrategy type or a + IO[bytes] type. Required. + :type resource: ~azure.mgmt.containerservicefleet.models.FleetUpdateStrategy or + ~azure.mgmt.containerservicefleet.types.FleetUpdateStrategy or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -6984,6 +6104,7 @@ def get_long_running_output(pipeline_response): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def _delete_initial( @@ -7088,6 +6209,7 @@ async def _delete_initial( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def begin_delete( @@ -7190,6 +6312,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def list_by_fleet( @@ -7308,7 +6431,7 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) -class AutoUpgradeProfilesOperations: +class AutoUpgradeProfilesOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -7347,6 +6470,7 @@ def __init__(self, *args, **kwargs) -> None: "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def get( @@ -7445,6 +6569,7 @@ async def get( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def _create_or_update_initial( @@ -7452,7 +6577,7 @@ async def _create_or_update_initial( resource_group_name: str, fleet_name: str, auto_upgrade_profile_name: str, - resource: Union[_models.AutoUpgradeProfile, JSON, IO[bytes]], + resource: Union[_models.AutoUpgradeProfile, _types.AutoUpgradeProfile, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -7582,7 +6707,7 @@ async def begin_create_or_update( resource_group_name: str, fleet_name: str, auto_upgrade_profile_name: str, - resource: JSON, + resource: _types.AutoUpgradeProfile, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -7599,7 +6724,7 @@ async def begin_create_or_update( :param auto_upgrade_profile_name: The name of the AutoUpgradeProfile resource. Required. :type auto_upgrade_profile_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.containerservicefleet.types.AutoUpgradeProfile :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -7677,6 +6802,7 @@ async def begin_create_or_update( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def begin_create_or_update( @@ -7684,7 +6810,7 @@ async def begin_create_or_update( resource_group_name: str, fleet_name: str, auto_upgrade_profile_name: str, - resource: Union[_models.AutoUpgradeProfile, JSON, IO[bytes]], + resource: Union[_models.AutoUpgradeProfile, _types.AutoUpgradeProfile, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -7699,10 +6825,10 @@ async def begin_create_or_update( :type fleet_name: str :param auto_upgrade_profile_name: The name of the AutoUpgradeProfile resource. Required. :type auto_upgrade_profile_name: str - :param resource: Resource create parameters. Is one of the following types: AutoUpgradeProfile, - JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.containerservicefleet.models.AutoUpgradeProfile or JSON or - IO[bytes] + :param resource: Resource create parameters. Is either a AutoUpgradeProfile type or a IO[bytes] + type. Required. + :type resource: ~azure.mgmt.containerservicefleet.models.AutoUpgradeProfile or + ~azure.mgmt.containerservicefleet.types.AutoUpgradeProfile or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -7789,6 +6915,7 @@ def get_long_running_output(pipeline_response): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def _delete_initial( @@ -7889,6 +7016,7 @@ async def _delete_initial( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def begin_delete( @@ -7987,6 +7115,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def list_by_fleet( @@ -8105,7 +7234,7 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) -class AutoUpgradeProfileOperationsOperations: +class AutoUpgradeProfileOperationsOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -8142,6 +7271,7 @@ def __init__(self, *args, **kwargs) -> None: "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def _generate_update_run_initial( @@ -8228,6 +7358,7 @@ async def _generate_update_run_initial( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) async def begin_generate_update_run( diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/operations/_patch.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/operations/_patch.py index ea765788358a..87676c65a8f0 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/operations/_patch.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/aio/operations/_patch.py @@ -8,6 +8,7 @@ Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ + __all__: list[str] = [] # Add all objects you want publicly available to users at this package level diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/__init__.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/__init__.py index 30221d03e2b6..e20fa7262a95 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/__init__.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/__init__.py @@ -21,11 +21,7 @@ AutoUpgradeProfile, AutoUpgradeProfileProperties, AutoUpgradeProfileStatus, - CiliumProperties, ClusterAffinity, - ClusterMeshProfile, - ClusterMeshProfileProperties, - ClusterMeshProfileStatus, ClusterResourcePlacementSpec, ClusterSelector, ClusterSelectorTerm, @@ -63,10 +59,7 @@ ManagedClusterUpgradeSpec, ManagedNamespaceProperties, ManagedServiceIdentity, - MemberSelector, MemberUpdateStatus, - MeshMemberStatus, - MeshProperties, NetworkPolicy, NodeImageSelection, NodeImageSelectionStatus, @@ -107,8 +100,6 @@ AutoUpgradeLastTriggerStatus, AutoUpgradeNodeImageSelectionType, AutoUpgradeProfileProvisioningState, - ClusterMeshProfileProvisioningState, - ClusterMeshState, CreatedByType, DeletePolicy, FleetManagedNamespaceProvisioningState, @@ -121,7 +112,6 @@ LabelSelectorOperator, ManagedClusterUpgradeType, ManagedServiceIdentityType, - MeshMemberState, NodeImageSelectionType, Origin, PlacementType, @@ -148,11 +138,7 @@ "AutoUpgradeProfile", "AutoUpgradeProfileProperties", "AutoUpgradeProfileStatus", - "CiliumProperties", "ClusterAffinity", - "ClusterMeshProfile", - "ClusterMeshProfileProperties", - "ClusterMeshProfileStatus", "ClusterResourcePlacementSpec", "ClusterSelector", "ClusterSelectorTerm", @@ -190,10 +176,7 @@ "ManagedClusterUpgradeSpec", "ManagedNamespaceProperties", "ManagedServiceIdentity", - "MemberSelector", "MemberUpdateStatus", - "MeshMemberStatus", - "MeshProperties", "NetworkPolicy", "NodeImageSelection", "NodeImageSelectionStatus", @@ -231,8 +214,6 @@ "AutoUpgradeLastTriggerStatus", "AutoUpgradeNodeImageSelectionType", "AutoUpgradeProfileProvisioningState", - "ClusterMeshProfileProvisioningState", - "ClusterMeshState", "CreatedByType", "DeletePolicy", "FleetManagedNamespaceProvisioningState", @@ -245,7 +226,6 @@ "LabelSelectorOperator", "ManagedClusterUpgradeType", "ManagedServiceIdentityType", - "MeshMemberState", "NodeImageSelectionType", "Origin", "PlacementType", diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/_enums.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/_enums.py index 177caf1d0c4d..7d7dc6ecf7e3 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/_enums.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/_enums.py @@ -71,32 +71,6 @@ class AutoUpgradeProfileProvisioningState(str, Enum, metaclass=CaseInsensitiveEn """Resource creation was canceled.""" -class ClusterMeshProfileProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The provisioning state of the cluster mesh profile resource.""" - - SUCCEEDED = "Succeeded" - """Resource has been created.""" - FAILED = "Failed" - """Resource creation failed.""" - CANCELED = "Canceled" - """Resource creation was canceled.""" - - -class ClusterMeshState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Cluster mesh state.""" - - NOT_CONNECTED = "NotConnected" - """The mesh is not connected.""" - APPLYING = "Applying" - """The mesh is applying.""" - CONNECTED = "Connected" - """The mesh is connected.""" - DEGRADED = "Degraded" - """The mesh is degraded.""" - FAILED = "Failed" - """The mesh failed to connect.""" - - class CreatedByType(str, Enum, metaclass=CaseInsensitiveEnumMeta): """The kind of entity that created the resource.""" @@ -253,19 +227,6 @@ class ManagedServiceIdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): """System and user assigned managed identity.""" -class MeshMemberState(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """Mesh member state.""" - - CONNECTING = "Connecting" - """The member is connecting to the mesh.""" - CONNECTED = "Connected" - """The member is connected to the mesh.""" - DISCONNECTING = "Disconnecting" - """The member is disconnecting from the mesh.""" - FAILED = "Failed" - """The member failed to connect due to an error.""" - - class NodeImageSelectionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): """The node image upgrade type.""" diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/_models.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/_models.py index 4f0a329e1e23..9ec381568e3d 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/_models.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/_models.py @@ -17,7 +17,7 @@ from .. import models as _models -class Affinity(_Model): +class Affinity(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """Affinity is a group of cluster affinity scheduling rules. More to be added. :ivar cluster_affinity: ClusterAffinity contains cluster affinity scheduling rules for the @@ -48,7 +48,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class AgentProfile(_Model): +class AgentProfile(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """Agent profile for the Fleet hub. :ivar subnet_id: The ID of the subnet which the Fleet hub node will join on startup. If this is @@ -83,7 +83,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class APIServerAccessProfile(_Model): +class APIServerAccessProfile(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """Access profile for the Fleet hub API server. :ivar enable_private_cluster: Whether to create the Fleet hub as a private cluster or not. @@ -124,7 +124,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class AutoUpgradeNodeImageSelection(_Model): +class AutoUpgradeNodeImageSelection(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The node image upgrade to be applied to the target clusters in auto upgrade. :ivar type: The node image upgrade type. Required. Known values are: "Latest" and "Consistent". @@ -198,7 +198,7 @@ class ProxyResource(Resource): """ -class AutoUpgradeProfile(ProxyResource): +class AutoUpgradeProfile(ProxyResource): # pylint: disable=docstring-keyword-should-match-keyword-only """The AutoUpgradeProfile resource. :ivar id: Fully qualified resource ID for the resource. Ex - @@ -278,7 +278,7 @@ def __setattr__(self, key: str, value: Any) -> None: super().__setattr__(key, value) -class AutoUpgradeProfileProperties(_Model): +class AutoUpgradeProfileProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The properties of the AutoUpgradeProfile. :ivar provisioning_state: The provisioning state of the AutoUpgradeProfile resource. Known @@ -419,26 +419,7 @@ class AutoUpgradeProfileStatus(_Model): """The target Kubernetes version or node image versions of the last trigger.""" -class CiliumProperties(_Model): - """The Cilium specific properties of the member cluster. - - :ivar id: Cilium requires each cluster to be assigned a unique numeric cluster id from 1 - 255. - The id is managed by Fleet and cannot be set by the user. Required. - :vartype id: int - :ivar name: Cilium requires each cluster to be assigned a unique human-readable name. The name - is managed by Fleet, based on the Fleet Member name, and cannot be set by the user. Required. - :vartype name: str - """ - - id: int = rest_field(visibility=["read"]) - """Cilium requires each cluster to be assigned a unique numeric cluster id from 1 - 255. The id is - managed by Fleet and cannot be set by the user. Required.""" - name: str = rest_field(visibility=["read"]) - """Cilium requires each cluster to be assigned a unique human-readable name. The name is managed - by Fleet, based on the Fleet Member name, and cannot be set by the user. Required.""" - - -class ClusterAffinity(_Model): +class ClusterAffinity(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """ClusterAffinity contains cluster affinity scheduling rules for the selected resources. :ivar required_during_scheduling_ignored_during_execution: If the affinity requirements @@ -477,155 +458,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class ClusterMeshProfile(ProxyResource): - """A cluster mesh profile stores the general information about the mesh. - - :ivar id: Fully qualified resource ID for the resource. Ex - - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. - :vartype id: str - :ivar name: The name of the resource. - :vartype name: str - :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or - "Microsoft.Storage/storageAccounts". - :vartype type: str - :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy - information. - :vartype system_data: ~azure.mgmt.containerservicefleet.models.SystemData - :ivar properties: The resource-specific properties for this resource. - :vartype properties: ~azure.mgmt.containerservicefleet.models.ClusterMeshProfileProperties - :ivar e_tag: If eTag is provided in the response body, it may also be provided as a header per - the normal etag convention. Entity tags are used for comparing two or more entities from the - same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match - (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. - :vartype e_tag: str - """ - - properties: Optional["_models.ClusterMeshProfileProperties"] = rest_field( - visibility=["read", "create", "update", "delete", "query"] - ) - """The resource-specific properties for this resource.""" - e_tag: Optional[str] = rest_field(name="eTag", visibility=["read"]) - """If eTag is provided in the response body, it may also be provided as a header per the normal - etag convention. Entity tags are used for comparing two or more entities from the same - requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section - 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.""" - - __flattened_items = ["provisioning_state", "member_selector", "status"] - - @overload - def __init__( - self, - *, - properties: Optional["_models.ClusterMeshProfileProperties"] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - _flattened_input = {k: kwargs.pop(k) for k in kwargs.keys() & self.__flattened_items} - super().__init__(*args, **kwargs) - for k, v in _flattened_input.items(): - setattr(self, k, v) - - def __getattr__(self, name: str) -> Any: - if name in self.__flattened_items: - if self.properties is None: - return None - return getattr(self.properties, name) - raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'") - - def __setattr__(self, key: str, value: Any) -> None: - if key in self.__flattened_items: - if self.properties is None: - self.properties = self._attr_to_rest_field["properties"]._class_type() - setattr(self.properties, key, value) - else: - super().__setattr__(key, value) - - -class ClusterMeshProfileProperties(_Model): - """A cluster mesh profile stores the general information about the mesh. - - :ivar provisioning_state: The provisioning state of the cluster mesh profile. Known values are: - "Succeeded", "Failed", and "Canceled". - :vartype provisioning_state: str or - ~azure.mgmt.containerservicefleet.models.ClusterMeshProfileProvisioningState - :ivar member_selector: Select the members of the mesh. - - * Only key/value pairs with the `=` operator are accepted in the label selector. - * If empty or not specified, no Fleet members will be selected to join the mesh. - :vartype member_selector: ~azure.mgmt.containerservicefleet.models.MemberSelector - :ivar status: The cluster mesh profile status. - :vartype status: ~azure.mgmt.containerservicefleet.models.ClusterMeshProfileStatus - """ - - provisioning_state: Optional[Union[str, "_models.ClusterMeshProfileProvisioningState"]] = rest_field( - name="provisioningState", visibility=["read"] - ) - """The provisioning state of the cluster mesh profile. Known values are: \"Succeeded\", - \"Failed\", and \"Canceled\".""" - member_selector: Optional["_models.MemberSelector"] = rest_field( - name="memberSelector", visibility=["read", "create"] - ) - """Select the members of the mesh. - - * Only key/value pairs with the `=` operator are accepted in the label selector. - * If empty or not specified, no Fleet members will be selected to join the mesh.""" - status: Optional["_models.ClusterMeshProfileStatus"] = rest_field(visibility=["read"]) - """The cluster mesh profile status.""" - - @overload - def __init__( - self, - *, - member_selector: Optional["_models.MemberSelector"] = None, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - -class ClusterMeshProfileStatus(_Model): - """Status of the cluster mesh. - - :ivar state: The state of the cluster mesh. Required. Known values are: "NotConnected", - "Applying", "Connected", "Degraded", and "Failed". - :vartype state: str or ~azure.mgmt.containerservicefleet.models.ClusterMeshState - :ivar last_applied_member_selector: The last applied MemberSelector for the cluster mesh - profile. - :vartype last_applied_member_selector: ~azure.mgmt.containerservicefleet.models.MemberSelector - :ivar last_operation_id: The last operation ID for the cluster mesh profile. - :vartype last_operation_id: str - :ivar last_operation_error: The last operation error of the cluster mesh profile. - :vartype last_operation_error: ~azure.mgmt.containerservicefleet.models.ErrorDetail - """ - - state: Union[str, "_models.ClusterMeshState"] = rest_field(visibility=["read"]) - """The state of the cluster mesh. Required. Known values are: \"NotConnected\", \"Applying\", - \"Connected\", \"Degraded\", and \"Failed\".""" - last_applied_member_selector: Optional["_models.MemberSelector"] = rest_field( - name="lastAppliedMemberSelector", visibility=["read"] - ) - """The last applied MemberSelector for the cluster mesh profile.""" - last_operation_id: Optional[str] = rest_field(name="lastOperationId", visibility=["read"]) - """The last operation ID for the cluster mesh profile.""" - last_operation_error: Optional["_models.ErrorDetail"] = rest_field(name="lastOperationError", visibility=["read"]) - """The last operation error of the cluster mesh profile.""" - - -class ClusterResourcePlacementSpec(_Model): +class ClusterResourcePlacementSpec(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """ClusterResourcePlacementSpec defines the desired state of ClusterResourcePlacement. :ivar policy: Policy defines how to select member clusters to place the selected resources. If @@ -655,7 +488,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class ClusterSelector(_Model): +class ClusterSelector(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """ClusterSelector. :ivar cluster_selector_terms: ClusterSelectorTerms is a list of cluster selector terms. The @@ -687,7 +520,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class ClusterSelectorTerm(_Model): +class ClusterSelectorTerm(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """ClusterSelectorTerm. :ivar label_selector: LabelSelector is a label query over all the joined member clusters. @@ -782,7 +615,7 @@ class ErrorDetail(_Model): """The error additional info.""" -class ErrorResponse(_Model): +class ErrorResponse(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """Error response. :ivar error: The error object. @@ -810,7 +643,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class TrackedResource(Resource): +class TrackedResource(Resource): # pylint: disable=docstring-keyword-should-match-keyword-only """Tracked Resource. :ivar id: Fully qualified resource ID for the resource. Ex - @@ -854,7 +687,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class Fleet(TrackedResource): +class Fleet(TrackedResource): # pylint: disable=docstring-keyword-should-match-keyword-only """The Fleet resource. :ivar id: Fully qualified resource ID for the resource. Ex - @@ -964,7 +797,7 @@ class FleetCredentialResults(_Model): """Array of base64-encoded Kubernetes configuration files.""" -class FleetHubProfile(_Model): +class FleetHubProfile(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The FleetHubProfile configures the fleet hub. :ivar dns_prefix: DNS prefix used to create the FQDN for the Fleet hub. @@ -1017,7 +850,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class FleetManagedNamespace(TrackedResource): +class FleetManagedNamespace(TrackedResource): # pylint: disable=docstring-keyword-should-match-keyword-only """A fleet managed namespace. :ivar id: Fully qualified resource ID for the resource. Ex - @@ -1102,7 +935,7 @@ def __setattr__(self, key: str, value: Any) -> None: super().__setattr__(key, value) -class FleetManagedNamespacePatch(_Model): +class FleetManagedNamespacePatch(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The properties of a fleet managed namespace that can be patched. :ivar tags: Resource tags. @@ -1130,7 +963,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class FleetManagedNamespaceProperties(_Model): +class FleetManagedNamespaceProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The properties of a fleet managed namespace. :ivar provisioning_state: The status of the last operation. Known values are: "Succeeded", @@ -1218,7 +1051,7 @@ class FleetManagedNamespaceStatus(_Model): """The last operation error of the fleet managed namespace.""" -class FleetMember(ProxyResource): +class FleetMember(ProxyResource): # pylint: disable=docstring-keyword-should-match-keyword-only """A member of the Fleet. It contains a reference to an existing Kubernetes cluster on Azure. :ivar id: Fully qualified resource ID for the resource. Ex - @@ -1251,7 +1084,7 @@ class FleetMember(ProxyResource): requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.""" - __flattened_items = ["cluster_resource_id", "group", "provisioning_state", "labels", "status", "mesh_properties"] + __flattened_items = ["cluster_resource_id", "group", "provisioning_state", "labels", "status"] @overload def __init__( @@ -1289,7 +1122,7 @@ def __setattr__(self, key: str, value: Any) -> None: super().__setattr__(key, value) -class FleetMemberProperties(_Model): +class FleetMemberProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """A member of the Fleet. It contains a reference to an existing Kubernetes cluster on Azure. :ivar cluster_resource_id: The ARM resource id of the cluster that joins the Fleet. Must be a @@ -1307,8 +1140,6 @@ class FleetMemberProperties(_Model): :vartype labels: dict[str, str] :ivar status: Status information of the last operation for fleet member. :vartype status: ~azure.mgmt.containerservicefleet.models.FleetMemberStatus - :ivar mesh_properties: The Mesh Member Properties associated with this Fleet Member. - :vartype mesh_properties: ~azure.mgmt.containerservicefleet.models.MeshProperties """ cluster_resource_id: str = rest_field(name="clusterResourceId", visibility=["read", "create"]) @@ -1327,8 +1158,6 @@ class FleetMemberProperties(_Model): """The labels for the fleet member.""" status: Optional["_models.FleetMemberStatus"] = rest_field(visibility=["read"]) """Status information of the last operation for fleet member.""" - mesh_properties: Optional["_models.MeshProperties"] = rest_field(name="meshProperties", visibility=["read"]) - """The Mesh Member Properties associated with this Fleet Member.""" @overload def __init__( @@ -1365,7 +1194,7 @@ class FleetMemberStatus(_Model): """The last operation error of the fleet member.""" -class FleetMemberUpdate(_Model): +class FleetMemberUpdate(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The type used for update operations of the FleetMember. :ivar properties: The resource-specific properties for this resource. @@ -1415,7 +1244,7 @@ def __setattr__(self, key: str, value: Any) -> None: super().__setattr__(key, value) -class FleetMemberUpdateProperties(_Model): +class FleetMemberUpdateProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The updatable properties of the FleetMember. :ivar group: The group this member belongs to for multi-cluster update management. @@ -1448,7 +1277,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class FleetPatch(_Model): +class FleetPatch(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """Properties of a Fleet that can be patched. :ivar tags: Resource tags. @@ -1483,7 +1312,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class FleetProperties(_Model): +class FleetProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """Fleet properties. :ivar provisioning_state: The status of the last operation. Known values are: "Succeeded", @@ -1541,7 +1370,7 @@ class FleetStatus(_Model): """The last operation error for the fleet.""" -class FleetUpdateStrategy(ProxyResource): +class FleetUpdateStrategy(ProxyResource): # pylint: disable=docstring-keyword-should-match-keyword-only """Defines a multi-stage process to perform update operations across members of a Fleet. :ivar id: Fully qualified resource ID for the resource. Ex - @@ -1612,7 +1441,7 @@ def __setattr__(self, key: str, value: Any) -> None: super().__setattr__(key, value) -class FleetUpdateStrategyProperties(_Model): +class FleetUpdateStrategyProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The properties of the UpdateStrategy. :ivar provisioning_state: The provisioning state of the UpdateStrategy resource. Known values @@ -1649,7 +1478,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class Gate(ProxyResource): +class Gate(ProxyResource): # pylint: disable=docstring-keyword-should-match-keyword-only """A Gate controls the progression during a staged rollout, e.g. in an Update Run. :ivar id: Fully qualified resource ID for the resource. Ex - @@ -1720,7 +1549,7 @@ def __setattr__(self, key: str, value: Any) -> None: super().__setattr__(key, value) -class GateConfiguration(_Model): +class GateConfiguration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """GateConfiguration is used to define where Gates should be placed within the Update Run. :ivar display_name: The human-readable display name of the Gate. @@ -1755,7 +1584,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class GatePatch(_Model): +class GatePatch(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """Patch a Gate resource. :ivar properties: Properties of a Gate that can be patched. Required. @@ -1783,7 +1612,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class GatePatchProperties(_Model): +class GatePatchProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """Properties of a Gate that can be patched. :ivar state: The state of the Gate. Required. Known values are: "Pending", "Skipped", and @@ -1812,7 +1641,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class GateProperties(_Model): +class GateProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """A Gate controls the progression during a staged rollout, e.g. in an Update Run. :ivar provisioning_state: The provisioning state of the Gate resource. Known values are: @@ -1865,7 +1694,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class GateTarget(_Model): +class GateTarget(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The target that the Gate is controlling, e.g. an Update Run. Exactly one of the properties objects will be set. @@ -1917,7 +1746,7 @@ class GenerateResponse(_Model): Required.""" -class LabelSelector(_Model): +class LabelSelector(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects. @@ -1962,7 +1791,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class LabelSelectorRequirement(_Model): +class LabelSelectorRequirement(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values. @@ -2013,7 +1842,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class ManagedClusterUpdate(_Model): +class ManagedClusterUpdate(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The update to be applied to the ManagedClusters. :ivar upgrade: The upgrade to apply to the ManagedClusters. Required. @@ -2051,7 +1880,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class ManagedClusterUpgradeSpec(_Model): +class ManagedClusterUpgradeSpec(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The upgrade to apply to a ManagedCluster. :ivar type: ManagedClusterUpgradeType is the type of upgrade to be applied. Required. Known @@ -2090,7 +1919,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class ManagedNamespaceProperties(_Model): +class ManagedNamespaceProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The namespace properties for the fleet managed namespace. :ivar labels: The labels for the fleet managed namespace. @@ -2137,7 +1966,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class ManagedServiceIdentity(_Model): +class ManagedServiceIdentity(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """Managed service identity (system assigned and/or user assigned identities). :ivar principal_id: The service principal ID of the system assigned identity. This property @@ -2189,35 +2018,6 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class MemberSelector(_Model): - """Select members of a fleet. - - :ivar by_label: Kubernetes-style label selector for selecting Fleet members, e.g. - ``env=production``. Required. - :vartype by_label: str - """ - - by_label: str = rest_field(name="byLabel", visibility=["read", "create"]) - """Kubernetes-style label selector for selecting Fleet members, e.g. ``env=production``. Required.""" - - @overload - def __init__( - self, - *, - by_label: str, - ) -> None: ... - - @overload - def __init__(self, mapping: Mapping[str, Any]) -> None: - """ - :param mapping: raw JSON to initialize the model. - :type mapping: Mapping[str, Any] - """ - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - class MemberUpdateStatus(_Model): """The status of a member update operation. @@ -2245,55 +2045,7 @@ class MemberUpdateStatus(_Model): """The status message after processing the member update operation.""" -class MeshMemberStatus(_Model): - """Status of the mesh member. - - :ivar state: The mesh member state. Required. Known values are: "Connecting", "Connected", - "Disconnecting", and "Failed". - :vartype state: str or ~azure.mgmt.containerservicefleet.models.MeshMemberState - :ivar last_updated_at: When the status was last updated. - :vartype last_updated_at: ~datetime.datetime - :ivar last_operation_id: The last operation ID that affected the mesh properties of the fleet - member. - :vartype last_operation_id: str - :ivar error: The error affecting this member. - :vartype error: ~azure.mgmt.containerservicefleet.models.ErrorDetail - """ - - state: Union[str, "_models.MeshMemberState"] = rest_field(visibility=["read"]) - """The mesh member state. Required. Known values are: \"Connecting\", \"Connected\", - \"Disconnecting\", and \"Failed\".""" - last_updated_at: Optional[datetime.datetime] = rest_field( - name="lastUpdatedAt", visibility=["read"], format="rfc3339" - ) - """When the status was last updated.""" - last_operation_id: Optional[str] = rest_field(name="lastOperationId", visibility=["read"]) - """The last operation ID that affected the mesh properties of the fleet member.""" - error: Optional["_models.ErrorDetail"] = rest_field(visibility=["read"]) - """The error affecting this member.""" - - -class MeshProperties(_Model): - """The Mesh Member data for a Fleet Member resource. - - :ivar cilium_properties: The Cilium cluster properties. Required. - :vartype cilium_properties: ~azure.mgmt.containerservicefleet.models.CiliumProperties - :ivar status: The status of the mesh member. Required. - :vartype status: ~azure.mgmt.containerservicefleet.models.MeshMemberStatus - :ivar cluster_mesh_profile_resource_id: Resource id of the cluster mesh profile associated with - this mesh member. Required. - :vartype cluster_mesh_profile_resource_id: str - """ - - cilium_properties: "_models.CiliumProperties" = rest_field(name="ciliumProperties", visibility=["read"]) - """The Cilium cluster properties. Required.""" - status: "_models.MeshMemberStatus" = rest_field(visibility=["read"]) - """The status of the mesh member. Required.""" - cluster_mesh_profile_resource_id: str = rest_field(name="clusterMeshProfileResourceId", visibility=["read"]) - """Resource id of the cluster mesh profile associated with this mesh member. Required.""" - - -class NetworkPolicy(_Model): +class NetworkPolicy(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The network policy for the managed namespace. :ivar ingress: The ingress policy for the managed namespace. Known values are: "AllowAll", @@ -2334,7 +2086,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class NodeImageSelection(_Model): +class NodeImageSelection(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The node image upgrade to be applied to the target nodes in update run. :ivar type: The node image upgrade type. Required. Known values are: "Latest", "Consistent", @@ -2408,7 +2160,7 @@ class NodeImageVersion(_Model): """The image version to upgrade the nodes to (e.g., 'AKSUbuntu-1804gen2containerd-2022.12.13').""" -class Operation(_Model): +class Operation(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """REST API Operation. :ivar name: The name of the operation, as per Resource-Based Access Control (RBAC). Examples: @@ -2496,7 +2248,7 @@ class OperationDisplay(_Model): views.""" -class PlacementPolicy(_Model): +class PlacementPolicy(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """PlacementPolicy contains the rules to select target member clusters to place the selected resources. Note that only clusters that are both joined and satisfying the rules will be selected. You can only specify at most one of the two fields: ClusterNames and Affinity. If @@ -2557,7 +2309,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class PlacementProfile(_Model): +class PlacementProfile(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The configuration profile for default ClusterResourcePlacement for placement. :ivar default_cluster_resource_placement: The default ClusterResourcePlacement policy @@ -2589,7 +2341,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class PropagationPolicy(_Model): +class PropagationPolicy(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The propagation to be used for provisioning the namespace among the fleet. :ivar type: The type of the policy to be used. Default is Placement. Required. "Placement" @@ -2624,7 +2376,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class PropertySelector(_Model): +class PropertySelector(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """PropertySelector helps user specify property requirements when picking clusters for resource placement. @@ -2658,7 +2410,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class PropertySelectorRequirement(_Model): +class PropertySelectorRequirement(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """PropertySelectorRequirement is a specific property requirement when picking clusters for resource placement. @@ -2717,7 +2469,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class ResourceQuota(_Model): +class ResourceQuota(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The resource quota for the managed namespace. :ivar cpu_request: The CPU request for the managed namespace. See more at @@ -2782,7 +2534,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class SkipProperties(_Model): +class SkipProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The properties of a skip operation containing multiple skip requests. :ivar targets: The targets to skip. Required. @@ -2810,7 +2562,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class SkipTarget(_Model): +class SkipTarget(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The definition of a single skip request. :ivar type: The skip target type. Required. Known values are: "Member", "Group", "Stage", and @@ -2847,7 +2599,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class SystemData(_Model): +class SystemData(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """Metadata pertaining to creation and last modification of the resource. :ivar created_by: The identity that created the resource. @@ -2914,7 +2666,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class Toleration(_Model): +class Toleration(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """Toleration allows ClusterResourcePlacement to tolerate any taint that matches the triple using the matching operator . @@ -2975,7 +2727,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class UpdateGroup(_Model): +class UpdateGroup(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """A group to be updated. :ivar name: Name of the group. It must match a group name of an existing fleet member. @@ -3080,7 +2832,7 @@ class UpdateGroupStatus(_Model): """The list of Gates that will run after this UpdateGroup.""" -class UpdateRun(ProxyResource): +class UpdateRun(ProxyResource): # pylint: disable=docstring-keyword-should-match-keyword-only """A multi-stage process to perform update operations across members of a Fleet. :ivar id: Fully qualified resource ID for the resource. Ex - @@ -3177,7 +2929,7 @@ class UpdateRunGateStatus(_Model): """The status of the Gate.""" -class UpdateRunGateTargetProperties(_Model): +class UpdateRunGateTargetProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The properties of the Update Run that the Gate is targeting. :ivar name: The name of the Update Run. Required. @@ -3219,7 +2971,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class UpdateRunProperties(_Model): +class UpdateRunProperties(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """The properties of the UpdateRun. :ivar provisioning_state: The provisioning state of the UpdateRun resource. Known values are: @@ -3344,7 +3096,7 @@ class UpdateRunStatus(_Model): ``NodeImageSelection.type`` is ``Consistent``.""" -class UpdateRunStrategy(_Model): +class UpdateRunStrategy(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """Defines the update sequence of the clusters via stages and groups. Stages within a run are executed sequentially one after another. @@ -3378,7 +3130,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class UpdateStage(_Model): +class UpdateStage(_Model): # pylint: disable=docstring-keyword-should-match-keyword-only """Defines a stage which contains the groups to update and the steps to take (e.g., wait for a time period) before starting the next stage. diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/_patch.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/_patch.py index ea765788358a..87676c65a8f0 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/_patch.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/models/_patch.py @@ -8,6 +8,7 @@ Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ + __all__: list[str] = [] # Add all objects you want publicly available to users at this package level diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/operations/__init__.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/operations/__init__.py index 0ceec5058a9b..4c46bb360e8d 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/operations/__init__.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/operations/__init__.py @@ -13,7 +13,6 @@ from ._patch import * # pylint: disable=unused-wildcard-import from ._operations import Operations # type: ignore -from ._operations import ClusterMeshProfilesOperations # type: ignore from ._operations import FleetsOperations # type: ignore from ._operations import FleetMembersOperations # type: ignore from ._operations import FleetManagedNamespacesOperations # type: ignore @@ -29,7 +28,6 @@ __all__ = [ "Operations", - "ClusterMeshProfilesOperations", "FleetsOperations", "FleetMembersOperations", "FleetManagedNamespacesOperations", diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/operations/_operations.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/operations/_operations.py index 5729765979b8..b095f2eca99c 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/operations/_operations.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/operations/_operations.py @@ -33,7 +33,7 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from azure.mgmt.core.polling.arm_polling import ARMPolling -from .. import models as _models +from .. import models as _models, types as _types from .._configuration import ContainerServiceFleetMgmtClientConfiguration from .._utils.model_base import SdkJSONEncoder, _deserialize, _failsafe_deserialize from .._utils.serialization import Deserializer, Serializer @@ -42,7 +42,6 @@ T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, dict[str, Any]], Any]] -JSON = MutableMapping[str, Any] List = list _SERIALIZER = Serializer() @@ -53,7 +52,7 @@ def build_operations_list_request(**kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -68,196 +67,13 @@ def build_operations_list_request(**kwargs: Any) -> HttpRequest: return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) -def build_cluster_mesh_profiles_get_request( - resource_group_name: str, fleet_name: str, cluster_mesh_profile_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}/clusterMeshProfiles/{clusterMeshProfileName}" - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "fleetName": _SERIALIZER.url("fleet_name", fleet_name, "str"), - "clusterMeshProfileName": _SERIALIZER.url("cluster_mesh_profile_name", cluster_mesh_profile_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_cluster_mesh_profiles_create_or_update_request( # pylint: disable=name-too-long - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - subscription_id: str, - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}/clusterMeshProfiles/{clusterMeshProfileName}" - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "fleetName": _SERIALIZER.url("fleet_name", fleet_name, "str"), - "clusterMeshProfileName": _SERIALIZER.url("cluster_mesh_profile_name", cluster_mesh_profile_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - if_match = prep_if_match(etag, match_condition) - if if_match is not None: - _headers["If-Match"] = _SERIALIZER.header("if_match", if_match, "str") - if_none_match = prep_if_none_match(etag, match_condition) - if if_none_match is not None: - _headers["If-None-Match"] = _SERIALIZER.header("if_none_match", if_none_match, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_cluster_mesh_profiles_delete_request( # pylint: disable=name-too-long - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - subscription_id: str, - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}/clusterMeshProfiles/{clusterMeshProfileName}" - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "fleetName": _SERIALIZER.url("fleet_name", fleet_name, "str"), - "clusterMeshProfileName": _SERIALIZER.url("cluster_mesh_profile_name", cluster_mesh_profile_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if_match = prep_if_match(etag, match_condition) - if if_match is not None: - _headers["If-Match"] = _SERIALIZER.header("if_match", if_match, "str") - if_none_match = prep_if_none_match(etag, match_condition) - if if_none_match is not None: - _headers["if-none-match"] = _SERIALIZER.header("if_none_match", if_none_match, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_cluster_mesh_profiles_list_by_fleet_request( # pylint: disable=name-too-long - resource_group_name: str, fleet_name: str, subscription_id: str, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}/clusterMeshProfiles" - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "fleetName": _SERIALIZER.url("fleet_name", fleet_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_cluster_mesh_profiles_apply_request( # pylint: disable=name-too-long - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - subscription_id: str, - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}/clusterMeshProfiles/{clusterMeshProfileName}/apply" - path_format_arguments = { - "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"), - "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"), - "fleetName": _SERIALIZER.url("fleet_name", fleet_name, "str"), - "clusterMeshProfileName": _SERIALIZER.url("cluster_mesh_profile_name", cluster_mesh_profile_name, "str"), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - if_match = prep_if_match(etag, match_condition) - if if_match is not None: - _headers["If-Match"] = _SERIALIZER.header("if_match", if_match, "str") - if_none_match = prep_if_none_match(etag, match_condition) - if if_none_match is not None: - _headers["if-none-match"] = _SERIALIZER.header("if_none_match", if_none_match, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - def build_fleets_get_request( resource_group_name: str, fleet_name: str, subscription_id: str, **kwargs: Any ) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -292,7 +108,7 @@ def build_fleets_begin_create_or_update_request( # pylint: disable=name-too-lon _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -335,7 +151,7 @@ def build_fleets_begin_update_request( _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -377,7 +193,7 @@ def build_fleets_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) # Construct URL _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}" path_format_arguments = { @@ -408,7 +224,7 @@ def build_fleets_list_by_resource_group_request( # pylint: disable=name-too-lon _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -437,7 +253,7 @@ def build_fleets_list_by_subscription_request( # pylint: disable=name-too-long _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -467,7 +283,7 @@ def build_fleets_list_credentials_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -495,7 +311,7 @@ def build_fleet_members_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -532,7 +348,7 @@ def build_fleet_members_create_request( _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -577,7 +393,7 @@ def build_fleet_members_begin_update_request( _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -621,7 +437,7 @@ def build_fleet_members_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) # Construct URL _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}/members/{fleetMemberName}" path_format_arguments = { @@ -660,7 +476,7 @@ def build_fleet_members_list_by_fleet_request( # pylint: disable=name-too-long _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -694,7 +510,7 @@ def build_fleet_managed_namespaces_get_request( # pylint: disable=name-too-long _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -731,7 +547,7 @@ def build_fleet_managed_namespaces_create_or_update_request( # pylint: disable= _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -775,7 +591,7 @@ def build_fleet_managed_namespaces_delete_request( # pylint: disable=name-too-l _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) # Construct URL _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}/managedNamespaces/{managedNamespaceName}" path_format_arguments = { @@ -807,7 +623,7 @@ def build_fleet_managed_namespaces_list_by_fleet_request( # pylint: disable=nam _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -843,7 +659,7 @@ def build_fleet_managed_namespaces_update_request( # pylint: disable=name-too-l _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -880,7 +696,7 @@ def build_gates_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -917,7 +733,7 @@ def build_gates_update_request( _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -961,7 +777,7 @@ def build_gates_list_by_fleet_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -995,7 +811,7 @@ def build_update_runs_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -1032,7 +848,7 @@ def build_update_runs_create_or_update_request( # pylint: disable=name-too-long _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -1076,7 +892,7 @@ def build_update_runs_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) # Construct URL _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}/updateRuns/{updateRunName}" path_format_arguments = { @@ -1114,7 +930,7 @@ def build_update_runs_list_by_fleet_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -1153,7 +969,7 @@ def build_update_runs_start_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -1195,7 +1011,7 @@ def build_update_runs_stop_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -1238,7 +1054,7 @@ def build_update_runs_skip_request( _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -1275,7 +1091,7 @@ def build_fleet_update_strategies_get_request( # pylint: disable=name-too-long _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -1312,7 +1128,7 @@ def build_fleet_update_strategies_create_or_update_request( # pylint: disable=n _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -1356,7 +1172,7 @@ def build_fleet_update_strategies_delete_request( # pylint: disable=name-too-lo _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) # Construct URL _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}/updateStrategies/{updateStrategyName}" path_format_arguments = { @@ -1394,7 +1210,7 @@ def build_fleet_update_strategies_list_by_fleet_request( # pylint: disable=name _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -1426,7 +1242,7 @@ def build_auto_upgrade_profiles_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -1463,7 +1279,7 @@ def build_auto_upgrade_profiles_create_or_update_request( # pylint: disable=nam _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -1507,7 +1323,7 @@ def build_auto_upgrade_profiles_delete_request( # pylint: disable=name-too-long _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) # Construct URL _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}/autoUpgradeProfiles/{autoUpgradeProfileName}" path_format_arguments = { @@ -1545,7 +1361,7 @@ def build_auto_upgrade_profiles_list_by_fleet_request( # pylint: disable=name-t _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -1577,7 +1393,7 @@ def build_auto_upgrade_profile_operations_generate_update_run_request( # pylint _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-02-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-06-01")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -1595,770 +1411,42 @@ def build_auto_upgrade_profile_operations_generate_update_run_request( # pylint _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -class Operations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.containerservicefleet.ContainerServiceFleetMgmtClient`'s - :attr:`operations` attribute. - """ - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: ContainerServiceFleetMgmtClientConfiguration = ( - input_args.pop(0) if input_args else kwargs.pop("config") - ) - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace - def list(self, **kwargs: Any) -> ItemPaged["_models.Operation"]: - """List the operations for the provider. - - :return: An iterator like instance of Operation - :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.containerservicefleet.models.Operation] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[List[_models.Operation]] = kwargs.pop("cls", None) - - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - def prepare_request(next_link=None): - if not next_link: - - _request = build_operations_list_request( - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - _request = HttpRequest( - "GET", - urllib.parse.urljoin(next_link, _parsed_next_link.path), - headers=_headers, - params=_next_request_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.base_url", self._config.base_url, "str", skip_quote=True - ), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - return _request - - def extract_data(pipeline_response): - deserialized = pipeline_response.http_response.json() - list_of_elem = _deserialize( - List[_models.Operation], - deserialized.get("value", []), - ) - if cls: - list_of_elem = cls(list_of_elem) # type: ignore - return deserialized.get("nextLink") or None, iter(list_of_elem) - - def get_next(next_link=None): - _request = prepare_request(next_link) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize( - _models.ErrorResponse, - response, - ) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - return pipeline_response - - return ItemPaged(get_next, extract_data) - - -class ClusterMeshProfilesOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.mgmt.containerservicefleet.ContainerServiceFleetMgmtClient`'s - :attr:`cluster_mesh_profiles` attribute. - """ - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: ContainerServiceFleetMgmtClientConfiguration = ( - input_args.pop(0) if input_args else kwargs.pop("config") - ) - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "fleet_name", - "cluster_mesh_profile_name", - "accept", - ] - }, - api_versions_list=["2026-03-02-preview"], - ) - def get( - self, resource_group_name: str, fleet_name: str, cluster_mesh_profile_name: str, **kwargs: Any - ) -> _models.ClusterMeshProfile: - """Get a ClusterMeshProfile. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :param cluster_mesh_profile_name: The name of the ClusterMeshProfile resource. Required. - :type cluster_mesh_profile_name: str - :return: ClusterMeshProfile. The ClusterMeshProfile is compatible with MutableMapping - :rtype: ~azure.mgmt.containerservicefleet.models.ClusterMeshProfile - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.ClusterMeshProfile] = kwargs.pop("cls", None) - - _request = build_cluster_mesh_profiles_get_request( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - cluster_mesh_profile_name=cluster_mesh_profile_name, - subscription_id=self._config.subscription_id, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _decompress = kwargs.pop("decompress", True) - _stream = kwargs.pop("stream", False) - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - if _stream: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize( - _models.ErrorResponse, - response, - ) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - if _stream: - deserialized = response.iter_bytes() if _decompress else response.iter_raw() - else: - deserialized = _deserialize(_models.ClusterMeshProfile, response.json()) - - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - - return deserialized # type: ignore - - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "fleet_name", - "cluster_mesh_profile_name", - "content_type", - "accept", - "etag", - "match_condition", - ] - }, - api_versions_list=["2026-03-02-preview"], - ) - def _create_or_update_initial( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - resource: Union[_models.ClusterMeshProfile, JSON, IO[bytes]], - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - if match_condition == MatchConditions.IfNotModified: - error_map[412] = ResourceModifiedError - elif match_condition == MatchConditions.IfPresent: - error_map[412] = ResourceNotFoundError - elif match_condition == MatchConditions.IfMissing: - error_map[412] = ResourceExistsError - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _content = None - if isinstance(resource, (IOBase, bytes)): - _content = resource - else: - _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore - - _request = build_cluster_mesh_profiles_create_or_update_request( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - cluster_mesh_profile_name=cluster_mesh_profile_name, - subscription_id=self._config.subscription_id, - etag=etag, - match_condition=match_condition, - content_type=content_type, - api_version=self._config.api_version, - content=_content, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _decompress = kwargs.pop("decompress", True) - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 201]: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize( - _models.ErrorResponse, - response, - ) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 201: - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() if _decompress else response.iter_raw() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - resource: _models.ClusterMeshProfile, - *, - content_type: str = "application/json", - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> LROPoller[_models.ClusterMeshProfile]: - """Create a ClusterMeshProfile. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :param cluster_mesh_profile_name: The name of the ClusterMeshProfile resource. Required. - :type cluster_mesh_profile_name: str - :param resource: Resource create parameters. Required. - :type resource: ~azure.mgmt.containerservicefleet.models.ClusterMeshProfile - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is - None. - :paramtype etag: str - :keyword match_condition: The match condition to use upon the etag. Default value is None. - :paramtype match_condition: ~azure.core.MatchConditions - :return: An instance of LROPoller that returns ClusterMeshProfile. The ClusterMeshProfile is - compatible with MutableMapping - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.containerservicefleet.models.ClusterMeshProfile] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - resource: JSON, - *, - content_type: str = "application/json", - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> LROPoller[_models.ClusterMeshProfile]: - """Create a ClusterMeshProfile. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :param cluster_mesh_profile_name: The name of the ClusterMeshProfile resource. Required. - :type cluster_mesh_profile_name: str - :param resource: Resource create parameters. Required. - :type resource: JSON - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is - None. - :paramtype etag: str - :keyword match_condition: The match condition to use upon the etag. Default value is None. - :paramtype match_condition: ~azure.core.MatchConditions - :return: An instance of LROPoller that returns ClusterMeshProfile. The ClusterMeshProfile is - compatible with MutableMapping - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.containerservicefleet.models.ClusterMeshProfile] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def begin_create_or_update( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - resource: IO[bytes], - *, - content_type: str = "application/json", - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> LROPoller[_models.ClusterMeshProfile]: - """Create a ClusterMeshProfile. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :param cluster_mesh_profile_name: The name of the ClusterMeshProfile resource. Required. - :type cluster_mesh_profile_name: str - :param resource: Resource create parameters. Required. - :type resource: IO[bytes] - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is - None. - :paramtype etag: str - :keyword match_condition: The match condition to use upon the etag. Default value is None. - :paramtype match_condition: ~azure.core.MatchConditions - :return: An instance of LROPoller that returns ClusterMeshProfile. The ClusterMeshProfile is - compatible with MutableMapping - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.containerservicefleet.models.ClusterMeshProfile] - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "fleet_name", - "cluster_mesh_profile_name", - "content_type", - "accept", - "etag", - "match_condition", - ] - }, - api_versions_list=["2026-03-02-preview"], - ) - def begin_create_or_update( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - resource: Union[_models.ClusterMeshProfile, JSON, IO[bytes]], - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> LROPoller[_models.ClusterMeshProfile]: - """Create a ClusterMeshProfile. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :param cluster_mesh_profile_name: The name of the ClusterMeshProfile resource. Required. - :type cluster_mesh_profile_name: str - :param resource: Resource create parameters. Is one of the following types: ClusterMeshProfile, - JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.containerservicefleet.models.ClusterMeshProfile or JSON or - IO[bytes] - :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is - None. - :paramtype etag: str - :keyword match_condition: The match condition to use upon the etag. Default value is None. - :paramtype match_condition: ~azure.core.MatchConditions - :return: An instance of LROPoller that returns ClusterMeshProfile. The ClusterMeshProfile is - compatible with MutableMapping - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.containerservicefleet.models.ClusterMeshProfile] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[_models.ClusterMeshProfile] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._create_or_update_initial( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - cluster_mesh_profile_name=cluster_mesh_profile_name, - resource=resource, - etag=etag, - match_condition=match_condition, - content_type=content_type, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - response = pipeline_response.http_response - deserialized = _deserialize(_models.ClusterMeshProfile, response.json()) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: PollingMethod = cast( - PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.ClusterMeshProfile].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.ClusterMeshProfile]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "fleet_name", - "cluster_mesh_profile_name", - "etag", - "match_condition", - ] - }, - api_versions_list=["2026-03-02-preview"], - ) - def _delete_initial( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - if match_condition == MatchConditions.IfNotModified: - error_map[412] = ResourceModifiedError - elif match_condition == MatchConditions.IfPresent: - error_map[412] = ResourceNotFoundError - elif match_condition == MatchConditions.IfMissing: - error_map[412] = ResourceExistsError - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_cluster_mesh_profiles_delete_request( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - cluster_mesh_profile_name=cluster_mesh_profile_name, - subscription_id=self._config.subscription_id, - etag=etag, - match_condition=match_condition, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _decompress = kwargs.pop("decompress", True) - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202, 204]: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize( - _models.ErrorResponse, - response, - ) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() if _decompress else response.iter_raw() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "fleet_name", - "cluster_mesh_profile_name", - "etag", - "match_condition", - ] - }, - api_versions_list=["2026-03-02-preview"], - ) - def begin_delete( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> LROPoller[None]: - """Delete a ClusterMeshProfile. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :param cluster_mesh_profile_name: The name of the ClusterMeshProfile resource. Required. - :type cluster_mesh_profile_name: str - :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is - None. - :paramtype etag: str - :keyword match_condition: The match condition to use upon the etag. Default value is None. - :paramtype match_condition: ~azure.core.MatchConditions - :return: An instance of LROPoller that returns None - :rtype: ~azure.core.polling.LROPoller[None] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._delete_initial( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - cluster_mesh_profile_name=cluster_mesh_profile_name, - etag=etag, - match_condition=match_condition, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements - if cls: - return cls(pipeline_response, None, {}) # type: ignore + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - if polling is True: - polling_method: PollingMethod = cast( - PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[None].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore +class Operations: # pylint: disable=docstring-missing-param + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.mgmt.containerservicefleet.ContainerServiceFleetMgmtClient`'s + :attr:`operations` attribute. + """ + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: ContainerServiceFleetMgmtClientConfiguration = ( + input_args.pop(0) if input_args else kwargs.pop("config") + ) + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") @distributed_trace - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": ["api_version", "subscription_id", "resource_group_name", "fleet_name", "accept"] - }, - api_versions_list=["2026-03-02-preview"], - ) - def list_by_fleet( - self, resource_group_name: str, fleet_name: str, **kwargs: Any - ) -> ItemPaged["_models.ClusterMeshProfile"]: - """List ClusterMeshProfile resources by Fleet. + def list(self, **kwargs: Any) -> ItemPaged["_models.Operation"]: + """List the operations for the provider. - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :return: An iterator like instance of ClusterMeshProfile - :rtype: - ~azure.core.paging.ItemPaged[~azure.mgmt.containerservicefleet.models.ClusterMeshProfile] + :return: An iterator like instance of Operation + :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.containerservicefleet.models.Operation] :raises ~azure.core.exceptions.HttpResponseError: """ _headers = kwargs.pop("headers", {}) or {} _params = kwargs.pop("params", {}) or {} - cls: ClsType[List[_models.ClusterMeshProfile]] = kwargs.pop("cls", None) + cls: ClsType[List[_models.Operation]] = kwargs.pop("cls", None) error_map: MutableMapping = { 401: ClientAuthenticationError, @@ -2371,10 +1459,7 @@ def list_by_fleet( def prepare_request(next_link=None): if not next_link: - _request = build_cluster_mesh_profiles_list_by_fleet_request( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - subscription_id=self._config.subscription_id, + _request = build_operations_list_request( api_version=self._config.api_version, headers=_headers, params=_params, @@ -2414,7 +1499,7 @@ def prepare_request(next_link=None): def extract_data(pipeline_response): deserialized = pipeline_response.http_response.json() list_of_elem = _deserialize( - List[_models.ClusterMeshProfile], + List[_models.Operation], deserialized.get("value", []), ) if cls: @@ -2442,200 +1527,8 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "fleet_name", - "cluster_mesh_profile_name", - "accept", - "etag", - "match_condition", - ] - }, - api_versions_list=["2026-03-02-preview"], - ) - def _apply_initial( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> Iterator[bytes]: - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - if match_condition == MatchConditions.IfNotModified: - error_map[412] = ResourceModifiedError - elif match_condition == MatchConditions.IfPresent: - error_map[412] = ResourceNotFoundError - elif match_condition == MatchConditions.IfMissing: - error_map[412] = ResourceExistsError - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _request = build_cluster_mesh_profiles_apply_request( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - cluster_mesh_profile_name=cluster_mesh_profile_name, - subscription_id=self._config.subscription_id, - etag=etag, - match_condition=match_condition, - api_version=self._config.api_version, - headers=_headers, - params=_params, - ) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - _request.url = self._client.format_url(_request.url, **path_format_arguments) - - _decompress = kwargs.pop("decompress", True) - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = _failsafe_deserialize( - _models.ErrorResponse, - response, - ) - raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) - - response_headers = {} - if response.status_code == 202: - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - - deserialized = response.iter_bytes() if _decompress else response.iter_raw() - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - @api_version_validation( - method_added_on="2026-03-02-preview", - params_added_on={ - "2026-03-02-preview": [ - "api_version", - "subscription_id", - "resource_group_name", - "fleet_name", - "cluster_mesh_profile_name", - "accept", - "etag", - "match_condition", - ] - }, - api_versions_list=["2026-03-02-preview"], - ) - def begin_apply( - self, - resource_group_name: str, - fleet_name: str, - cluster_mesh_profile_name: str, - *, - etag: Optional[str] = None, - match_condition: Optional[MatchConditions] = None, - **kwargs: Any - ) -> LROPoller[_models.ClusterMeshProfile]: - """Applies the cluster mesh profile to selected fleet members. - - :param resource_group_name: The name of the resource group. The name is case insensitive. - Required. - :type resource_group_name: str - :param fleet_name: The name of the Fleet resource. Required. - :type fleet_name: str - :param cluster_mesh_profile_name: The name of the ClusterMeshProfile resource. Required. - :type cluster_mesh_profile_name: str - :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is - None. - :paramtype etag: str - :keyword match_condition: The match condition to use upon the etag. Default value is None. - :paramtype match_condition: ~azure.core.MatchConditions - :return: An instance of LROPoller that returns ClusterMeshProfile. The ClusterMeshProfile is - compatible with MutableMapping - :rtype: - ~azure.core.polling.LROPoller[~azure.mgmt.containerservicefleet.models.ClusterMeshProfile] - :raises ~azure.core.exceptions.HttpResponseError: - """ - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[_models.ClusterMeshProfile] = kwargs.pop("cls", None) - polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) - lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) - cont_token: Optional[str] = kwargs.pop("continuation_token", None) - if cont_token is None: - raw_result = self._apply_initial( - resource_group_name=resource_group_name, - fleet_name=fleet_name, - cluster_mesh_profile_name=cluster_mesh_profile_name, - etag=etag, - match_condition=match_condition, - cls=lambda x, y, z: x, - headers=_headers, - params=_params, - **kwargs - ) - raw_result.http_response.read() # type: ignore - kwargs.pop("error_map", None) - - def get_long_running_output(pipeline_response): - response = pipeline_response.http_response - deserialized = _deserialize(_models.ClusterMeshProfile, response.json()) - if cls: - return cls(pipeline_response, deserialized, {}) # type: ignore - return deserialized - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True), - } - - if polling is True: - polling_method: PollingMethod = cast( - PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - ) - elif polling is False: - polling_method = cast(PollingMethod, NoPolling()) - else: - polling_method = polling - if cont_token: - return LROPoller[_models.ClusterMeshProfile].from_continuation_token( - polling_method=polling_method, - continuation_token=cont_token, - client=self._client, - deserialization_callback=get_long_running_output, - ) - return LROPoller[_models.ClusterMeshProfile]( - self._client, raw_result, get_long_running_output, polling_method # type: ignore - ) - -class FleetsOperations: +class FleetsOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -2728,7 +1621,7 @@ def _begin_create_or_update_initial( self, resource_group_name: str, fleet_name: str, - resource: Union[_models.Fleet, JSON, IO[bytes]], + resource: Union[_models.Fleet, _types.Fleet, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -2849,7 +1742,7 @@ def begin_create_or_update( self, resource_group_name: str, fleet_name: str, - resource: JSON, + resource: _types.Fleet, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -2864,7 +1757,7 @@ def begin_create_or_update( :param fleet_name: The name of the Fleet resource. Required. :type fleet_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.containerservicefleet.types.Fleet :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -2919,7 +1812,7 @@ def begin_create_or_update( self, resource_group_name: str, fleet_name: str, - resource: Union[_models.Fleet, JSON, IO[bytes]], + resource: Union[_models.Fleet, _types.Fleet, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -2932,9 +1825,10 @@ def begin_create_or_update( :type resource_group_name: str :param fleet_name: The name of the Fleet resource. Required. :type fleet_name: str - :param resource: Resource create parameters. Is one of the following types: Fleet, JSON, - IO[bytes] Required. - :type resource: ~azure.mgmt.containerservicefleet.models.Fleet or JSON or IO[bytes] + :param resource: Resource create parameters. Is either a Fleet type or a IO[bytes] type. + Required. + :type resource: ~azure.mgmt.containerservicefleet.models.Fleet or + ~azure.mgmt.containerservicefleet.types.Fleet or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -3025,13 +1919,14 @@ def get_long_running_output(pipeline_response): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def _begin_update_initial( self, resource_group_name: str, fleet_name: str, - properties: Union[_models.FleetPatch, JSON, IO[bytes]], + properties: Union[_models.FleetPatch, _types.FleetPatch, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -3153,7 +2048,7 @@ def begin_update( self, resource_group_name: str, fleet_name: str, - properties: JSON, + properties: _types.FleetPatch, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -3168,7 +2063,7 @@ def begin_update( :param fleet_name: The name of the Fleet resource. Required. :type fleet_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.containerservicefleet.types.FleetPatch :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -3245,13 +2140,14 @@ def begin_update( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def begin_update( self, resource_group_name: str, fleet_name: str, - properties: Union[_models.FleetPatch, JSON, IO[bytes]], + properties: Union[_models.FleetPatch, _types.FleetPatch, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -3264,9 +2160,10 @@ def begin_update( :type resource_group_name: str :param fleet_name: The name of the Fleet resource. Required. :type fleet_name: str - :param properties: The resource properties to be updated. Is one of the following types: - FleetPatch, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.containerservicefleet.models.FleetPatch or JSON or IO[bytes] + :param properties: The resource properties to be updated. Is either a FleetPatch type or a + IO[bytes] type. Required. + :type properties: ~azure.mgmt.containerservicefleet.models.FleetPatch or + ~azure.mgmt.containerservicefleet.types.FleetPatch or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -3750,7 +2647,7 @@ def list_credentials( return deserialized # type: ignore -class FleetMembersOperations: +class FleetMembersOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -3849,7 +2746,7 @@ def _create_initial( resource_group_name: str, fleet_name: str, fleet_member_name: str, - resource: Union[_models.FleetMember, JSON, IO[bytes]], + resource: Union[_models.FleetMember, _types.FleetMember, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -3975,7 +2872,7 @@ def begin_create( resource_group_name: str, fleet_name: str, fleet_member_name: str, - resource: JSON, + resource: _types.FleetMember, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -3992,7 +2889,7 @@ def begin_create( :param fleet_member_name: The name of the Fleet member resource. Required. :type fleet_member_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.containerservicefleet.types.FleetMember :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -4051,7 +2948,7 @@ def begin_create( resource_group_name: str, fleet_name: str, fleet_member_name: str, - resource: Union[_models.FleetMember, JSON, IO[bytes]], + resource: Union[_models.FleetMember, _types.FleetMember, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -4066,9 +2963,10 @@ def begin_create( :type fleet_name: str :param fleet_member_name: The name of the Fleet member resource. Required. :type fleet_member_name: str - :param resource: Resource create parameters. Is one of the following types: FleetMember, JSON, - IO[bytes] Required. - :type resource: ~azure.mgmt.containerservicefleet.models.FleetMember or JSON or IO[bytes] + :param resource: Resource create parameters. Is either a FleetMember type or a IO[bytes] type. + Required. + :type resource: ~azure.mgmt.containerservicefleet.models.FleetMember or + ~azure.mgmt.containerservicefleet.types.FleetMember or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -4161,6 +3059,7 @@ def get_long_running_output(pipeline_response): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def _begin_update_initial( @@ -4168,7 +3067,7 @@ def _begin_update_initial( resource_group_name: str, fleet_name: str, fleet_member_name: str, - properties: Union[_models.FleetMemberUpdate, JSON, IO[bytes]], + properties: Union[_models.FleetMemberUpdate, _types.FleetMemberUpdate, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -4295,7 +3194,7 @@ def begin_update( resource_group_name: str, fleet_name: str, fleet_member_name: str, - properties: JSON, + properties: _types.FleetMemberUpdate, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -4312,7 +3211,7 @@ def begin_update( :param fleet_member_name: The name of the Fleet member resource. Required. :type fleet_member_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.containerservicefleet.types.FleetMemberUpdate :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -4393,6 +3292,7 @@ def begin_update( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def begin_update( @@ -4400,7 +3300,7 @@ def begin_update( resource_group_name: str, fleet_name: str, fleet_member_name: str, - properties: Union[_models.FleetMemberUpdate, JSON, IO[bytes]], + properties: Union[_models.FleetMemberUpdate, _types.FleetMemberUpdate, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -4415,10 +3315,10 @@ def begin_update( :type fleet_name: str :param fleet_member_name: The name of the Fleet member resource. Required. :type fleet_member_name: str - :param properties: The resource properties to be updated. Is one of the following types: - FleetMemberUpdate, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.containerservicefleet.models.FleetMemberUpdate or JSON or - IO[bytes] + :param properties: The resource properties to be updated. Is either a FleetMemberUpdate type or + a IO[bytes] type. Required. + :type properties: ~azure.mgmt.containerservicefleet.models.FleetMemberUpdate or + ~azure.mgmt.containerservicefleet.types.FleetMemberUpdate or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -4757,7 +3657,7 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) -class FleetManagedNamespacesOperations: +class FleetManagedNamespacesOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -4789,7 +3689,7 @@ def __init__(self, *args, **kwargs) -> None: "accept", ] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) def get( self, resource_group_name: str, fleet_name: str, managed_namespace_name: str, **kwargs: Any @@ -4880,14 +3780,14 @@ def get( "match_condition", ] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) def _create_or_update_initial( self, resource_group_name: str, fleet_name: str, managed_namespace_name: str, - resource: Union[_models.FleetManagedNamespace, JSON, IO[bytes]], + resource: Union[_models.FleetManagedNamespace, _types.FleetManagedNamespace, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -5017,7 +3917,7 @@ def begin_create_or_update( resource_group_name: str, fleet_name: str, managed_namespace_name: str, - resource: JSON, + resource: _types.FleetManagedNamespace, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -5034,7 +3934,7 @@ def begin_create_or_update( :param managed_namespace_name: The name of the fleet managed namespace resource. Required. :type managed_namespace_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.containerservicefleet.types.FleetManagedNamespace :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -5105,14 +4005,14 @@ def begin_create_or_update( "match_condition", ] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) def begin_create_or_update( self, resource_group_name: str, fleet_name: str, managed_namespace_name: str, - resource: Union[_models.FleetManagedNamespace, JSON, IO[bytes]], + resource: Union[_models.FleetManagedNamespace, _types.FleetManagedNamespace, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -5127,10 +4027,10 @@ def begin_create_or_update( :type fleet_name: str :param managed_namespace_name: The name of the fleet managed namespace resource. Required. :type managed_namespace_name: str - :param resource: Resource create parameters. Is one of the following types: - FleetManagedNamespace, JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.containerservicefleet.models.FleetManagedNamespace or JSON or - IO[bytes] + :param resource: Resource create parameters. Is either a FleetManagedNamespace type or a + IO[bytes] type. Required. + :type resource: ~azure.mgmt.containerservicefleet.models.FleetManagedNamespace or + ~azure.mgmt.containerservicefleet.types.FleetManagedNamespace or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -5210,7 +4110,7 @@ def get_long_running_output(pipeline_response): "match_condition", ] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) def _delete_initial( self, @@ -5303,7 +4203,7 @@ def _delete_initial( "match_condition", ] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) def begin_delete( self, @@ -5386,7 +4286,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- params_added_on={ "2025-08-01-preview": ["api_version", "subscription_id", "resource_group_name", "fleet_name", "accept"] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) def list_by_fleet( self, resource_group_name: str, fleet_name: str, **kwargs: Any @@ -5505,14 +4405,14 @@ def get_next(next_link=None): "match_condition", ] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) def _update_initial( self, resource_group_name: str, fleet_name: str, managed_namespace_name: str, - properties: Union[_models.FleetManagedNamespacePatch, JSON, IO[bytes]], + properties: Union[_models.FleetManagedNamespacePatch, _types.FleetManagedNamespacePatch, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -5640,7 +4540,7 @@ def begin_update( resource_group_name: str, fleet_name: str, managed_namespace_name: str, - properties: JSON, + properties: _types.FleetManagedNamespacePatch, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -5657,7 +4557,7 @@ def begin_update( :param managed_namespace_name: The name of the fleet managed namespace resource. Required. :type managed_namespace_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.containerservicefleet.types.FleetManagedNamespacePatch :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -5728,14 +4628,14 @@ def begin_update( "match_condition", ] }, - api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=["2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", "2026-06-01"], ) def begin_update( self, resource_group_name: str, fleet_name: str, managed_namespace_name: str, - properties: Union[_models.FleetManagedNamespacePatch, JSON, IO[bytes]], + properties: Union[_models.FleetManagedNamespacePatch, _types.FleetManagedNamespacePatch, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -5750,10 +4650,10 @@ def begin_update( :type fleet_name: str :param managed_namespace_name: The name of the fleet managed namespace resource. Required. :type managed_namespace_name: str - :param properties: The resource properties to be updated. Is one of the following types: - FleetManagedNamespacePatch, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.containerservicefleet.models.FleetManagedNamespacePatch or JSON - or IO[bytes] + :param properties: The resource properties to be updated. Is either a + FleetManagedNamespacePatch type or a IO[bytes] type. Required. + :type properties: ~azure.mgmt.containerservicefleet.models.FleetManagedNamespacePatch or + ~azure.mgmt.containerservicefleet.types.FleetManagedNamespacePatch or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -5821,7 +4721,7 @@ def get_long_running_output(pipeline_response): ) -class GatesOperations: +class GatesOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -5853,7 +4753,13 @@ def __init__(self, *args, **kwargs) -> None: "accept", ] }, - api_versions_list=["2025-04-01-preview", "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=[ + "2025-04-01-preview", + "2025-08-01-preview", + "2026-02-01-preview", + "2026-03-02-preview", + "2026-06-01", + ], ) def get(self, resource_group_name: str, fleet_name: str, gate_name: str, **kwargs: Any) -> _models.Gate: """Get a Gate. @@ -5942,14 +4848,20 @@ def get(self, resource_group_name: str, fleet_name: str, gate_name: str, **kwarg "match_condition", ] }, - api_versions_list=["2025-04-01-preview", "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=[ + "2025-04-01-preview", + "2025-08-01-preview", + "2026-02-01-preview", + "2026-03-02-preview", + "2026-06-01", + ], ) def _update_initial( self, resource_group_name: str, fleet_name: str, gate_name: str, - properties: Union[_models.GatePatch, JSON, IO[bytes]], + properties: Union[_models.GatePatch, _types.GatePatch, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -6075,7 +4987,7 @@ def begin_update( resource_group_name: str, fleet_name: str, gate_name: str, - properties: JSON, + properties: _types.GatePatch, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -6092,7 +5004,7 @@ def begin_update( :param gate_name: The name of the Gate resource, a GUID. Required. :type gate_name: str :param properties: The resource properties to be updated. Required. - :type properties: JSON + :type properties: ~azure.mgmt.containerservicefleet.types.GatePatch :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -6159,14 +5071,20 @@ def begin_update( "match_condition", ] }, - api_versions_list=["2025-04-01-preview", "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=[ + "2025-04-01-preview", + "2025-08-01-preview", + "2026-02-01-preview", + "2026-03-02-preview", + "2026-06-01", + ], ) def begin_update( self, resource_group_name: str, fleet_name: str, gate_name: str, - properties: Union[_models.GatePatch, JSON, IO[bytes]], + properties: Union[_models.GatePatch, _types.GatePatch, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -6181,9 +5099,10 @@ def begin_update( :type fleet_name: str :param gate_name: The name of the Gate resource, a GUID. Required. :type gate_name: str - :param properties: The resource properties to be updated. Is one of the following types: - GatePatch, JSON, IO[bytes] Required. - :type properties: ~azure.mgmt.containerservicefleet.models.GatePatch or JSON or IO[bytes] + :param properties: The resource properties to be updated. Is either a GatePatch type or a + IO[bytes] type. Required. + :type properties: ~azure.mgmt.containerservicefleet.models.GatePatch or + ~azure.mgmt.containerservicefleet.types.GatePatch or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -6263,7 +5182,13 @@ def get_long_running_output(pipeline_response): "accept", ] }, - api_versions_list=["2025-04-01-preview", "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview"], + api_versions_list=[ + "2025-04-01-preview", + "2025-08-01-preview", + "2026-02-01-preview", + "2026-03-02-preview", + "2026-06-01", + ], ) def list_by_fleet( self, @@ -6384,7 +5309,7 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) -class UpdateRunsOperations: +class UpdateRunsOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -6429,6 +5354,7 @@ def __init__(self, *args, **kwargs) -> None: "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def get(self, resource_group_name: str, fleet_name: str, update_run_name: str, **kwargs: Any) -> _models.UpdateRun: @@ -6531,6 +5457,7 @@ def get(self, resource_group_name: str, fleet_name: str, update_run_name: str, * "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def _create_or_update_initial( @@ -6538,7 +5465,7 @@ def _create_or_update_initial( resource_group_name: str, fleet_name: str, update_run_name: str, - resource: Union[_models.UpdateRun, JSON, IO[bytes]], + resource: Union[_models.UpdateRun, _types.UpdateRun, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -6664,7 +5591,7 @@ def begin_create_or_update( resource_group_name: str, fleet_name: str, update_run_name: str, - resource: JSON, + resource: _types.UpdateRun, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -6681,7 +5608,7 @@ def begin_create_or_update( :param update_run_name: The name of the UpdateRun resource. Required. :type update_run_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.containerservicefleet.types.UpdateRun :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -6763,6 +5690,7 @@ def begin_create_or_update( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def begin_create_or_update( @@ -6770,7 +5698,7 @@ def begin_create_or_update( resource_group_name: str, fleet_name: str, update_run_name: str, - resource: Union[_models.UpdateRun, JSON, IO[bytes]], + resource: Union[_models.UpdateRun, _types.UpdateRun, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -6785,9 +5713,10 @@ def begin_create_or_update( :type fleet_name: str :param update_run_name: The name of the UpdateRun resource. Required. :type update_run_name: str - :param resource: Resource create parameters. Is one of the following types: UpdateRun, JSON, - IO[bytes] Required. - :type resource: ~azure.mgmt.containerservicefleet.models.UpdateRun or JSON or IO[bytes] + :param resource: Resource create parameters. Is either a UpdateRun type or a IO[bytes] type. + Required. + :type resource: ~azure.mgmt.containerservicefleet.models.UpdateRun or + ~azure.mgmt.containerservicefleet.types.UpdateRun or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -6879,6 +5808,7 @@ def get_long_running_output(pipeline_response): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def _delete_initial( @@ -6985,6 +5915,7 @@ def _delete_initial( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def begin_delete( @@ -7089,6 +6020,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def list_by_fleet( @@ -7232,6 +6164,7 @@ def get_next(next_link=None): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def _start_initial( @@ -7339,6 +6272,7 @@ def _start_initial( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def begin_start( @@ -7449,6 +6383,7 @@ def get_long_running_output(pipeline_response): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def _stop_initial( @@ -7556,6 +6491,7 @@ def _stop_initial( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def begin_stop( @@ -7663,6 +6599,7 @@ def get_long_running_output(pipeline_response): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def _skip_initial( @@ -7670,7 +6607,7 @@ def _skip_initial( resource_group_name: str, fleet_name: str, update_run_name: str, - body: Union[_models.SkipProperties, JSON, IO[bytes]], + body: Union[_models.SkipProperties, _types.SkipProperties, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -7797,7 +6734,7 @@ def begin_skip( resource_group_name: str, fleet_name: str, update_run_name: str, - body: JSON, + body: _types.SkipProperties, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -7814,7 +6751,7 @@ def begin_skip( :param update_run_name: The name of the UpdateRun resource. Required. :type update_run_name: str :param body: The content of the action request. Required. - :type body: JSON + :type body: ~azure.mgmt.containerservicefleet.types.SkipProperties :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -7892,6 +6829,7 @@ def begin_skip( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def begin_skip( @@ -7899,7 +6837,7 @@ def begin_skip( resource_group_name: str, fleet_name: str, update_run_name: str, - body: Union[_models.SkipProperties, JSON, IO[bytes]], + body: Union[_models.SkipProperties, _types.SkipProperties, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -7914,9 +6852,10 @@ def begin_skip( :type fleet_name: str :param update_run_name: The name of the UpdateRun resource. Required. :type update_run_name: str - :param body: The content of the action request. Is one of the following types: SkipProperties, - JSON, IO[bytes] Required. - :type body: ~azure.mgmt.containerservicefleet.models.SkipProperties or JSON or IO[bytes] + :param body: The content of the action request. Is either a SkipProperties type or a IO[bytes] + type. Required. + :type body: ~azure.mgmt.containerservicefleet.models.SkipProperties or + ~azure.mgmt.containerservicefleet.types.SkipProperties or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -7983,7 +6922,7 @@ def get_long_running_output(pipeline_response): ) -class FleetUpdateStrategiesOperations: +class FleetUpdateStrategiesOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -8026,6 +6965,7 @@ def __init__(self, *args, **kwargs) -> None: "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def get( @@ -8128,6 +7068,7 @@ def get( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def _create_or_update_initial( @@ -8135,7 +7076,7 @@ def _create_or_update_initial( resource_group_name: str, fleet_name: str, update_strategy_name: str, - resource: Union[_models.FleetUpdateStrategy, JSON, IO[bytes]], + resource: Union[_models.FleetUpdateStrategy, _types.FleetUpdateStrategy, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -8262,7 +7203,7 @@ def begin_create_or_update( resource_group_name: str, fleet_name: str, update_strategy_name: str, - resource: JSON, + resource: _types.FleetUpdateStrategy, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -8279,7 +7220,7 @@ def begin_create_or_update( :param update_strategy_name: The name of the UpdateStrategy resource. Required. :type update_strategy_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.containerservicefleet.types.FleetUpdateStrategy :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -8361,6 +7302,7 @@ def begin_create_or_update( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def begin_create_or_update( @@ -8368,7 +7310,7 @@ def begin_create_or_update( resource_group_name: str, fleet_name: str, update_strategy_name: str, - resource: Union[_models.FleetUpdateStrategy, JSON, IO[bytes]], + resource: Union[_models.FleetUpdateStrategy, _types.FleetUpdateStrategy, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -8383,10 +7325,10 @@ def begin_create_or_update( :type fleet_name: str :param update_strategy_name: The name of the UpdateStrategy resource. Required. :type update_strategy_name: str - :param resource: Resource create parameters. Is one of the following types: - FleetUpdateStrategy, JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.containerservicefleet.models.FleetUpdateStrategy or JSON or - IO[bytes] + :param resource: Resource create parameters. Is either a FleetUpdateStrategy type or a + IO[bytes] type. Required. + :type resource: ~azure.mgmt.containerservicefleet.models.FleetUpdateStrategy or + ~azure.mgmt.containerservicefleet.types.FleetUpdateStrategy or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -8477,6 +7419,7 @@ def get_long_running_output(pipeline_response): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def _delete_initial( @@ -8581,6 +7524,7 @@ def _delete_initial( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def begin_delete( @@ -8683,6 +7627,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def list_by_fleet( @@ -8801,7 +7746,7 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) -class AutoUpgradeProfilesOperations: +class AutoUpgradeProfilesOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -8840,6 +7785,7 @@ def __init__(self, *args, **kwargs) -> None: "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def get( @@ -8938,6 +7884,7 @@ def get( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def _create_or_update_initial( @@ -8945,7 +7892,7 @@ def _create_or_update_initial( resource_group_name: str, fleet_name: str, auto_upgrade_profile_name: str, - resource: Union[_models.AutoUpgradeProfile, JSON, IO[bytes]], + resource: Union[_models.AutoUpgradeProfile, _types.AutoUpgradeProfile, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -9075,7 +8022,7 @@ def begin_create_or_update( resource_group_name: str, fleet_name: str, auto_upgrade_profile_name: str, - resource: JSON, + resource: _types.AutoUpgradeProfile, *, content_type: str = "application/json", etag: Optional[str] = None, @@ -9092,7 +8039,7 @@ def begin_create_or_update( :param auto_upgrade_profile_name: The name of the AutoUpgradeProfile resource. Required. :type auto_upgrade_profile_name: str :param resource: Resource create parameters. Required. - :type resource: JSON + :type resource: ~azure.mgmt.containerservicefleet.types.AutoUpgradeProfile :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -9170,6 +8117,7 @@ def begin_create_or_update( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def begin_create_or_update( @@ -9177,7 +8125,7 @@ def begin_create_or_update( resource_group_name: str, fleet_name: str, auto_upgrade_profile_name: str, - resource: Union[_models.AutoUpgradeProfile, JSON, IO[bytes]], + resource: Union[_models.AutoUpgradeProfile, _types.AutoUpgradeProfile, IO[bytes]], *, etag: Optional[str] = None, match_condition: Optional[MatchConditions] = None, @@ -9192,10 +8140,10 @@ def begin_create_or_update( :type fleet_name: str :param auto_upgrade_profile_name: The name of the AutoUpgradeProfile resource. Required. :type auto_upgrade_profile_name: str - :param resource: Resource create parameters. Is one of the following types: AutoUpgradeProfile, - JSON, IO[bytes] Required. - :type resource: ~azure.mgmt.containerservicefleet.models.AutoUpgradeProfile or JSON or - IO[bytes] + :param resource: Resource create parameters. Is either a AutoUpgradeProfile type or a IO[bytes] + type. Required. + :type resource: ~azure.mgmt.containerservicefleet.models.AutoUpgradeProfile or + ~azure.mgmt.containerservicefleet.types.AutoUpgradeProfile or IO[bytes] :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is None. :paramtype etag: str @@ -9282,6 +8230,7 @@ def get_long_running_output(pipeline_response): "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def _delete_initial( @@ -9382,6 +8331,7 @@ def _delete_initial( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def begin_delete( @@ -9480,6 +8430,7 @@ def get_long_running_output(pipeline_response): # pylint: disable=inconsistent- "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def list_by_fleet( @@ -9598,7 +8549,7 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) -class AutoUpgradeProfileOperationsOperations: +class AutoUpgradeProfileOperationsOperations: # pylint: disable=docstring-missing-param """ .. warning:: **DO NOT** instantiate this class directly. @@ -9635,6 +8586,7 @@ def __init__(self, *args, **kwargs) -> None: "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def _generate_update_run_initial( @@ -9721,6 +8673,7 @@ def _generate_update_run_initial( "2025-08-01-preview", "2026-02-01-preview", "2026-03-02-preview", + "2026-06-01", ], ) def begin_generate_update_run( diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/operations/_patch.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/operations/_patch.py index ea765788358a..87676c65a8f0 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/operations/_patch.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/operations/_patch.py @@ -8,6 +8,7 @@ Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ + __all__: list[str] = [] # Add all objects you want publicly available to users at this package level diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/types.py b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/types.py new file mode 100644 index 000000000000..ae8d75a1a1db --- /dev/null +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/azure/mgmt/containerservicefleet/types.py @@ -0,0 +1,1706 @@ +# pylint: disable=line-too-long,useless-suppression,too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from typing import Any, TYPE_CHECKING, Union +from typing_extensions import Required, TypedDict + +if TYPE_CHECKING: + from .models import ( + AdoptionPolicy, + AutoUpgradeLastTriggerStatus, + AutoUpgradeNodeImageSelectionType, + AutoUpgradeProfileProvisioningState, + CreatedByType, + DeletePolicy, + FleetManagedNamespaceProvisioningState, + FleetMemberProvisioningState, + FleetProvisioningState, + FleetUpdateStrategyProvisioningState, + GateState, + GateType, + LabelSelectorOperator, + ManagedClusterUpgradeType, + ManagedServiceIdentityType, + NodeImageSelectionType, + PlacementType, + PolicyRule, + PropagationType, + PropertySelectorOperator, + TaintEffect, + TargetType, + TolerationOperator, + UpdateRunProvisioningState, + UpdateState, + UpgradeChannel, + ) + + +class Affinity(TypedDict, total=False): + """Affinity is a group of cluster affinity scheduling rules. More to be added. + + :ivar clusterAffinity: ClusterAffinity contains cluster affinity scheduling rules for the + selected resources. + :vartype clusterAffinity: "ClusterAffinity" + """ + + clusterAffinity: "ClusterAffinity" + """ClusterAffinity contains cluster affinity scheduling rules for the selected resources.""" + + +class AgentProfile(TypedDict, total=False): + """Agent profile for the Fleet hub. + + :ivar subnetId: The ID of the subnet which the Fleet hub node will join on startup. If this is + not specified, a vnet and subnet will be generated and used. + :vartype subnetId: str + :ivar vmSize: The virtual machine size of the Fleet hub. + :vartype vmSize: str + """ + + subnetId: str + """The ID of the subnet which the Fleet hub node will join on startup. If this is not specified, a + vnet and subnet will be generated and used.""" + vmSize: str + """The virtual machine size of the Fleet hub.""" + + +class APIServerAccessProfile(TypedDict, total=False): + """Access profile for the Fleet hub API server. + + :ivar enablePrivateCluster: Whether to create the Fleet hub as a private cluster or not. + :vartype enablePrivateCluster: bool + :ivar enableVnetIntegration: Whether to enable apiserver vnet integration for the Fleet hub or + not. + :vartype enableVnetIntegration: bool + :ivar subnetId: The subnet to be used when apiserver vnet integration is enabled. It is + required when creating a new Fleet with BYO vnet. + :vartype subnetId: str + """ + + enablePrivateCluster: bool + """Whether to create the Fleet hub as a private cluster or not.""" + enableVnetIntegration: bool + """Whether to enable apiserver vnet integration for the Fleet hub or not.""" + subnetId: str + """The subnet to be used when apiserver vnet integration is enabled. It is required when creating + a new Fleet with BYO vnet.""" + + +class AutoUpgradeNodeImageSelection(TypedDict, total=False): + """The node image upgrade to be applied to the target clusters in auto upgrade. + + :ivar type: The node image upgrade type. Required. Known values are: "Latest" and "Consistent". + :vartype type: Union[str, "AutoUpgradeNodeImageSelectionType"] + """ + + type: Required[Union[str, "AutoUpgradeNodeImageSelectionType"]] + """The node image upgrade type. Required. Known values are: \"Latest\" and \"Consistent\".""" + + +class Resource(TypedDict, total=False): + """Resource. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar systemData: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype systemData: "SystemData" + """ + + id: str + """Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.""" + name: str + """The name of the resource.""" + type: str + """The type of the resource. E.g. \"Microsoft.Compute/virtualMachines\" or + \"Microsoft.Storage/storageAccounts\".""" + systemData: "SystemData" + """Azure Resource Manager metadata containing createdBy and modifiedBy information.""" + + +class ProxyResource(Resource): + """Proxy Resource. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar systemData: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype systemData: "SystemData" + """ + + +class AutoUpgradeProfile(ProxyResource): + """The AutoUpgradeProfile resource. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar systemData: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype systemData: "SystemData" + :ivar properties: The resource-specific properties for this resource. + :vartype properties: "AutoUpgradeProfileProperties" + :ivar eTag: If eTag is provided in the response body, it may also be provided as a header per + the normal etag convention. Entity tags are used for comparing two or more entities from the + same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match + (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. + :vartype eTag: str + """ + + properties: "AutoUpgradeProfileProperties" + """The resource-specific properties for this resource.""" + eTag: str + """If eTag is provided in the response body, it may also be provided as a header per the normal + etag convention. Entity tags are used for comparing two or more entities from the same + requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section + 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.""" + + +class AutoUpgradeProfileProperties(TypedDict, total=False): + """The properties of the AutoUpgradeProfile. + + :ivar provisioningState: The provisioning state of the AutoUpgradeProfile resource. Known + values are: "Succeeded", "Failed", and "Canceled". + :vartype provisioningState: Union[str, "AutoUpgradeProfileProvisioningState"] + :ivar updateStrategyId: The resource id of the UpdateStrategy resource to reference. If not + specified, the auto upgrade will run on all clusters which are members of the fleet. + :vartype updateStrategyId: str + :ivar channel: Configures how auto-upgrade will be run. Required. Known values are: "Stable", + "Rapid", "NodeImage", and "TargetKubernetesVersion". + :vartype channel: Union[str, "UpgradeChannel"] + :ivar nodeImageSelection: The node image upgrade to be applied to the target clusters in auto + upgrade. + :vartype nodeImageSelection: "AutoUpgradeNodeImageSelection" + :ivar disabled: If set to False: the auto upgrade has effect - target managed clusters will be + upgraded on schedule. If set to True: the auto upgrade has no effect - no upgrade will be run + on the target managed clusters. This is a boolean and not an enum because enabled/disabled are + all available states of the auto upgrade profile. By default, this is set to False. + :vartype disabled: bool + :ivar autoUpgradeProfileStatus: The status of the auto upgrade profile. + :vartype autoUpgradeProfileStatus: "AutoUpgradeProfileStatus" + :ivar targetKubernetesVersion: This is the target Kubernetes version for auto-upgrade. The + format must be ``{major version}.{minor version}``. For example, "1.30". By default, this is + empty. If upgrade channel is set to TargetKubernetesVersion, this field must not be empty. If + upgrade channel is Rapid, Stable or NodeImage, this field must be empty. + :vartype targetKubernetesVersion: str + :ivar longTermSupport: If upgrade channel is not TargetKubernetesVersion, this field must be + False. If set to True: Fleet auto upgrade will continue generate update runs for patches of + minor versions earlier than N-2 (where N is the latest supported minor version) if those minor + versions support Long-Term Support (LTS). By default, this is set to False. For more + information on AKS LTS, please see + `https://learn.microsoft.com/en-us/azure/aks/long-term-support + `_. + :vartype longTermSupport: bool + """ + + provisioningState: Union[str, "AutoUpgradeProfileProvisioningState"] + """The provisioning state of the AutoUpgradeProfile resource. Known values are: \"Succeeded\", + \"Failed\", and \"Canceled\".""" + updateStrategyId: str + """The resource id of the UpdateStrategy resource to reference. If not specified, the auto upgrade + will run on all clusters which are members of the fleet.""" + channel: Required[Union[str, "UpgradeChannel"]] + """Configures how auto-upgrade will be run. Required. Known values are: \"Stable\", \"Rapid\", + \"NodeImage\", and \"TargetKubernetesVersion\".""" + nodeImageSelection: "AutoUpgradeNodeImageSelection" + """The node image upgrade to be applied to the target clusters in auto upgrade.""" + disabled: bool + """If set to False: the auto upgrade has effect - target managed clusters will be upgraded on + schedule. If set to True: the auto upgrade has no effect - no upgrade will be run on the target + managed clusters. This is a boolean and not an enum because enabled/disabled are all available + states of the auto upgrade profile. By default, this is set to False.""" + autoUpgradeProfileStatus: "AutoUpgradeProfileStatus" + """The status of the auto upgrade profile.""" + targetKubernetesVersion: str + """This is the target Kubernetes version for auto-upgrade. The format must be ``{major + version}.{minor version}``. For example, \"1.30\". By default, this is empty. If upgrade + channel is set to TargetKubernetesVersion, this field must not be empty. If upgrade channel is + Rapid, Stable or NodeImage, this field must be empty.""" + longTermSupport: bool + """If upgrade channel is not TargetKubernetesVersion, this field must be False. If set to True: + Fleet auto upgrade will continue generate update runs for patches of minor versions earlier + than N-2 (where N is the latest supported minor version) if those minor versions support + Long-Term Support (LTS). By default, this is set to False. For more information on AKS LTS, + please see `https://learn.microsoft.com/en-us/azure/aks/long-term-support + `_.""" + + +class AutoUpgradeProfileStatus(TypedDict, total=False): + """AutoUpgradeProfileStatus is the status of an auto upgrade profile. + + :ivar lastTriggeredAt: The UTC time of the last attempt to automatically create and start an + UpdateRun as triggered by the release of new versions. + :vartype lastTriggeredAt: str + :ivar lastTriggerStatus: The status of the last AutoUpgrade trigger. Known values are: + "Succeeded" and "Failed". + :vartype lastTriggerStatus: Union[str, "AutoUpgradeLastTriggerStatus"] + :ivar lastTriggerError: The error details of the last trigger. + :vartype lastTriggerError: "ErrorDetail" + :ivar lastTriggerUpgradeVersions: The target Kubernetes version or node image versions of the + last trigger. + :vartype lastTriggerUpgradeVersions: list[str] + """ + + lastTriggeredAt: str + """The UTC time of the last attempt to automatically create and start an UpdateRun as triggered by + the release of new versions.""" + lastTriggerStatus: Union[str, "AutoUpgradeLastTriggerStatus"] + """The status of the last AutoUpgrade trigger. Known values are: \"Succeeded\" and \"Failed\".""" + lastTriggerError: "ErrorDetail" + """The error details of the last trigger.""" + lastTriggerUpgradeVersions: list[str] + """The target Kubernetes version or node image versions of the last trigger.""" + + +class ClusterAffinity(TypedDict, total=False): + """ClusterAffinity contains cluster affinity scheduling rules for the selected resources. + + :ivar requiredDuringSchedulingIgnoredDuringExecution: If the affinity requirements specified by + this field are not met at scheduling time, the resource will not be scheduled onto the cluster. + If the affinity requirements specified by this field cease to be met at some point after the + placement (e.g. due to an update), the system may or may not try to eventually remove the + resource from the cluster. + :vartype requiredDuringSchedulingIgnoredDuringExecution: "ClusterSelector" + """ + + requiredDuringSchedulingIgnoredDuringExecution: "ClusterSelector" + """If the affinity requirements specified by this field are not met at scheduling time, the + resource will not be scheduled onto the cluster. If the affinity requirements specified by this + field cease to be met at some point after the placement (e.g. due to an update), the system may + or may not try to eventually remove the resource from the cluster.""" + + +class ClusterResourcePlacementSpec(TypedDict, total=False): + """ClusterResourcePlacementSpec defines the desired state of ClusterResourcePlacement. + + :ivar policy: Policy defines how to select member clusters to place the selected resources. If + unspecified, all the joined member clusters are selected. + :vartype policy: "PlacementPolicy" + """ + + policy: "PlacementPolicy" + """Policy defines how to select member clusters to place the selected resources. If unspecified, + all the joined member clusters are selected.""" + + +class ClusterSelector(TypedDict, total=False): + """ClusterSelector. + + :ivar clusterSelectorTerms: ClusterSelectorTerms is a list of cluster selector terms. The terms + are ``ORed``. Required. + :vartype clusterSelectorTerms: list["ClusterSelectorTerm"] + """ + + clusterSelectorTerms: Required[list["ClusterSelectorTerm"]] + """ClusterSelectorTerms is a list of cluster selector terms. The terms are ``ORed``. Required.""" + + +class ClusterSelectorTerm(TypedDict, total=False): + """ClusterSelectorTerm. + + :ivar labelSelector: LabelSelector is a label query over all the joined member clusters. + Clusters matching the query are selected. If you specify both label and property selectors in + the same term, the results are AND'd. + :vartype labelSelector: "LabelSelector" + :ivar propertySelector: PropertySelector is a property query over all joined member clusters. + Clusters matching the query are selected. If you specify both label and property selectors in + the same term, the results are AND'd. At this moment, PropertySelector can only be used with + ``RequiredDuringSchedulingIgnoredDuringExecution`` affinity terms. This field is beta-level; it + is for the property-based scheduling feature and is only functional when a property provider is + enabled in the deployment. + :vartype propertySelector: "PropertySelector" + """ + + labelSelector: "LabelSelector" + """LabelSelector is a label query over all the joined member clusters. Clusters matching the query + are selected. If you specify both label and property selectors in the same term, the results + are AND'd.""" + propertySelector: "PropertySelector" + """PropertySelector is a property query over all joined member clusters. Clusters matching the + query are selected. If you specify both label and property selectors in the same term, the + results are AND'd. At this moment, PropertySelector can only be used with + ``RequiredDuringSchedulingIgnoredDuringExecution`` affinity terms. This field is beta-level; it + is for the property-based scheduling feature and is only functional when a property provider is + enabled in the deployment.""" + + +class ErrorAdditionalInfo(TypedDict, total=False): + """The resource management error additional info. + + :ivar type: The additional info type. + :vartype type: str + :ivar info: The additional info. + :vartype info: Any + """ + + type: str + """The additional info type.""" + info: Any + """The additional info.""" + + +class ErrorDetail(TypedDict, total=False): + """The error detail. + + :ivar code: The error code. + :vartype code: str + :ivar message: The error message. + :vartype message: str + :ivar target: The error target. + :vartype target: str + :ivar details: The error details. + :vartype details: list["ErrorDetail"] + :ivar additionalInfo: The error additional info. + :vartype additionalInfo: list["ErrorAdditionalInfo"] + """ + + code: str + """The error code.""" + message: str + """The error message.""" + target: str + """The error target.""" + details: list["ErrorDetail"] + """The error details.""" + additionalInfo: list["ErrorAdditionalInfo"] + """The error additional info.""" + + +class TrackedResource(Resource): + """Tracked Resource. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar systemData: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype systemData: "SystemData" + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + :ivar location: The geo-location where the resource lives. Required. + :vartype location: str + """ + + tags: dict[str, str] + """Resource tags.""" + location: Required[str] + """The geo-location where the resource lives. Required.""" + + +class Fleet(TrackedResource): + """The Fleet resource. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar systemData: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype systemData: "SystemData" + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + :ivar location: The geo-location where the resource lives. Required. + :vartype location: str + :ivar properties: The resource-specific properties for this resource. + :vartype properties: "FleetProperties" + :ivar eTag: If eTag is provided in the response body, it may also be provided as a header per + the normal etag convention. Entity tags are used for comparing two or more entities from the + same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match + (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. + :vartype eTag: str + :ivar identity: Managed identity. + :vartype identity: "ManagedServiceIdentity" + """ + + properties: "FleetProperties" + """The resource-specific properties for this resource.""" + eTag: str + """If eTag is provided in the response body, it may also be provided as a header per the normal + etag convention. Entity tags are used for comparing two or more entities from the same + requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section + 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.""" + identity: "ManagedServiceIdentity" + """Managed identity.""" + + +class FleetHubProfile(TypedDict, total=False): + """The FleetHubProfile configures the fleet hub. + + :ivar dnsPrefix: DNS prefix used to create the FQDN for the Fleet hub. + :vartype dnsPrefix: str + :ivar apiServerAccessProfile: The access profile for the Fleet hub API server. + :vartype apiServerAccessProfile: "APIServerAccessProfile" + :ivar agentProfile: The agent profile for the Fleet hub. + :vartype agentProfile: "AgentProfile" + :ivar fqdn: The FQDN of the Fleet hub. + :vartype fqdn: str + :ivar kubernetesVersion: The Kubernetes version of the Fleet hub. + :vartype kubernetesVersion: str + :ivar portalFqdn: The Azure Portal FQDN of the Fleet hub. + :vartype portalFqdn: str + """ + + dnsPrefix: str + """DNS prefix used to create the FQDN for the Fleet hub.""" + apiServerAccessProfile: "APIServerAccessProfile" + """The access profile for the Fleet hub API server.""" + agentProfile: "AgentProfile" + """The agent profile for the Fleet hub.""" + fqdn: str + """The FQDN of the Fleet hub.""" + kubernetesVersion: str + """The Kubernetes version of the Fleet hub.""" + portalFqdn: str + """The Azure Portal FQDN of the Fleet hub.""" + + +class FleetManagedNamespace(TrackedResource): + """A fleet managed namespace. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar systemData: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype systemData: "SystemData" + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + :ivar location: The geo-location where the resource lives. Required. + :vartype location: str + :ivar properties: The resource-specific properties for this resource. + :vartype properties: "FleetManagedNamespaceProperties" + :ivar eTag: If eTag is provided in the response body, it may also be provided as a header per + the normal etag convention. Entity tags are used for comparing two or more entities from the + same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match + (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. + :vartype eTag: str + """ + + properties: "FleetManagedNamespaceProperties" + """The resource-specific properties for this resource.""" + eTag: str + """If eTag is provided in the response body, it may also be provided as a header per the normal + etag convention. Entity tags are used for comparing two or more entities from the same + requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section + 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.""" + + +class FleetManagedNamespacePatch(TypedDict, total=False): + """The properties of a fleet managed namespace that can be patched. + + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + """ + + tags: dict[str, str] + """Resource tags.""" + + +class FleetManagedNamespaceProperties(TypedDict, total=False): + """The properties of a fleet managed namespace. + + :ivar provisioningState: The status of the last operation. Known values are: "Succeeded", + "Failed", "Canceled", "Creating", "Updating", and "Deleting". + :vartype provisioningState: Union[str, "FleetManagedNamespaceProvisioningState"] + :ivar managedNamespaceProperties: The namespace properties for the fleet managed namespace. + :vartype managedNamespaceProperties: "ManagedNamespaceProperties" + :ivar adoptionPolicy: Action if the managed namespace with the same name already exists. + Default is Never. Required. Known values are: "Never", "IfIdentical", and "Always". + :vartype adoptionPolicy: Union[str, "AdoptionPolicy"] + :ivar deletePolicy: Delete options of a fleet managed namespace. Default is Keep. Required. + Known values are: "Keep" and "Delete". + :vartype deletePolicy: Union[str, "DeletePolicy"] + :ivar propagationPolicy: The profile of the propagation to create the namespace. + :vartype propagationPolicy: "PropagationPolicy" + :ivar status: Status information of the last operation for fleet managed namespace. + :vartype status: "FleetManagedNamespaceStatus" + :ivar portalFqdn: The Azure Portal FQDN of the Fleet hub. + :vartype portalFqdn: str + """ + + provisioningState: Union[str, "FleetManagedNamespaceProvisioningState"] + """The status of the last operation. Known values are: \"Succeeded\", \"Failed\", \"Canceled\", + \"Creating\", \"Updating\", and \"Deleting\".""" + managedNamespaceProperties: "ManagedNamespaceProperties" + """The namespace properties for the fleet managed namespace.""" + adoptionPolicy: Required[Union[str, "AdoptionPolicy"]] + """Action if the managed namespace with the same name already exists. Default is Never. Required. + Known values are: \"Never\", \"IfIdentical\", and \"Always\".""" + deletePolicy: Required[Union[str, "DeletePolicy"]] + """Delete options of a fleet managed namespace. Default is Keep. Required. Known values are: + \"Keep\" and \"Delete\".""" + propagationPolicy: "PropagationPolicy" + """The profile of the propagation to create the namespace.""" + status: "FleetManagedNamespaceStatus" + """Status information of the last operation for fleet managed namespace.""" + portalFqdn: str + """The Azure Portal FQDN of the Fleet hub.""" + + +class FleetManagedNamespaceStatus(TypedDict, total=False): + """Status information for the fleet managed namespace. + + :ivar lastOperationId: The last operation ID for the fleet managed namespace. + :vartype lastOperationId: str + :ivar lastOperationError: The last operation error of the fleet managed namespace. + :vartype lastOperationError: "ErrorDetail" + """ + + lastOperationId: str + """The last operation ID for the fleet managed namespace.""" + lastOperationError: "ErrorDetail" + """The last operation error of the fleet managed namespace.""" + + +class FleetMember(ProxyResource): + """A member of the Fleet. It contains a reference to an existing Kubernetes cluster on Azure. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar systemData: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype systemData: "SystemData" + :ivar properties: The resource-specific properties for this resource. + :vartype properties: "FleetMemberProperties" + :ivar eTag: If eTag is provided in the response body, it may also be provided as a header per + the normal etag convention. Entity tags are used for comparing two or more entities from the + same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match + (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. + :vartype eTag: str + """ + + properties: "FleetMemberProperties" + """The resource-specific properties for this resource.""" + eTag: str + """If eTag is provided in the response body, it may also be provided as a header per the normal + etag convention. Entity tags are used for comparing two or more entities from the same + requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section + 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.""" + + +class FleetMemberProperties(TypedDict, total=False): + """A member of the Fleet. It contains a reference to an existing Kubernetes cluster on Azure. + + :ivar clusterResourceId: The ARM resource id of the cluster that joins the Fleet. Must be a + valid Azure resource id. e.g.: + '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{clusterName}'. + Required. + :vartype clusterResourceId: str + :ivar group: The group this member belongs to for multi-cluster update management. + :vartype group: str + :ivar provisioningState: The status of the last operation. Known values are: "Succeeded", + "Failed", "Canceled", "Joining", "Leaving", and "Updating". + :vartype provisioningState: Union[str, "FleetMemberProvisioningState"] + :ivar labels: The labels for the fleet member. + :vartype labels: dict[str, str] + :ivar status: Status information of the last operation for fleet member. + :vartype status: "FleetMemberStatus" + """ + + clusterResourceId: Required[str] + """The ARM resource id of the cluster that joins the Fleet. Must be a valid Azure resource id. + e.g.: + '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{clusterName}'. + Required.""" + group: str + """The group this member belongs to for multi-cluster update management.""" + provisioningState: Union[str, "FleetMemberProvisioningState"] + """The status of the last operation. Known values are: \"Succeeded\", \"Failed\", \"Canceled\", + \"Joining\", \"Leaving\", and \"Updating\".""" + labels: dict[str, str] + """The labels for the fleet member.""" + status: "FleetMemberStatus" + """Status information of the last operation for fleet member.""" + + +class FleetMemberStatus(TypedDict, total=False): + """Status information for the fleet member. + + :ivar lastOperationId: The last operation ID for the fleet member. + :vartype lastOperationId: str + :ivar lastOperationError: The last operation error of the fleet member. + :vartype lastOperationError: "ErrorDetail" + """ + + lastOperationId: str + """The last operation ID for the fleet member.""" + lastOperationError: "ErrorDetail" + """The last operation error of the fleet member.""" + + +class FleetMemberUpdate(TypedDict, total=False): + """The type used for update operations of the FleetMember. + + :ivar properties: The resource-specific properties for this resource. + :vartype properties: "FleetMemberUpdateProperties" + """ + + properties: "FleetMemberUpdateProperties" + """The resource-specific properties for this resource.""" + + +class FleetMemberUpdateProperties(TypedDict, total=False): + """The updatable properties of the FleetMember. + + :ivar group: The group this member belongs to for multi-cluster update management. + :vartype group: str + :ivar labels: The labels for the fleet member. + :vartype labels: dict[str, str] + """ + + group: str + """The group this member belongs to for multi-cluster update management.""" + labels: dict[str, str] + """The labels for the fleet member.""" + + +class FleetPatch(TypedDict, total=False): + """Properties of a Fleet that can be patched. + + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + :ivar identity: Managed identity. + :vartype identity: "ManagedServiceIdentity" + """ + + tags: dict[str, str] + """Resource tags.""" + identity: "ManagedServiceIdentity" + """Managed identity.""" + + +class FleetProperties(TypedDict, total=False): + """Fleet properties. + + :ivar provisioningState: The status of the last operation. Known values are: "Succeeded", + "Failed", "Canceled", "Creating", "Updating", and "Deleting". + :vartype provisioningState: Union[str, "FleetProvisioningState"] + :ivar hubProfile: The FleetHubProfile configures the Fleet's hub. + :vartype hubProfile: "FleetHubProfile" + :ivar status: Status information for the fleet. + :vartype status: "FleetStatus" + """ + + provisioningState: Union[str, "FleetProvisioningState"] + """The status of the last operation. Known values are: \"Succeeded\", \"Failed\", \"Canceled\", + \"Creating\", \"Updating\", and \"Deleting\".""" + hubProfile: "FleetHubProfile" + """The FleetHubProfile configures the Fleet's hub.""" + status: "FleetStatus" + """Status information for the fleet.""" + + +class FleetStatus(TypedDict, total=False): + """Status information for the fleet. + + :ivar lastOperationId: The last operation ID for the fleet. + :vartype lastOperationId: str + :ivar lastOperationError: The last operation error for the fleet. + :vartype lastOperationError: "ErrorDetail" + """ + + lastOperationId: str + """The last operation ID for the fleet.""" + lastOperationError: "ErrorDetail" + """The last operation error for the fleet.""" + + +class FleetUpdateStrategy(ProxyResource): + """Defines a multi-stage process to perform update operations across members of a Fleet. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar systemData: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype systemData: "SystemData" + :ivar properties: The resource-specific properties for this resource. + :vartype properties: "FleetUpdateStrategyProperties" + :ivar eTag: If eTag is provided in the response body, it may also be provided as a header per + the normal etag convention. Entity tags are used for comparing two or more entities from the + same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match + (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. + :vartype eTag: str + """ + + properties: "FleetUpdateStrategyProperties" + """The resource-specific properties for this resource.""" + eTag: str + """If eTag is provided in the response body, it may also be provided as a header per the normal + etag convention. Entity tags are used for comparing two or more entities from the same + requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section + 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.""" + + +class FleetUpdateStrategyProperties(TypedDict, total=False): + """The properties of the UpdateStrategy. + + :ivar provisioningState: The provisioning state of the UpdateStrategy resource. Known values + are: "Succeeded", "Failed", and "Canceled". + :vartype provisioningState: Union[str, "FleetUpdateStrategyProvisioningState"] + :ivar strategy: Defines the update sequence of the clusters. Required. + :vartype strategy: "UpdateRunStrategy" + """ + + provisioningState: Union[str, "FleetUpdateStrategyProvisioningState"] + """The provisioning state of the UpdateStrategy resource. Known values are: \"Succeeded\", + \"Failed\", and \"Canceled\".""" + strategy: Required["UpdateRunStrategy"] + """Defines the update sequence of the clusters. Required.""" + + +class GateConfiguration(TypedDict, total=False): + """GateConfiguration is used to define where Gates should be placed within the Update Run. + + :ivar displayName: The human-readable display name of the Gate. + :vartype displayName: str + :ivar type: The type of the Gate determines how it is completed. Required. "Approval" + :vartype type: Union[str, "GateType"] + """ + + displayName: str + """The human-readable display name of the Gate.""" + type: Required[Union[str, "GateType"]] + """The type of the Gate determines how it is completed. Required. \"Approval\"""" + + +class GatePatch(TypedDict, total=False): + """Patch a Gate resource. + + :ivar properties: Properties of a Gate that can be patched. Required. + :vartype properties: "GatePatchProperties" + """ + + properties: Required["GatePatchProperties"] + """Properties of a Gate that can be patched. Required.""" + + +class GatePatchProperties(TypedDict, total=False): + """Properties of a Gate that can be patched. + + :ivar state: The state of the Gate. Required. Known values are: "Pending", "Skipped", and + "Completed". + :vartype state: Union[str, "GateState"] + """ + + state: Required[Union[str, "GateState"]] + """The state of the Gate. Required. Known values are: \"Pending\", \"Skipped\", and \"Completed\".""" + + +class LabelSelector(TypedDict, total=False): + """A label selector is a label query over a set of resources. The result of matchLabels and + matchExpressions are ANDed. An empty label selector matches all objects. A null label selector + matches no objects. + + :ivar matchLabels: matchLabels is a map of {key,value} pairs. A single {key,value} in the + matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the + operator is "In", and the values array contains only "value". The requirements are ANDed. + :vartype matchLabels: dict[str, str] + :ivar matchExpressions: matchExpressions is a list of label selector requirements. The + requirements are ANDed. + :vartype matchExpressions: list["LabelSelectorRequirement"] + """ + + matchLabels: dict[str, str] + """matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is + equivalent to an element of matchExpressions, whose key field is \"key\", the operator is + \"In\", and the values array contains only \"value\". The requirements are ANDed.""" + matchExpressions: list["LabelSelectorRequirement"] + """matchExpressions is a list of label selector requirements. The requirements are ANDed.""" + + +class LabelSelectorRequirement(TypedDict, total=False): + """A label selector requirement is a selector that contains values, a key, and an operator that + relates the key and values. + + :ivar key: key is the label key that the selector applies to. Required. + :vartype key: str + :ivar operator: operator represents a key's relationship to a set of values. Valid operators + are In, NotIn, Exists and DoesNotExist. Required. Known values are: "In", "NotIn", "Exists", + and "DoesNotExist". + :vartype operator: Union[str, "LabelSelectorOperator"] + :ivar values: values is an array of string values. If the operator is In or NotIn, the values + array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be + empty. This array is replaced during a strategic merge patch. + :vartype values: list[str] + """ + + key: Required[str] + """key is the label key that the selector applies to. Required.""" + operator: Required[Union[str, "LabelSelectorOperator"]] + """operator represents a key's relationship to a set of values. Valid operators are In, NotIn, + Exists and DoesNotExist. Required. Known values are: \"In\", \"NotIn\", \"Exists\", and + \"DoesNotExist\".""" + values: list[str] + """values is an array of string values. If the operator is In or NotIn, the values array must be + non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This + array is replaced during a strategic merge patch.""" + + +class ManagedClusterUpdate(TypedDict, total=False): + """The update to be applied to the ManagedClusters. + + :ivar upgrade: The upgrade to apply to the ManagedClusters. Required. + :vartype upgrade: "ManagedClusterUpgradeSpec" + :ivar nodeImageSelection: The node image upgrade to be applied to the target nodes in update + run. + :vartype nodeImageSelection: "NodeImageSelection" + """ + + upgrade: Required["ManagedClusterUpgradeSpec"] + """The upgrade to apply to the ManagedClusters. Required.""" + nodeImageSelection: "NodeImageSelection" + """The node image upgrade to be applied to the target nodes in update run.""" + + +class ManagedClusterUpgradeSpec(TypedDict, total=False): + """The upgrade to apply to a ManagedCluster. + + :ivar type: ManagedClusterUpgradeType is the type of upgrade to be applied. Required. Known + values are: "Full", "NodeImageOnly", and "ControlPlaneOnly". + :vartype type: Union[str, "ManagedClusterUpgradeType"] + :ivar kubernetesVersion: The Kubernetes version to upgrade the member clusters to. + :vartype kubernetesVersion: str + """ + + type: Required[Union[str, "ManagedClusterUpgradeType"]] + """ManagedClusterUpgradeType is the type of upgrade to be applied. Required. Known values are: + \"Full\", \"NodeImageOnly\", and \"ControlPlaneOnly\".""" + kubernetesVersion: str + """The Kubernetes version to upgrade the member clusters to.""" + + +class ManagedNamespaceProperties(TypedDict, total=False): + """The namespace properties for the fleet managed namespace. + + :ivar labels: The labels for the fleet managed namespace. + :vartype labels: dict[str, str] + :ivar annotations: The annotations for the fleet managed namespace. + :vartype annotations: dict[str, str] + :ivar defaultResourceQuota: The default resource quota for the fleet managed namespace. + :vartype defaultResourceQuota: "ResourceQuota" + :ivar defaultNetworkPolicy: The default network policy for the fleet managed namespace. + :vartype defaultNetworkPolicy: "NetworkPolicy" + """ + + labels: dict[str, str] + """The labels for the fleet managed namespace.""" + annotations: dict[str, str] + """The annotations for the fleet managed namespace.""" + defaultResourceQuota: "ResourceQuota" + """The default resource quota for the fleet managed namespace.""" + defaultNetworkPolicy: "NetworkPolicy" + """The default network policy for the fleet managed namespace.""" + + +class ManagedServiceIdentity(TypedDict, total=False): + """Managed service identity (system assigned and/or user assigned identities). + + :ivar principalId: The service principal ID of the system assigned identity. This property will + only be provided for a system assigned identity. + :vartype principalId: str + :ivar tenantId: The tenant ID of the system assigned identity. This property will only be + provided for a system assigned identity. + :vartype tenantId: str + :ivar type: The type of managed identity assigned to this resource. Required. Known values are: + "None", "SystemAssigned", "UserAssigned", and "SystemAssigned, UserAssigned". + :vartype type: Union[str, "ManagedServiceIdentityType"] + :ivar userAssignedIdentities: The identities assigned to this resource by the user. + :vartype userAssignedIdentities: dict[str, "UserAssignedIdentity"] + """ + + principalId: str + """The service principal ID of the system assigned identity. This property will only be provided + for a system assigned identity.""" + tenantId: str + """The tenant ID of the system assigned identity. This property will only be provided for a system + assigned identity.""" + type: Required[Union[str, "ManagedServiceIdentityType"]] + """The type of managed identity assigned to this resource. Required. Known values are: \"None\", + \"SystemAssigned\", \"UserAssigned\", and \"SystemAssigned, UserAssigned\".""" + userAssignedIdentities: dict[str, "UserAssignedIdentity"] + """The identities assigned to this resource by the user.""" + + +class MemberUpdateStatus(TypedDict, total=False): + """The status of a member update operation. + + :ivar status: The status of the MemberUpdate operation. + :vartype status: "UpdateStatus" + :ivar name: The name of the FleetMember. + :vartype name: str + :ivar clusterResourceId: The Azure resource id of the target Kubernetes cluster. + :vartype clusterResourceId: str + :ivar operationId: The operation resource id of the latest attempt to perform the operation. + :vartype operationId: str + :ivar message: The status message after processing the member update operation. + :vartype message: str + """ + + status: "UpdateStatus" + """The status of the MemberUpdate operation.""" + name: str + """The name of the FleetMember.""" + clusterResourceId: str + """The Azure resource id of the target Kubernetes cluster.""" + operationId: str + """The operation resource id of the latest attempt to perform the operation.""" + message: str + """The status message after processing the member update operation.""" + + +class NetworkPolicy(TypedDict, total=False): + """The network policy for the managed namespace. + + :ivar ingress: The ingress policy for the managed namespace. Known values are: "AllowAll", + "DenyAll", and "AllowSameNamespace". + :vartype ingress: Union[str, "PolicyRule"] + :ivar egress: The egress policy for the managed namespace. Known values are: "AllowAll", + "DenyAll", and "AllowSameNamespace". + :vartype egress: Union[str, "PolicyRule"] + """ + + ingress: Union[str, "PolicyRule"] + """The ingress policy for the managed namespace. Known values are: \"AllowAll\", \"DenyAll\", and + \"AllowSameNamespace\".""" + egress: Union[str, "PolicyRule"] + """The egress policy for the managed namespace. Known values are: \"AllowAll\", \"DenyAll\", and + \"AllowSameNamespace\".""" + + +class NodeImageSelection(TypedDict, total=False): + """The node image upgrade to be applied to the target nodes in update run. + + :ivar type: The node image upgrade type. Required. Known values are: "Latest", "Consistent", + and "Custom". + :vartype type: Union[str, "NodeImageSelectionType"] + :ivar customNodeImageVersions: Custom node image versions to upgrade the nodes to. This field + is required if node image selection type is Custom. Otherwise, it must be empty. For each node + image family (e.g., 'AKSUbuntu-1804gen2containerd'), this field can contain at most one version + (e.g., only one of 'AKSUbuntu-1804gen2containerd-2023.01.12' or + 'AKSUbuntu-1804gen2containerd-2023.02.12', not both). If the nodes belong to a family without a + matching image version in this field, they are not upgraded. + :vartype customNodeImageVersions: list["NodeImageVersion"] + """ + + type: Required[Union[str, "NodeImageSelectionType"]] + """The node image upgrade type. Required. Known values are: \"Latest\", \"Consistent\", and + \"Custom\".""" + customNodeImageVersions: list["NodeImageVersion"] + """Custom node image versions to upgrade the nodes to. This field is required if node image + selection type is Custom. Otherwise, it must be empty. For each node image family (e.g., + 'AKSUbuntu-1804gen2containerd'), this field can contain at most one version (e.g., only one of + 'AKSUbuntu-1804gen2containerd-2023.01.12' or 'AKSUbuntu-1804gen2containerd-2023.02.12', not + both). If the nodes belong to a family without a matching image version in this field, they are + not upgraded.""" + + +class NodeImageSelectionStatus(TypedDict, total=False): + """The node image upgrade specs for the update run. + + :ivar selectedNodeImageVersions: The image versions to upgrade the nodes to. + :vartype selectedNodeImageVersions: list["NodeImageVersion"] + """ + + selectedNodeImageVersions: list["NodeImageVersion"] + """The image versions to upgrade the nodes to.""" + + +class NodeImageVersion(TypedDict, total=False): + """The node upgrade image version. + + :ivar version: The image version to upgrade the nodes to (e.g., + 'AKSUbuntu-1804gen2containerd-2022.12.13'). + :vartype version: str + """ + + version: str + """The image version to upgrade the nodes to (e.g., 'AKSUbuntu-1804gen2containerd-2022.12.13').""" + + +class PlacementPolicy(TypedDict, total=False): + """PlacementPolicy contains the rules to select target member clusters to place the selected + resources. Note that only clusters that are both joined and satisfying the rules will be + selected. You can only specify at most one of the two fields: ClusterNames and Affinity. If + none is specified, all the joined clusters are selected. + + :ivar placementType: Type of placement. Can be "PickAll", "PickN" or "PickFixed". Default is + PickAll. Known values are: "PickAll" and "PickFixed". + :vartype placementType: Union[str, "PlacementType"] + :ivar clusterNames: ClusterNames contains a list of names of MemberCluster to place the + selected resources. Only valid if the placement type is "PickFixed". + :vartype clusterNames: list[str] + :ivar affinity: Affinity contains cluster affinity scheduling rules. Defines which member + clusters to place the selected resources. Only valid if the placement type is "PickAll" or + "PickN". + :vartype affinity: "Affinity" + :ivar tolerations: If specified, the ClusterResourcePlacement's Tolerations. Tolerations cannot + be updated or deleted. This field is beta-level and is for the taints and tolerations feature. + :vartype tolerations: list["Toleration"] + """ + + placementType: Union[str, "PlacementType"] + """Type of placement. Can be \"PickAll\", \"PickN\" or \"PickFixed\". Default is PickAll. Known + values are: \"PickAll\" and \"PickFixed\".""" + clusterNames: list[str] + """ClusterNames contains a list of names of MemberCluster to place the selected resources. Only + valid if the placement type is \"PickFixed\".""" + affinity: "Affinity" + """Affinity contains cluster affinity scheduling rules. Defines which member clusters to place the + selected resources. Only valid if the placement type is \"PickAll\" or \"PickN\".""" + tolerations: list["Toleration"] + """If specified, the ClusterResourcePlacement's Tolerations. Tolerations cannot be updated or + deleted. This field is beta-level and is for the taints and tolerations feature.""" + + +class PlacementProfile(TypedDict, total=False): + """The configuration profile for default ClusterResourcePlacement for placement. + + :ivar defaultClusterResourcePlacement: The default ClusterResourcePlacement policy + configuration. + :vartype defaultClusterResourcePlacement: "ClusterResourcePlacementSpec" + """ + + defaultClusterResourcePlacement: "ClusterResourcePlacementSpec" + """The default ClusterResourcePlacement policy configuration.""" + + +class PropagationPolicy(TypedDict, total=False): + """The propagation to be used for provisioning the namespace among the fleet. + + :ivar type: The type of the policy to be used. Default is Placement. Required. "Placement" + :vartype type: Union[str, "PropagationType"] + :ivar placementProfile: The profile to be used for propagation via placement. + :vartype placementProfile: "PlacementProfile" + """ + + type: Required[Union[str, "PropagationType"]] + """The type of the policy to be used. Default is Placement. Required. \"Placement\"""" + placementProfile: "PlacementProfile" + """The profile to be used for propagation via placement.""" + + +class PropertySelector(TypedDict, total=False): + """PropertySelector helps user specify property requirements when picking clusters for resource + placement. + + :ivar matchExpressions: MatchExpressions is an array of PropertySelectorRequirements. The + requirements are AND'd. Required. + :vartype matchExpressions: list["PropertySelectorRequirement"] + """ + + matchExpressions: Required[list["PropertySelectorRequirement"]] + """MatchExpressions is an array of PropertySelectorRequirements. The requirements are AND'd. + Required.""" + + +class PropertySelectorRequirement(TypedDict, total=False): + """PropertySelectorRequirement is a specific property requirement when picking clusters for + resource placement. + + :ivar name: Name is the name of the property; it should be a Kubernetes label name. Required. + :vartype name: str + :ivar operator: Operator specifies the relationship between a cluster's observed value of the + specified property and the values given in the requirement. Required. Known values are: "Gt", + "Ge", "Eq", "Ne", "Lt", and "Le". + :vartype operator: Union[str, "PropertySelectorOperator"] + :ivar values: Values are a list of values of the specified property which Fleet will compare + against the observed values of individual member clusters in accordance with the given + operator. At this moment, each value should be a Kubernetes quantity. For more information, see + `https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity + `_. If the operator is Gt + (greater than), Ge (greater than or equal to), Lt (less than), or ``Le`` (less than or equal + to), Eq (equal to), or Ne (ne), exactly one value must be specified in the list. Required. + :vartype values: list[str] + """ + + name: Required[str] + """Name is the name of the property; it should be a Kubernetes label name. Required.""" + operator: Required[Union[str, "PropertySelectorOperator"]] + """Operator specifies the relationship between a cluster's observed value of the specified + property and the values given in the requirement. Required. Known values are: \"Gt\", \"Ge\", + \"Eq\", \"Ne\", \"Lt\", and \"Le\".""" + values: Required[list[str]] + """Values are a list of values of the specified property which Fleet will compare against the + observed values of individual member clusters in accordance with the given operator. At this + moment, each value should be a Kubernetes quantity. For more information, see + `https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity + `_. If the operator is Gt + (greater than), Ge (greater than or equal to), Lt (less than), or ``Le`` (less than or equal + to), Eq (equal to), or Ne (ne), exactly one value must be specified in the list. Required.""" + + +class ResourceQuota(TypedDict, total=False): + """The resource quota for the managed namespace. + + :ivar cpuRequest: The CPU request for the managed namespace. See more at + `https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu + `_. + :vartype cpuRequest: str + :ivar cpuLimit: The CPU limit for the managed namespace. See more at + `https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu + `_. + :vartype cpuLimit: str + :ivar memoryRequest: The memory request for the managed namespace. See more at + `https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory + `_. + :vartype memoryRequest: str + :ivar memoryLimit: The memory limit for the managed namespace. See more at + `https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory + `_. + :vartype memoryLimit: str + """ + + cpuRequest: str + """The CPU request for the managed namespace. See more at + `https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu + `_.""" + cpuLimit: str + """The CPU limit for the managed namespace. See more at + `https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu + `_.""" + memoryRequest: str + """The memory request for the managed namespace. See more at + `https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory + `_.""" + memoryLimit: str + """The memory limit for the managed namespace. See more at + `https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory + `_.""" + + +class SkipProperties(TypedDict, total=False): + """The properties of a skip operation containing multiple skip requests. + + :ivar targets: The targets to skip. Required. + :vartype targets: list["SkipTarget"] + """ + + targets: Required[list["SkipTarget"]] + """The targets to skip. Required.""" + + +class SkipTarget(TypedDict, total=False): + """The definition of a single skip request. + + :ivar type: The skip target type. Required. Known values are: "Member", "Group", "Stage", and + "AfterStageWait". + :vartype type: Union[str, "TargetType"] + :ivar name: The skip target's name. To skip a member/group/stage, use the member/group/stage's + name; Tp skip an after stage wait, use the parent stage's name. Required. + :vartype name: str + """ + + type: Required[Union[str, "TargetType"]] + """The skip target type. Required. Known values are: \"Member\", \"Group\", \"Stage\", and + \"AfterStageWait\".""" + name: Required[str] + """The skip target's name. To skip a member/group/stage, use the member/group/stage's name; Tp + skip an after stage wait, use the parent stage's name. Required.""" + + +class SystemData(TypedDict, total=False): + """Metadata pertaining to creation and last modification of the resource. + + :ivar createdBy: The identity that created the resource. + :vartype createdBy: str + :ivar createdByType: The type of identity that created the resource. Known values are: "User", + "Application", "ManagedIdentity", and "Key". + :vartype createdByType: Union[str, "CreatedByType"] + :ivar createdAt: The timestamp of resource creation (UTC). + :vartype createdAt: str + :ivar lastModifiedBy: The identity that last modified the resource. + :vartype lastModifiedBy: str + :ivar lastModifiedByType: The type of identity that last modified the resource. Known values + are: "User", "Application", "ManagedIdentity", and "Key". + :vartype lastModifiedByType: Union[str, "CreatedByType"] + :ivar lastModifiedAt: The timestamp of resource last modification (UTC). + :vartype lastModifiedAt: str + """ + + createdBy: str + """The identity that created the resource.""" + createdByType: Union[str, "CreatedByType"] + """The type of identity that created the resource. Known values are: \"User\", \"Application\", + \"ManagedIdentity\", and \"Key\".""" + createdAt: str + """The timestamp of resource creation (UTC).""" + lastModifiedBy: str + """The identity that last modified the resource.""" + lastModifiedByType: Union[str, "CreatedByType"] + """The type of identity that last modified the resource. Known values are: \"User\", + \"Application\", \"ManagedIdentity\", and \"Key\".""" + lastModifiedAt: str + """The timestamp of resource last modification (UTC).""" + + +class Toleration(TypedDict, total=False): + """Toleration allows ClusterResourcePlacement to tolerate any taint that matches the triple + using the matching operator . + + :ivar key: Key is the taint key that the toleration applies to. Empty means match all taint + keys. If the key is empty, operator must be Exists; this combination means to match all values + and all keys. + :vartype key: str + :ivar operator: Operator represents a key's relationship to the value. Valid operators are + Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a + ClusterResourcePlacement can tolerate all taints of a particular category. Known values are: + "Exists" and "Equal". + :vartype operator: Union[str, "TolerationOperator"] + :ivar value: Value is the taint value the toleration matches to. If the operator is Exists, the + value should be empty, otherwise just a regular string. + :vartype value: str + :ivar effect: Effect indicates the taint effect to match. Empty means match all taint effects. + When specified, only allowed value is NoSchedule. "NoSchedule" + :vartype effect: Union[str, "TaintEffect"] + """ + + key: str + """Key is the taint key that the toleration applies to. Empty means match all taint keys. If the + key is empty, operator must be Exists; this combination means to match all values and all keys.""" + operator: Union[str, "TolerationOperator"] + """Operator represents a key's relationship to the value. Valid operators are Exists and Equal. + Defaults to Equal. Exists is equivalent to wildcard for value, so that a + ClusterResourcePlacement can tolerate all taints of a particular category. Known values are: + \"Exists\" and \"Equal\".""" + value: str + """Value is the taint value the toleration matches to. If the operator is Exists, the value should + be empty, otherwise just a regular string.""" + effect: Union[str, "TaintEffect"] + """Effect indicates the taint effect to match. Empty means match all taint effects. When + specified, only allowed value is NoSchedule. \"NoSchedule\"""" + + +class UpdateGroup(TypedDict, total=False): + """A group to be updated. + + :ivar name: Name of the group. It must match a group name of an existing fleet member. + Required. + :vartype name: str + :ivar maxConcurrency: The max number of upgrades that can run concurrently in this specific + group. Acts as a ceiling (and not a quota) for the number of concurrent upgrades within the + group you want to tolerate at a time. Actual concurrency may be lower depending on stage-level + concurrency limits or individual member conditions. Group maxConcurrency has a min value of + "1". The max value is min(number of clusters in the group, the stage maxConcurrency). If no + value is provided, defaults to 1. Accepts either: • A fixed count, e.g. "3" • A percentage, + e.g. "25%" (range 1–100). Percentage is of the number of clusters in the group. Fractional + results are rounded down. A minimum of 1 upgrade is enforced. Examples: • "3" --> up to 3 + members from this group upgrade at once. • "100%" --> “all at once”, up to all members for this + group upgrade at the same time. • "25%" --> up to 25% of the members in the group will be + upgraded at the same time. + :vartype maxConcurrency: str + :ivar beforeGates: A list of Gates that will be created before this Group is executed. + :vartype beforeGates: list["GateConfiguration"] + :ivar afterGates: A list of Gates that will be created after this Group is executed. + :vartype afterGates: list["GateConfiguration"] + """ + + name: Required[str] + """Name of the group. It must match a group name of an existing fleet member. Required.""" + maxConcurrency: str + """The max number of upgrades that can run concurrently in this specific group. Acts as a ceiling + (and not a quota) for the number of concurrent upgrades within the group you want to tolerate + at a time. Actual concurrency may be lower depending on stage-level concurrency limits or + individual member conditions. Group maxConcurrency has a min value of \"1\". The max value is + min(number of clusters in the group, the stage maxConcurrency). If no value is provided, + defaults to 1. Accepts either: • A fixed count, e.g. \"3\" • A percentage, e.g. \"25%\" (range + 1–100). Percentage is of the number of clusters in the group. Fractional results are rounded + down. A minimum of 1 upgrade is enforced. Examples: • \"3\" --> up to 3 members from this group + upgrade at once. • \"100%\" --> “all at once”, up to all members for this group upgrade at the + same time. • \"25%\" --> up to 25% of the members in the group will be upgraded at the same + time.""" + beforeGates: list["GateConfiguration"] + """A list of Gates that will be created before this Group is executed.""" + afterGates: list["GateConfiguration"] + """A list of Gates that will be created after this Group is executed.""" + + +class UpdateGroupStatus(TypedDict, total=False): + """The status of a UpdateGroup. + + :ivar status: The status of the UpdateGroup. + :vartype status: "UpdateStatus" + :ivar name: The name of the UpdateGroup. + :vartype name: str + :ivar maxConcurrency: The max number of upgrades that can run concurrently in this group, + resolved from the UpdateStrategy.UpdateGroup.maxConcurrency value. If no value was provided, + this value defaults to "1". + :vartype maxConcurrency: int + :ivar members: The list of member this UpdateGroup updates. + :vartype members: list["MemberUpdateStatus"] + :ivar beforeGates: The list of Gates that will run before this UpdateGroup. + :vartype beforeGates: list["UpdateRunGateStatus"] + :ivar afterGates: The list of Gates that will run after this UpdateGroup. + :vartype afterGates: list["UpdateRunGateStatus"] + """ + + status: "UpdateStatus" + """The status of the UpdateGroup.""" + name: str + """The name of the UpdateGroup.""" + maxConcurrency: int + """The max number of upgrades that can run concurrently in this group, resolved from the + UpdateStrategy.UpdateGroup.maxConcurrency value. If no value was provided, this value defaults + to \"1\".""" + members: list["MemberUpdateStatus"] + """The list of member this UpdateGroup updates.""" + beforeGates: list["UpdateRunGateStatus"] + """The list of Gates that will run before this UpdateGroup.""" + afterGates: list["UpdateRunGateStatus"] + """The list of Gates that will run after this UpdateGroup.""" + + +class UpdateRun(ProxyResource): + """A multi-stage process to perform update operations across members of a Fleet. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar systemData: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype systemData: "SystemData" + :ivar properties: The resource-specific properties for this resource. + :vartype properties: "UpdateRunProperties" + :ivar eTag: If eTag is provided in the response body, it may also be provided as a header per + the normal etag convention. Entity tags are used for comparing two or more entities from the + same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match + (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. + :vartype eTag: str + """ + + properties: "UpdateRunProperties" + """The resource-specific properties for this resource.""" + eTag: str + """If eTag is provided in the response body, it may also be provided as a header per the normal + etag convention. Entity tags are used for comparing two or more entities from the same + requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section + 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.""" + + +class UpdateRunGateStatus(TypedDict, total=False): + """The status of the Gate, as represented in the Update Run. + + :ivar displayName: The human-readable display name of the Gate. + :vartype displayName: str + :ivar gateId: The resource id of the Gate. + :vartype gateId: str + :ivar status: The status of the Gate. + :vartype status: "UpdateStatus" + """ + + displayName: str + """The human-readable display name of the Gate.""" + gateId: str + """The resource id of the Gate.""" + status: "UpdateStatus" + """The status of the Gate.""" + + +class UpdateRunProperties(TypedDict, total=False): + """The properties of the UpdateRun. + + :ivar provisioningState: The provisioning state of the UpdateRun resource. Known values are: + "Succeeded", "Failed", and "Canceled". + :vartype provisioningState: Union[str, "UpdateRunProvisioningState"] + :ivar updateStrategyId: The resource id of the FleetUpdateStrategy resource to reference. + + When creating a new run, there are three ways to define a strategy for the run: + + 1. Define a new strategy in place: Set the "strategy" field. + 2. Use an existing strategy: Set the "updateStrategyId" field. (since 2023-08-15-preview) + 3. Use the default strategy to update all the members one by one: Leave both "updateStrategyId" + and "strategy" unset. (since 2023-08-15-preview) + + Setting both "updateStrategyId" and "strategy" is invalid. + + UpdateRuns created by "updateStrategyId" snapshot the referenced UpdateStrategy at the time of + creation and store it in the "strategy" field. + Subsequent changes to the referenced FleetUpdateStrategy resource do not propagate. + UpdateRunStrategy changes can be made directly on the "strategy" field before launching the + UpdateRun. + :vartype updateStrategyId: str + :ivar strategy: The strategy defines the order in which the clusters will be updated. If not + set, all members will be updated sequentially. The UpdateRun status will show a single + UpdateStage and a single UpdateGroup targeting all members. The strategy of the UpdateRun can + be modified until the run is started. + :vartype strategy: "UpdateRunStrategy" + :ivar managedClusterUpdate: The update to be applied to all clusters in the UpdateRun. The + managedClusterUpdate can be modified until the run is started. Required. + :vartype managedClusterUpdate: "ManagedClusterUpdate" + :ivar status: The status of the UpdateRun. + :vartype status: "UpdateRunStatus" + :ivar autoUpgradeProfileId: AutoUpgradeProfileId is the id of an auto upgrade profile resource. + :vartype autoUpgradeProfileId: str + """ + + provisioningState: Union[str, "UpdateRunProvisioningState"] + """The provisioning state of the UpdateRun resource. Known values are: \"Succeeded\", \"Failed\", + and \"Canceled\".""" + updateStrategyId: str + """The resource id of the FleetUpdateStrategy resource to reference. + + When creating a new run, there are three ways to define a strategy for the run: + + 1. Define a new strategy in place: Set the \"strategy\" field. + 2. Use an existing strategy: Set the \"updateStrategyId\" field. (since 2023-08-15-preview) + 3. Use the default strategy to update all the members one by one: Leave both + \"updateStrategyId\" and \"strategy\" unset. (since 2023-08-15-preview) + + Setting both \"updateStrategyId\" and \"strategy\" is invalid. + + UpdateRuns created by \"updateStrategyId\" snapshot the referenced UpdateStrategy at the time + of creation and store it in the \"strategy\" field. + Subsequent changes to the referenced FleetUpdateStrategy resource do not propagate. + UpdateRunStrategy changes can be made directly on the \"strategy\" field before launching the + UpdateRun.""" + strategy: "UpdateRunStrategy" + """The strategy defines the order in which the clusters will be updated. If not set, all members + will be updated sequentially. The UpdateRun status will show a single UpdateStage and a single + UpdateGroup targeting all members. The strategy of the UpdateRun can be modified until the run + is started.""" + managedClusterUpdate: Required["ManagedClusterUpdate"] + """The update to be applied to all clusters in the UpdateRun. The managedClusterUpdate can be + modified until the run is started. Required.""" + status: "UpdateRunStatus" + """The status of the UpdateRun.""" + autoUpgradeProfileId: str + """AutoUpgradeProfileId is the id of an auto upgrade profile resource.""" + + +class UpdateRunStatus(TypedDict, total=False): + """The status of a UpdateRun. + + :ivar status: The status of the UpdateRun. + :vartype status: "UpdateStatus" + :ivar stages: The stages composing an update run. Stages are run sequentially withing an + UpdateRun. + :vartype stages: list["UpdateStageStatus"] + :ivar nodeImageSelection: The node image upgrade specs for the update run. It is only set in + update run when ``NodeImageSelection.type`` is ``Consistent``. + :vartype nodeImageSelection: "NodeImageSelectionStatus" + """ + + status: "UpdateStatus" + """The status of the UpdateRun.""" + stages: list["UpdateStageStatus"] + """The stages composing an update run. Stages are run sequentially withing an UpdateRun.""" + nodeImageSelection: "NodeImageSelectionStatus" + """The node image upgrade specs for the update run. It is only set in update run when + ``NodeImageSelection.type`` is ``Consistent``.""" + + +class UpdateRunStrategy(TypedDict, total=False): + """Defines the update sequence of the clusters via stages and groups. + + Stages within a run are executed sequentially one after another. + Groups within a stage are executed in parallel. + Member clusters within a group are updated sequentially one after another. + + A valid strategy contains no duplicate groups within or across stages. + + :ivar stages: The list of stages that compose this update run. Min size: 1. Required. + :vartype stages: list["UpdateStage"] + """ + + stages: Required[list["UpdateStage"]] + """The list of stages that compose this update run. Min size: 1. Required.""" + + +class UpdateStage(TypedDict, total=False): + """Defines a stage which contains the groups to update and the steps to take (e.g., wait for a + time period) before starting the next stage. + + :ivar name: The name of the stage. Must be unique within the UpdateRun. Required. + :vartype name: str + :ivar groups: Defines the groups to be executed in parallel in this stage. Duplicate groups are + not allowed. Min size: 1. + :vartype groups: list["UpdateGroup"] + :ivar afterStageWaitInSeconds: The time in seconds to wait at the end of this stage before + starting the next one. Defaults to 0 seconds if unspecified. + :vartype afterStageWaitInSeconds: int + :ivar maxConcurrency: The max number of upgrades that can run concurrently across all groups in + this stage. Acts as a ceiling (and not a quota) for the number of concurrent upgrades within + the stage you want to tolerate at a time. Actual concurrency may be lower depending on + group-level concurrency limits or individual member conditions. Stage maxConcurrency has a min + value of "1". Accepts either: • A fixed count, e.g., "3" • A percentage, e.g., "25%" (range + 1–100). Percentage is of the total number of clusters across all groups in the stage. + Fractional results are rounded down. A minimum of 1 upgrade is enforced. Examples: • "3" + --> up to 3 clusters from this stage upgrade at once (across all groups). • "100%" --> “all at + once”; up to all clusters in this stage upgrade at the same time. • "25%" --> up to 25% of + the stage’s total clusters upgrade at the same time. + :vartype maxConcurrency: str + :ivar beforeGates: A list of Gates that will be created before this Stage is executed. + :vartype beforeGates: list["GateConfiguration"] + :ivar afterGates: A list of Gates that will be created after this Stage is executed. + :vartype afterGates: list["GateConfiguration"] + """ + + name: Required[str] + """The name of the stage. Must be unique within the UpdateRun. Required.""" + groups: list["UpdateGroup"] + """Defines the groups to be executed in parallel in this stage. Duplicate groups are not allowed. + Min size: 1.""" + afterStageWaitInSeconds: int + """The time in seconds to wait at the end of this stage before starting the next one. Defaults to + 0 seconds if unspecified.""" + maxConcurrency: str + """The max number of upgrades that can run concurrently across all groups in this stage. Acts as a + ceiling (and not a quota) for the number of concurrent upgrades within the stage you want to + tolerate at a time. Actual concurrency may be lower depending on group-level concurrency limits + or individual member conditions. Stage maxConcurrency has a min value of \"1\". Accepts either: + • A fixed count, e.g., \"3\" • A percentage, e.g., \"25%\" (range 1–100). Percentage is of the + total number of clusters across all groups in the stage. Fractional results are rounded down. A + minimum of 1 upgrade is enforced. Examples: • \"3\" --> up to 3 clusters from this stage + upgrade at once (across all groups). • \"100%\" --> “all at once”; up to all clusters in this + stage upgrade at the same time. • \"25%\" --> up to 25% of the stage’s total clusters upgrade + at the same time.""" + beforeGates: list["GateConfiguration"] + """A list of Gates that will be created before this Stage is executed.""" + afterGates: list["GateConfiguration"] + """A list of Gates that will be created after this Stage is executed.""" + + +class UpdateStageStatus(TypedDict, total=False): + """The status of a UpdateStage. + + :ivar status: The status of the UpdateStage. + :vartype status: "UpdateStatus" + :ivar name: The name of the UpdateStage. + :vartype name: str + :ivar maxConcurrency: The max number of upgrades that can run concurrently across all groups in + this stage, resolved from the UpdateStrategy.UpdateStage.maxConcurrency value. + :vartype maxConcurrency: int + :ivar groups: The list of groups to be updated as part of this UpdateStage. + :vartype groups: list["UpdateGroupStatus"] + :ivar beforeGates: The list of Gates that will run before this UpdateStage. + :vartype beforeGates: list["UpdateRunGateStatus"] + :ivar afterGates: The list of Gates that will run after this UpdateStage. + :vartype afterGates: list["UpdateRunGateStatus"] + :ivar afterStageWaitStatus: The status of the wait period configured on the UpdateStage. + :vartype afterStageWaitStatus: "WaitStatus" + """ + + status: "UpdateStatus" + """The status of the UpdateStage.""" + name: str + """The name of the UpdateStage.""" + maxConcurrency: int + """The max number of upgrades that can run concurrently across all groups in this stage, resolved + from the UpdateStrategy.UpdateStage.maxConcurrency value.""" + groups: list["UpdateGroupStatus"] + """The list of groups to be updated as part of this UpdateStage.""" + beforeGates: list["UpdateRunGateStatus"] + """The list of Gates that will run before this UpdateStage.""" + afterGates: list["UpdateRunGateStatus"] + """The list of Gates that will run after this UpdateStage.""" + afterStageWaitStatus: "WaitStatus" + """The status of the wait period configured on the UpdateStage.""" + + +class UpdateStatus(TypedDict, total=False): + """The status for an operation or group of operations. + + :ivar startTime: The time the operation or group was started. + :vartype startTime: str + :ivar completedTime: The time the operation or group was completed. + :vartype completedTime: str + :ivar state: The State of the operation or group. Known values are: "NotStarted", "Running", + "Stopping", "Stopped", "Skipped", "Failed", "Pending", and "Completed". + :vartype state: Union[str, "UpdateState"] + :ivar error: The error details when a failure is encountered. + :vartype error: "ErrorDetail" + """ + + startTime: str + """The time the operation or group was started.""" + completedTime: str + """The time the operation or group was completed.""" + state: Union[str, "UpdateState"] + """The State of the operation or group. Known values are: \"NotStarted\", \"Running\", + \"Stopping\", \"Stopped\", \"Skipped\", \"Failed\", \"Pending\", and \"Completed\".""" + error: "ErrorDetail" + """The error details when a failure is encountered.""" + + +class UserAssignedIdentity(TypedDict, total=False): + """User assigned identity properties. + + :ivar principalId: The principal ID of the assigned identity. + :vartype principalId: str + :ivar clientId: The client ID of the assigned identity. + :vartype clientId: str + """ + + principalId: str + """The principal ID of the assigned identity.""" + clientId: str + """The client ID of the assigned identity.""" + + +class WaitStatus(TypedDict, total=False): + """The status of the wait duration. + + :ivar status: The status of the wait duration. + :vartype status: "UpdateStatus" + :ivar waitDurationInSeconds: The wait duration configured in seconds. + :vartype waitDurationInSeconds: int + """ + + status: "UpdateStatus" + """The status of the wait duration.""" + waitDurationInSeconds: int + """The wait duration configured in seconds.""" diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profile_operations_generate_update_run.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profile_operations_generate_update_run.py index bd0dfd5c8758..f0e6a2025f88 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profile_operations_generate_update_run.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profile_operations_generate_update_run.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/AutoUpgradeProfileOperations_GenerateUpdateRun.json +# x-ms-original-file: 2026-06-01/AutoUpgradeProfileOperations_GenerateUpdateRun.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_create_or_update.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_create_or_update.py index 7ff8e072a32d..08ba4370bd68 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_create_or_update.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_create_or_update.py @@ -47,6 +47,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/AutoUpgradeProfiles_CreateOrUpdate.json +# x-ms-original-file: 2026-06-01/AutoUpgradeProfiles_CreateOrUpdate.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_delete.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_delete.py index b8f2bc93c7ea..606a4bb4c84b 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_delete.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_delete.py @@ -37,6 +37,6 @@ def main(): ).result() -# x-ms-original-file: 2026-03-02-preview/AutoUpgradeProfiles_Delete.json +# x-ms-original-file: 2026-06-01/AutoUpgradeProfiles_Delete.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_get.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_get.py index 84ae1c1167d1..668f61ae8533 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_get.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_get.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/AutoUpgradeProfiles_Get.json +# x-ms-original-file: 2026-06-01/AutoUpgradeProfiles_Get.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_list_by_fleet.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_list_by_fleet.py index f830dd591e81..697664230953 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_list_by_fleet.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/auto_upgrade_profiles_list_by_fleet.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-02-preview/AutoUpgradeProfiles_ListByFleet.json +# x-ms-original-file: 2026-06-01/AutoUpgradeProfiles_ListByFleet.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_apply.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_apply.py deleted file mode 100644 index 73188e8b8981..000000000000 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_apply.py +++ /dev/null @@ -1,43 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from azure.identity import DefaultAzureCredential - -from azure.mgmt.containerservicefleet import ContainerServiceFleetMgmtClient - -""" -# PREREQUISITES - pip install azure-identity - pip install azure-mgmt-containerservicefleet -# USAGE - python cluster_mesh_profiles_apply.py - - Before run the sample, please set the values of the client ID, tenant ID and client secret - of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, - AZURE_CLIENT_SECRET. For more info about how to get the value, please see: - https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal -""" - - -def main(): - client = ContainerServiceFleetMgmtClient( - credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", - ) - - response = client.cluster_mesh_profiles.begin_apply( - resource_group_name="rgfleets", - fleet_name="fleet1", - cluster_mesh_profile_name="clustermeshprofile1", - ).result() - print(response) - - -# x-ms-original-file: 2026-03-02-preview/ClusterMeshProfiles_Apply.json -if __name__ == "__main__": - main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_create_or_update.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_create_or_update.py deleted file mode 100644 index 74b6311ef7bf..000000000000 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_create_or_update.py +++ /dev/null @@ -1,44 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from azure.identity import DefaultAzureCredential - -from azure.mgmt.containerservicefleet import ContainerServiceFleetMgmtClient - -""" -# PREREQUISITES - pip install azure-identity - pip install azure-mgmt-containerservicefleet -# USAGE - python cluster_mesh_profiles_create_or_update.py - - Before run the sample, please set the values of the client ID, tenant ID and client secret - of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, - AZURE_CLIENT_SECRET. For more info about how to get the value, please see: - https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal -""" - - -def main(): - client = ContainerServiceFleetMgmtClient( - credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", - ) - - response = client.cluster_mesh_profiles.begin_create_or_update( - resource_group_name="rgfleets", - fleet_name="fleet1", - cluster_mesh_profile_name="clustermeshprofile1", - resource={"properties": {"memberSelector": {"byLabel": "env=production"}}}, - ).result() - print(response) - - -# x-ms-original-file: 2026-03-02-preview/ClusterMeshProfiles_CreateOrUpdate.json -if __name__ == "__main__": - main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_delete.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_delete.py deleted file mode 100644 index e155f356d562..000000000000 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_delete.py +++ /dev/null @@ -1,42 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from azure.identity import DefaultAzureCredential - -from azure.mgmt.containerservicefleet import ContainerServiceFleetMgmtClient - -""" -# PREREQUISITES - pip install azure-identity - pip install azure-mgmt-containerservicefleet -# USAGE - python cluster_mesh_profiles_delete.py - - Before run the sample, please set the values of the client ID, tenant ID and client secret - of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, - AZURE_CLIENT_SECRET. For more info about how to get the value, please see: - https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal -""" - - -def main(): - client = ContainerServiceFleetMgmtClient( - credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", - ) - - client.cluster_mesh_profiles.begin_delete( - resource_group_name="rg1", - fleet_name="fleet1", - cluster_mesh_profile_name="clustermeshprofile1", - ).result() - - -# x-ms-original-file: 2026-03-02-preview/ClusterMeshProfiles_Delete.json -if __name__ == "__main__": - main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_get.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_get.py deleted file mode 100644 index 22dd173fc1bc..000000000000 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_get.py +++ /dev/null @@ -1,43 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from azure.identity import DefaultAzureCredential - -from azure.mgmt.containerservicefleet import ContainerServiceFleetMgmtClient - -""" -# PREREQUISITES - pip install azure-identity - pip install azure-mgmt-containerservicefleet -# USAGE - python cluster_mesh_profiles_get.py - - Before run the sample, please set the values of the client ID, tenant ID and client secret - of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, - AZURE_CLIENT_SECRET. For more info about how to get the value, please see: - https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal -""" - - -def main(): - client = ContainerServiceFleetMgmtClient( - credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", - ) - - response = client.cluster_mesh_profiles.get( - resource_group_name="rgfleets", - fleet_name="fleet1", - cluster_mesh_profile_name="clustermeshprofile1", - ) - print(response) - - -# x-ms-original-file: 2026-03-02-preview/ClusterMeshProfiles_Get.json -if __name__ == "__main__": - main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_list_by_fleet.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_list_by_fleet.py deleted file mode 100644 index 3119f774e7f8..000000000000 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/cluster_mesh_profiles_list_by_fleet.py +++ /dev/null @@ -1,43 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -from azure.identity import DefaultAzureCredential - -from azure.mgmt.containerservicefleet import ContainerServiceFleetMgmtClient - -""" -# PREREQUISITES - pip install azure-identity - pip install azure-mgmt-containerservicefleet -# USAGE - python cluster_mesh_profiles_list_by_fleet.py - - Before run the sample, please set the values of the client ID, tenant ID and client secret - of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, - AZURE_CLIENT_SECRET. For more info about how to get the value, please see: - https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal -""" - - -def main(): - client = ContainerServiceFleetMgmtClient( - credential=DefaultAzureCredential(), - subscription_id="SUBSCRIPTION_ID", - ) - - response = client.cluster_mesh_profiles.list_by_fleet( - resource_group_name="rgfleets", - fleet_name="fleet1", - ) - for item in response: - print(item) - - -# x-ms-original-file: 2026-03-02-preview/ClusterMeshProfiles_ListByFleet.json -if __name__ == "__main__": - main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_create_or_update.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_create_or_update.py index fbb136a9dfe0..9d9321e740f0 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_create_or_update.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_create_or_update.py @@ -100,6 +100,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/FleetManagedNamespaces_CreateOrUpdate.json +# x-ms-original-file: 2026-06-01/FleetManagedNamespaces_CreateOrUpdate.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_delete.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_delete.py index 033efb50ccf0..9923ac3d76a5 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_delete.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_delete.py @@ -37,6 +37,6 @@ def main(): ).result() -# x-ms-original-file: 2026-03-02-preview/FleetManagedNamespaces_Delete.json +# x-ms-original-file: 2026-06-01/FleetManagedNamespaces_Delete.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_get.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_get.py index 7ad411e6be48..5c103f45b2b9 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_get.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_get.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/FleetManagedNamespaces_Get.json +# x-ms-original-file: 2026-06-01/FleetManagedNamespaces_Get.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_list_by_fleet.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_list_by_fleet.py index d49d7329bad2..0496ae17527a 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_list_by_fleet.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_list_by_fleet.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-02-preview/FleetManagedNamespaces_ListByFleet.json +# x-ms-original-file: 2026-06-01/FleetManagedNamespaces_ListByFleet.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_update.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_update.py index cf3005c55ac5..115d110c6e3a 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_update.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_managed_namespaces_update.py @@ -39,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/FleetManagedNamespaces_Update.json +# x-ms-original-file: 2026-06-01/FleetManagedNamespaces_Update.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_create.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_create.py index f6b360d2965f..79b8ef194357 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_create.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_create.py @@ -44,6 +44,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/FleetMembers_Create.json +# x-ms-original-file: 2026-06-01/FleetMembers_Create.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_delete.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_delete.py index 64e8054e414a..837ebe7064ee 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_delete.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_delete.py @@ -37,6 +37,6 @@ def main(): ).result() -# x-ms-original-file: 2026-03-02-preview/FleetMembers_Delete.json +# x-ms-original-file: 2026-06-01/FleetMembers_Delete.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_get.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_get.py index b747078a0ff8..d55a5c698943 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_get.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_get.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/FleetMembers_Get.json +# x-ms-original-file: 2026-06-01/FleetMembers_Get.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_list_by_fleet.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_list_by_fleet.py index 866202e64dfc..71bd8c3dfff5 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_list_by_fleet.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_list_by_fleet.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-02-preview/FleetMembers_ListByFleet.json +# x-ms-original-file: 2026-06-01/FleetMembers_ListByFleet.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_update.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_update.py index 18d31d2cab36..8d3fa0984775 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_update.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleet_members_update.py @@ -39,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/FleetMembers_Update.json +# x-ms-original-file: 2026-06-01/FleetMembers_Update.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_create_or_update.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_create_or_update.py index 4c573670a96d..d71eadabc9a5 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_create_or_update.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_create_or_update.py @@ -57,6 +57,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/Fleets_CreateOrUpdate.json +# x-ms-original-file: 2026-06-01/Fleets_CreateOrUpdate.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_delete.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_delete.py index 785c3ec81184..435bbb92fcdf 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_delete.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_delete.py @@ -36,6 +36,6 @@ def main(): ).result() -# x-ms-original-file: 2026-03-02-preview/Fleets_Delete.json +# x-ms-original-file: 2026-06-01/Fleets_Delete.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_get.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_get.py index cbd80cde8006..02c1ef23e90b 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_get.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_get.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/Fleets_Get.json +# x-ms-original-file: 2026-06-01/Fleets_Get.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_list_by_resource_group.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_list_by_resource_group.py index 6d25fb99f2b3..5d363942586c 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_list_by_resource_group.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_list_by_resource_group.py @@ -37,6 +37,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-02-preview/Fleets_ListByResourceGroup.json +# x-ms-original-file: 2026-06-01/Fleets_ListByResourceGroup.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_list_by_sub.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_list_by_sub.py index d7ff395c17e2..0bbd89793a2f 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_list_by_sub.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_list_by_sub.py @@ -35,6 +35,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-02-preview/Fleets_ListBySub.json +# x-ms-original-file: 2026-06-01/Fleets_ListBySub.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_list_credentials_result.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_list_credentials_result.py index e13bdd554545..eaf4fd8ca245 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_list_credentials_result.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_list_credentials_result.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/Fleets_ListCredentialsResult.json +# x-ms-original-file: 2026-06-01/Fleets_ListCredentialsResult.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_patch_tags.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_patch_tags.py index ce6eb496dcf5..abff4ac3025f 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_patch_tags.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_patch_tags.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/Fleets_PatchTags.json +# x-ms-original-file: 2026-06-01/Fleets_PatchTags.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_update.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_update.py index 54ab1e9b9c76..34c840401223 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_update.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/fleets_update.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/Fleets_Update.json +# x-ms-original-file: 2026-06-01/Fleets_Update.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/gates_get.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/gates_get.py index 8d057336dba3..9b6c2efc6bdc 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/gates_get.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/gates_get.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/Gates_Get.json +# x-ms-original-file: 2026-06-01/Gates_Get.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/gates_list_by_fleet.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/gates_list_by_fleet.py index 6bc04d26f313..f49695e918d4 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/gates_list_by_fleet.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/gates_list_by_fleet.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-02-preview/Gates_ListByFleet.json +# x-ms-original-file: 2026-06-01/Gates_ListByFleet.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/gates_update.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/gates_update.py index 948c4740cf19..5e66c05ccf70 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/gates_update.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/gates_update.py @@ -39,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/Gates_Update.json +# x-ms-original-file: 2026-06-01/Gates_Update.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/operations_list.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/operations_list.py index 2b7ec77fb2f0..40c391b5f5f0 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/operations_list.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/operations_list.py @@ -35,6 +35,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-02-preview/Operations_List.json +# x-ms-original-file: 2026-06-01/Operations_List.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_create_or_update.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_create_or_update.py index 9acaa55af139..6d39fc720710 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_create_or_update.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_create_or_update.py @@ -67,6 +67,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/UpdateRuns_CreateOrUpdate.json +# x-ms-original-file: 2026-06-01/UpdateRuns_CreateOrUpdate.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_delete.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_delete.py index f1bfbf36a0a8..303fdce77b90 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_delete.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_delete.py @@ -37,6 +37,6 @@ def main(): ).result() -# x-ms-original-file: 2026-03-02-preview/UpdateRuns_Delete.json +# x-ms-original-file: 2026-06-01/UpdateRuns_Delete.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_get.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_get.py index 3d6083730a05..fb97fd37904f 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_get.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_get.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/UpdateRuns_Get.json +# x-ms-original-file: 2026-06-01/UpdateRuns_Get.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_list_by_fleet.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_list_by_fleet.py index 8286bc6a4b44..bb7c4a9579a9 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_list_by_fleet.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_list_by_fleet.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-02-preview/UpdateRuns_ListByFleet.json +# x-ms-original-file: 2026-06-01/UpdateRuns_ListByFleet.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_skip.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_skip.py index 95edb083da5c..32181cbd76c5 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_skip.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_skip.py @@ -39,6 +39,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/UpdateRuns_Skip.json +# x-ms-original-file: 2026-06-01/UpdateRuns_Skip.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_start.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_start.py index a6611c782388..9eaeddb040f4 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_start.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_start.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/UpdateRuns_Start.json +# x-ms-original-file: 2026-06-01/UpdateRuns_Start.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_stop.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_stop.py index dd0bf0bbc0aa..3d8c2d195920 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_stop.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_runs_stop.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/UpdateRuns_Stop.json +# x-ms-original-file: 2026-06-01/UpdateRuns_Stop.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_create_or_update.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_create_or_update.py index a3ac9a7863e9..d5ab391249e9 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_create_or_update.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_create_or_update.py @@ -61,6 +61,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/UpdateStrategies_CreateOrUpdate.json +# x-ms-original-file: 2026-06-01/UpdateStrategies_CreateOrUpdate.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_delete.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_delete.py index f3cec17fb9b1..ac601608761c 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_delete.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_delete.py @@ -37,6 +37,6 @@ def main(): ).result() -# x-ms-original-file: 2026-03-02-preview/UpdateStrategies_Delete.json +# x-ms-original-file: 2026-06-01/UpdateStrategies_Delete.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_get.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_get.py index 7651299b3d1c..23d087103a20 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_get.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_get.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-02-preview/UpdateStrategies_Get.json +# x-ms-original-file: 2026-06-01/UpdateStrategies_Get.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_list_by_fleet.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_list_by_fleet.py index b07d355f376c..2053abb1fdbe 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_list_by_fleet.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_samples/update_strategies_list_by_fleet.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-02-preview/UpdateStrategies_ListByFleet.json +# x-ms-original-file: 2026-06-01/UpdateStrategies_ListByFleet.json if __name__ == "__main__": main() diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_tests/test_container_service_fleet_mgmt_cluster_mesh_profiles_operations.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_tests/test_container_service_fleet_mgmt_cluster_mesh_profiles_operations.py deleted file mode 100644 index d3b1a45b10c5..000000000000 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_tests/test_container_service_fleet_mgmt_cluster_mesh_profiles_operations.py +++ /dev/null @@ -1,108 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import pytest -from azure.mgmt.containerservicefleet import ContainerServiceFleetMgmtClient - -from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer, recorded_by_proxy - -AZURE_LOCATION = "eastus" - - -@pytest.mark.skip("you may need to update the auto-generated test case before run it") -class TestContainerServiceFleetMgmtClusterMeshProfilesOperations(AzureMgmtRecordedTestCase): - def setup_method(self, method): - self.client = self.create_mgmt_client(ContainerServiceFleetMgmtClient) - - @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) - @recorded_by_proxy - def test_cluster_mesh_profiles_get(self, resource_group): - response = self.client.cluster_mesh_profiles.get( - resource_group_name=resource_group.name, - fleet_name="str", - cluster_mesh_profile_name="str", - ) - - # please add some check logic here by yourself - # ... - - @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) - @recorded_by_proxy - def test_cluster_mesh_profiles_begin_create_or_update(self, resource_group): - response = self.client.cluster_mesh_profiles.begin_create_or_update( - resource_group_name=resource_group.name, - fleet_name="str", - cluster_mesh_profile_name="str", - resource={ - "eTag": "str", - "id": "str", - "name": "str", - "properties": { - "memberSelector": {"byLabel": "str"}, - "provisioningState": "str", - "status": { - "state": "str", - "lastAppliedMemberSelector": {"byLabel": "str"}, - "lastOperationError": { - "additionalInfo": [{"info": {}, "type": "str"}], - "code": "str", - "details": [...], - "message": "str", - "target": "str", - }, - "lastOperationId": "str", - }, - }, - "systemData": { - "createdAt": "2020-02-20 00:00:00", - "createdBy": "str", - "createdByType": "str", - "lastModifiedAt": "2020-02-20 00:00:00", - "lastModifiedBy": "str", - "lastModifiedByType": "str", - }, - "type": "str", - }, - ).result() # call '.result()' to poll until service return final result - - # please add some check logic here by yourself - # ... - - @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) - @recorded_by_proxy - def test_cluster_mesh_profiles_begin_delete(self, resource_group): - response = self.client.cluster_mesh_profiles.begin_delete( - resource_group_name=resource_group.name, - fleet_name="str", - cluster_mesh_profile_name="str", - ).result() # call '.result()' to poll until service return final result - - # please add some check logic here by yourself - # ... - - @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) - @recorded_by_proxy - def test_cluster_mesh_profiles_list_by_fleet(self, resource_group): - response = self.client.cluster_mesh_profiles.list_by_fleet( - resource_group_name=resource_group.name, - fleet_name="str", - ) - result = [r for r in response] - # please add some check logic here by yourself - # ... - - @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) - @recorded_by_proxy - def test_cluster_mesh_profiles_begin_apply(self, resource_group): - response = self.client.cluster_mesh_profiles.begin_apply( - resource_group_name=resource_group.name, - fleet_name="str", - cluster_mesh_profile_name="str", - ).result() # call '.result()' to poll until service return final result - - # please add some check logic here by yourself - # ... diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_tests/test_container_service_fleet_mgmt_cluster_mesh_profiles_operations_async.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_tests/test_container_service_fleet_mgmt_cluster_mesh_profiles_operations_async.py deleted file mode 100644 index 941a9228de9e..000000000000 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_tests/test_container_service_fleet_mgmt_cluster_mesh_profiles_operations_async.py +++ /dev/null @@ -1,115 +0,0 @@ -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) Python Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -import pytest -from azure.mgmt.containerservicefleet.aio import ContainerServiceFleetMgmtClient - -from devtools_testutils import AzureMgmtRecordedTestCase, RandomNameResourceGroupPreparer -from devtools_testutils.aio import recorded_by_proxy_async - -AZURE_LOCATION = "eastus" - - -@pytest.mark.skip("you may need to update the auto-generated test case before run it") -class TestContainerServiceFleetMgmtClusterMeshProfilesOperationsAsync(AzureMgmtRecordedTestCase): - def setup_method(self, method): - self.client = self.create_mgmt_client(ContainerServiceFleetMgmtClient, is_async=True) - - @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) - @recorded_by_proxy_async - async def test_cluster_mesh_profiles_get(self, resource_group): - response = await self.client.cluster_mesh_profiles.get( - resource_group_name=resource_group.name, - fleet_name="str", - cluster_mesh_profile_name="str", - ) - - # please add some check logic here by yourself - # ... - - @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) - @recorded_by_proxy_async - async def test_cluster_mesh_profiles_begin_create_or_update(self, resource_group): - response = await ( - await self.client.cluster_mesh_profiles.begin_create_or_update( - resource_group_name=resource_group.name, - fleet_name="str", - cluster_mesh_profile_name="str", - resource={ - "eTag": "str", - "id": "str", - "name": "str", - "properties": { - "memberSelector": {"byLabel": "str"}, - "provisioningState": "str", - "status": { - "state": "str", - "lastAppliedMemberSelector": {"byLabel": "str"}, - "lastOperationError": { - "additionalInfo": [{"info": {}, "type": "str"}], - "code": "str", - "details": [...], - "message": "str", - "target": "str", - }, - "lastOperationId": "str", - }, - }, - "systemData": { - "createdAt": "2020-02-20 00:00:00", - "createdBy": "str", - "createdByType": "str", - "lastModifiedAt": "2020-02-20 00:00:00", - "lastModifiedBy": "str", - "lastModifiedByType": "str", - }, - "type": "str", - }, - ) - ).result() # call '.result()' to poll until service return final result - - # please add some check logic here by yourself - # ... - - @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) - @recorded_by_proxy_async - async def test_cluster_mesh_profiles_begin_delete(self, resource_group): - response = await ( - await self.client.cluster_mesh_profiles.begin_delete( - resource_group_name=resource_group.name, - fleet_name="str", - cluster_mesh_profile_name="str", - ) - ).result() # call '.result()' to poll until service return final result - - # please add some check logic here by yourself - # ... - - @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) - @recorded_by_proxy_async - async def test_cluster_mesh_profiles_list_by_fleet(self, resource_group): - response = self.client.cluster_mesh_profiles.list_by_fleet( - resource_group_name=resource_group.name, - fleet_name="str", - ) - result = [r async for r in response] - # please add some check logic here by yourself - # ... - - @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) - @recorded_by_proxy_async - async def test_cluster_mesh_profiles_begin_apply(self, resource_group): - response = await ( - await self.client.cluster_mesh_profiles.begin_apply( - resource_group_name=resource_group.name, - fleet_name="str", - cluster_mesh_profile_name="str", - ) - ).result() # call '.result()' to poll until service return final result - - # please add some check logic here by yourself - # ... diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_tests/test_container_service_fleet_mgmt_fleet_members_operations.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_tests/test_container_service_fleet_mgmt_fleet_members_operations.py index 83850b236867..91adc1237766 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_tests/test_container_service_fleet_mgmt_fleet_members_operations.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_tests/test_container_service_fleet_mgmt_fleet_members_operations.py @@ -45,22 +45,6 @@ def test_fleet_members_begin_create(self, resource_group): "clusterResourceId": "str", "group": "str", "labels": {"str": "str"}, - "meshProperties": { - "ciliumProperties": {"id": 0, "name": "str"}, - "clusterMeshProfileResourceId": "str", - "status": { - "state": "str", - "error": { - "additionalInfo": [{"info": {}, "type": "str"}], - "code": "str", - "details": [...], - "message": "str", - "target": "str", - }, - "lastOperationId": "str", - "lastUpdatedAt": "2020-02-20 00:00:00", - }, - }, "provisioningState": "str", "status": { "lastOperationError": { diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_tests/test_container_service_fleet_mgmt_fleet_members_operations_async.py b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_tests/test_container_service_fleet_mgmt_fleet_members_operations_async.py index 6213e4013b04..a1a5164d1e06 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/generated_tests/test_container_service_fleet_mgmt_fleet_members_operations_async.py +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/generated_tests/test_container_service_fleet_mgmt_fleet_members_operations_async.py @@ -47,22 +47,6 @@ async def test_fleet_members_begin_create(self, resource_group): "clusterResourceId": "str", "group": "str", "labels": {"str": "str"}, - "meshProperties": { - "ciliumProperties": {"id": 0, "name": "str"}, - "clusterMeshProfileResourceId": "str", - "status": { - "state": "str", - "error": { - "additionalInfo": [{"info": {}, "type": "str"}], - "code": "str", - "details": [...], - "message": "str", - "target": "str", - }, - "lastOperationId": "str", - "lastUpdatedAt": "2020-02-20 00:00:00", - }, - }, "provisioningState": "str", "status": { "lastOperationError": { diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/pyproject.toml b/sdk/containerservice/azure-mgmt-containerservicefleet/pyproject.toml index e43426827cb8..f8be8d9d3af0 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/pyproject.toml +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/pyproject.toml @@ -13,7 +13,7 @@ authors = [ description = "Microsoft Azure Containerservicefleet Management Client Library for Python" license = "MIT" classifiers = [ - "Development Status :: 4 - Beta", + "Development Status :: 5 - Production/Stable", "Programming Language :: Python", "Programming Language :: Python :: 3 :: Only", "Programming Language :: Python :: 3", @@ -21,6 +21,7 @@ classifiers = [ "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", ] requires-python = ">=3.10" keywords = [ @@ -78,7 +79,7 @@ package_name = "azure-mgmt-containerservicefleet" package_nspkg = "azure-mgmt-nspkg" package_pprint_name = "Containerservicefleet Management" package_doc_id = "" -is_stable = false +is_stable = true is_arm = true need_msrestazure = false need_azuremgmtcore = true diff --git a/sdk/containerservice/azure-mgmt-containerservicefleet/tsp-location.yaml b/sdk/containerservice/azure-mgmt-containerservicefleet/tsp-location.yaml index 6da9fdc3b3b9..6e6c38184a4d 100644 --- a/sdk/containerservice/azure-mgmt-containerservicefleet/tsp-location.yaml +++ b/sdk/containerservice/azure-mgmt-containerservicefleet/tsp-location.yaml @@ -1,4 +1,4 @@ directory: specification/containerservice/resource-manager/Microsoft.ContainerService/fleet -commit: cb62053a18882dd258d9922be9770702b7ef6ac9 +commit: 3fe4c3b986995e48ec87d3bc809fcdafe47d2aac repo: Azure/azure-rest-api-specs additionalDirectories: