diff --git a/sdk/network/azure-mgmt-frontdoor/CHANGELOG.md b/sdk/network/azure-mgmt-frontdoor/CHANGELOG.md index b05bf99e9ad9..0feed8dc1ca2 100644 --- a/sdk/network/azure-mgmt-frontdoor/CHANGELOG.md +++ b/sdk/network/azure-mgmt-frontdoor/CHANGELOG.md @@ -1,5 +1,52 @@ # Release History +## 2.0.0 (2026-06-24) + +### Features Added + + - Client `FrontDoorManagementClient` added parameter `cloud_setting` in method `__init__` + - Client `FrontDoorManagementClient` added method `send_request` + - Enum `ActionType` added member `CAPTCHA` + - Model `ManagedRuleDefinition` added property `default_sensitivity` + - Model `ManagedRuleOverride` added property `sensitivity` + - Enum `Operator` added member `SERVICE_TAG_MATCH` + - Model `PolicySettings` added property `captcha_expiration_in_minutes` + - Added model `BasicResource` + - Added model `BasicResourceWithSettableIDName` + - Added model `ResourcewithSettableName` + - Added enum `SensitivityType` + +### Breaking Changes + + - 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. + - For the method breakings, please refer to https://aka.ms/azsdk/python/migrate/operations for migration. + - Model `BackendPool` moved instance variable `backends`, `load_balancing_settings`, `health_probe_settings` and `resource_state` under property `properties` whose type is `BackendPoolProperties` + - Model `CustomHttpsConfiguration` moved instance variable `certificate_type` under property `front_door_certificate_source_parameters` whose type is `FrontDoorCertificateSourceParameters` + - Model `CustomHttpsConfiguration` moved instance variable `vault`, `secret_name` and `secret_version` under property `key_vault_certificate_source_parameters` whose type is `KeyVaultCertificateSourceParameters` + - Model `Experiment` moved instance variable `description`, `endpoint_a`, `endpoint_b`, `enabled_state`, `resource_state`, `status` and `script_file_uri` under property `properties` whose type is `ExperimentProperties` + - Model `ExperimentUpdateModel` moved instance variable `description` and `enabled_state` under property `properties` whose type is `ExperimentUpdateProperties` + - Model `FrontDoor` moved instance variable `friendly_name`, `routing_rules`, `load_balancing_settings`, `health_probe_settings`, `backend_pools`, `frontend_endpoints`, `backend_pools_settings`, `enabled_state`, `resource_state`, `provisioning_state`, `cname`, `frontdoor_id`, `rules_engines` and `extended_properties` under property `properties` whose type is `FrontDoorProperties` + - Model `FrontendEndpoint` moved instance variable `host_name`, `session_affinity_enabled_state`, `session_affinity_ttl_seconds`, `web_application_firewall_policy_link`, `resource_state`, `custom_https_provisioning_state`, `custom_https_provisioning_substate` and `custom_https_configuration` under property `properties` whose type is `FrontendEndpointProperties` + - Model `HealthProbeSettingsModel` moved instance variable `path`, `protocol`, `interval_in_seconds`, `health_probe_method`, `enabled_state` and `resource_state` under property `properties` whose type is `HealthProbeSettingsProperties` + - Model `LatencyScorecard` moved instance variable `id_properties_id`, `name_properties_name`, `description`, `endpoint_a`, `endpoint_b`, `start_date_time_utc`, `end_date_time_utc`, `country` and `latency_metrics` under property `properties` whose type is `LatencyScorecardProperties` + - Model `LoadBalancingSettingsModel` moved instance variable `sample_size`, `successful_samples_required`, `additional_latency_milliseconds` and `resource_state` under property `properties` whose type is `LoadBalancingSettingsProperties` + - Model `ManagedRuleSetDefinition` moved instance variable `provisioning_state`, `rule_set_id`, `rule_set_type`, `rule_set_version` and `rule_groups` under property `properties` whose type is `ManagedRuleSetDefinitionProperties` + - Model `PolicySettings` moved instance variable `state` and `scrubbing_rules` under property `log_scrubbing` whose type is `PolicySettingsLogScrubbing` + - Model `PreconfiguredEndpoint` moved instance variable `description`, `endpoint`, `endpoint_type` and `backend` under property `properties` whose type is `PreconfiguredEndpointProperties` + - Model `Profile` moved instance variable `resource_state` and `enabled_state` under property `properties` whose type is `ProfileProperties` + - Model `ProfileUpdateModel` moved instance variable `enabled_state` under property `properties` whose type is `ProfileUpdateProperties` + - Model `RoutingRule` moved instance variable `frontend_endpoints`, `accepted_protocols`, `patterns_to_match`, `enabled_state`, `route_configuration`, `rules_engine`, `web_application_firewall_policy_link` and `resource_state` under property `properties` whose type is `RoutingRuleProperties` + - Model `RulesEngine` moved instance variable `rules` and `resource_state` under property `properties` whose type is `RulesEngineProperties` + - Model `Timeseries` moved instance variable `endpoint`, `start_date_time_utc`, `end_date_time_utc`, `aggregation_interval`, `timeseries_type`, `country` and `timeseries_data` under property `properties` whose type is `TimeseriesProperties` + - Model `WebApplicationFirewallPolicy` moved instance variable `policy_settings`, `custom_rules`, `managed_rules`, `frontend_endpoint_links`, `routing_rule_links`, `security_policy_links`, `provisioning_state` and `resource_state` under property `properties` whose type is `WebApplicationFirewallPolicyProperties` + - Method `ReportsOperations.get_latency_scorecards` changed its parameter `aggregation_interval`/`end_date_time_utc`/`country` from `positional_or_keyword` to `keyword_only` + - Method `ReportsOperations.get_timeseries` changed its parameter `start_date_time_utc`/`end_date_time_utc`/`aggregation_interval`/`timeseries_type`/`endpoint`/`country` from `positional_or_keyword` to `keyword_only` + +### Other Changes + + - Deleted model `AzureAsyncOperationResult`/`BackendPoolListResult`/`Error`/`ErrorDetails`/`ExperimentList`/`FrontDoorListResult`/`FrontendEndpointsListResult`/`HealthProbeSettingsListResult`/`LoadBalancingSettingsListResult`/`ManagedRuleSetDefinitionList`/`PreconfiguredEndpointList`/`ProfileList`/`RoutingRuleListResult`/`RulesEngineListResult`/`WebApplicationFirewallPolicyList` which actually were not used by SDK users + - Deleted enum `NetworkOperationStatus` which actually were not used by SDK users + ## 2.0.0b1 (2026-03-24) ### Features Added diff --git a/sdk/network/azure-mgmt-frontdoor/README.md b/sdk/network/azure-mgmt-frontdoor/README.md index 6e1c5ed20243..3bfcdfcad351 100644 --- a/sdk/network/azure-mgmt-frontdoor/README.md +++ b/sdk/network/azure-mgmt-frontdoor/README.md @@ -1,7 +1,7 @@ # Microsoft Azure SDK for Python This is the Microsoft Azure Front Door Service Client Library. -This package has been tested with Python 3.9+. +This package has been tested with Python 3.10+. For a more complete view of Azure libraries, see the [azure sdk python release](https://aka.ms/azsdk/python/all). ## _Disclaimer_ @@ -12,7 +12,7 @@ _Azure SDK Python packages support for Python 2.7 has ended 01 January 2022. For ### Prerequisites -- Python 3.9+ is required to use this package. +- Python 3.10+ is required to use this package. - [Azure subscription](https://azure.microsoft.com/free/) ### Install the package @@ -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/network/azure-mgmt-frontdoor/_metadata.json b/sdk/network/azure-mgmt-frontdoor/_metadata.json index 13addc96a0f8..4e1a7639c10f 100644 --- a/sdk/network/azure-mgmt-frontdoor/_metadata.json +++ b/sdk/network/azure-mgmt-frontdoor/_metadata.json @@ -3,8 +3,9 @@ "apiVersions": { "Microsoft.Network": "2025-10-01" }, - "commit": "5809ccc0da6207fc5544876346664e5e4b8035b4", + "commit": "12be16fab6dbfd11c55daefb35c28548f34c3f5c", "repository_url": "https://github.com/Azure/azure-rest-api-specs", "typespec_src": "specification/frontdoor/resource-manager/Microsoft.Network/FrontDoor", - "emitterVersion": "0.61.0" + "emitterVersion": "0.63.2", + "httpClientPythonVersion": "^0.33.0" } \ No newline at end of file diff --git a/sdk/network/azure-mgmt-frontdoor/api.md b/sdk/network/azure-mgmt-frontdoor/api.md new file mode 100644 index 000000000000..c8bf35a6cf95 --- /dev/null +++ b/sdk/network/azure-mgmt-frontdoor/api.md @@ -0,0 +1,3706 @@ +```py +namespace azure.mgmt.frontdoor + + class azure.mgmt.frontdoor.FrontDoorManagementClient: implements ContextManager + endpoints: EndpointsOperations + experiments: ExperimentsOperations + front_door_name_availability: FrontDoorNameAvailabilityOperations + front_door_name_availability_with_subscription: FrontDoorNameAvailabilityWithSubscriptionOperations + front_doors: FrontDoorsOperations + frontend_endpoints: FrontendEndpointsOperations + managed_rule_sets: ManagedRuleSetsOperations + network_experiment_profiles: NetworkExperimentProfilesOperations + policies: PoliciesOperations + preconfigured_endpoints: PreconfiguredEndpointsOperations + reports: ReportsOperations + rules_engines: RulesEnginesOperations + + 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.frontdoor.aio + + class azure.mgmt.frontdoor.aio.FrontDoorManagementClient: implements AsyncContextManager + endpoints: EndpointsOperations + experiments: ExperimentsOperations + front_door_name_availability: FrontDoorNameAvailabilityOperations + front_door_name_availability_with_subscription: FrontDoorNameAvailabilityWithSubscriptionOperations + front_doors: FrontDoorsOperations + frontend_endpoints: FrontendEndpointsOperations + managed_rule_sets: ManagedRuleSetsOperations + network_experiment_profiles: NetworkExperimentProfilesOperations + policies: PoliciesOperations + preconfigured_endpoints: PreconfiguredEndpointsOperations + reports: ReportsOperations + rules_engines: RulesEnginesOperations + + 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.frontdoor.aio.operations + + class azure.mgmt.frontdoor.aio.operations.EndpointsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_purge_content( + self, + resource_group_name: str, + front_door_name: str, + content_file_paths: PurgeParameters, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @overload + async def begin_purge_content( + self, + resource_group_name: str, + front_door_name: str, + content_file_paths: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @overload + async def begin_purge_content( + self, + resource_group_name: str, + front_door_name: str, + content_file_paths: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + + class azure.mgmt.frontdoor.aio.operations.ExperimentsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + parameters: Experiment, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[Experiment]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[Experiment]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[Experiment]: ... + + @distributed_trace_async + async def begin_delete( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + parameters: ExperimentUpdateModel, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[Experiment]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[Experiment]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[Experiment]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + **kwargs: Any + ) -> Experiment: ... + + @distributed_trace + def list_by_profile( + self, + resource_group_name: str, + profile_name: str, + **kwargs: Any + ) -> AsyncItemPaged[Experiment]: ... + + + class azure.mgmt.frontdoor.aio.operations.FrontDoorNameAvailabilityOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def check( + self, + check_front_door_name_availability_input: CheckNameAvailabilityInput, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + @overload + async def check( + self, + check_front_door_name_availability_input: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + @overload + async def check( + self, + check_front_door_name_availability_input: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + + class azure.mgmt.frontdoor.aio.operations.FrontDoorNameAvailabilityWithSubscriptionOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def check( + self, + check_front_door_name_availability_input: CheckNameAvailabilityInput, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + @overload + async def check( + self, + check_front_door_name_availability_input: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + @overload + async def check( + self, + check_front_door_name_availability_input: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + + class azure.mgmt.frontdoor.aio.operations.FrontDoorsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + front_door_name: str, + front_door_parameters: FrontDoor, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[FrontDoor]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + front_door_name: str, + front_door_parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[FrontDoor]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + front_door_name: str, + front_door_parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[FrontDoor]: ... + + @distributed_trace_async + async def begin_delete( + self, + resource_group_name: str, + front_door_name: str, + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + front_door_name: str, + **kwargs: Any + ) -> FrontDoor: ... + + @distributed_trace + def list(self, **kwargs: Any) -> AsyncItemPaged[FrontDoor]: ... + + @distributed_trace + def list_by_resource_group( + self, + resource_group_name: str, + **kwargs: Any + ) -> AsyncItemPaged[FrontDoor]: ... + + @overload + async def validate_custom_domain( + self, + resource_group_name: str, + front_door_name: str, + custom_domain_properties: ValidateCustomDomainInput, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> ValidateCustomDomainOutput: ... + + @overload + async def validate_custom_domain( + self, + resource_group_name: str, + front_door_name: str, + custom_domain_properties: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> ValidateCustomDomainOutput: ... + + @overload + async def validate_custom_domain( + self, + resource_group_name: str, + front_door_name: str, + custom_domain_properties: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> ValidateCustomDomainOutput: ... + + + class azure.mgmt.frontdoor.aio.operations.FrontendEndpointsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace_async + async def begin_disable_https( + self, + resource_group_name: str, + front_door_name: str, + frontend_endpoint_name: str, + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @overload + async def begin_enable_https( + self, + resource_group_name: str, + front_door_name: str, + frontend_endpoint_name: str, + custom_https_configuration: CustomHttpsConfiguration, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @overload + async def begin_enable_https( + self, + resource_group_name: str, + front_door_name: str, + frontend_endpoint_name: str, + custom_https_configuration: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @overload + async def begin_enable_https( + self, + resource_group_name: str, + front_door_name: str, + frontend_endpoint_name: str, + custom_https_configuration: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + front_door_name: str, + frontend_endpoint_name: str, + **kwargs: Any + ) -> FrontendEndpoint: ... + + @distributed_trace + def list_by_front_door( + self, + resource_group_name: str, + front_door_name: str, + **kwargs: Any + ) -> AsyncItemPaged[FrontendEndpoint]: ... + + + class azure.mgmt.frontdoor.aio.operations.ManagedRuleSetsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list(self, **kwargs: Any) -> AsyncItemPaged[ManagedRuleSetDefinition]: ... + + + class azure.mgmt.frontdoor.aio.operations.NetworkExperimentProfilesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + profile_name: str, + resource_group_name: str, + parameters: Profile, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[Profile]: ... + + @overload + async def begin_create_or_update( + self, + profile_name: str, + resource_group_name: str, + parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[Profile]: ... + + @overload + async def begin_create_or_update( + self, + profile_name: str, + resource_group_name: str, + parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[Profile]: ... + + @distributed_trace_async + async def begin_delete( + self, + resource_group_name: str, + profile_name: str, + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + profile_name: str, + parameters: ProfileUpdateModel, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[Profile]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + profile_name: str, + parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[Profile]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + profile_name: str, + parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[Profile]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + profile_name: str, + **kwargs: Any + ) -> Profile: ... + + @distributed_trace + def list(self, **kwargs: Any) -> AsyncItemPaged[Profile]: ... + + @distributed_trace + def list_by_resource_group( + self, + resource_group_name: str, + **kwargs: Any + ) -> AsyncItemPaged[Profile]: ... + + + class azure.mgmt.frontdoor.aio.operations.PoliciesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + policy_name: str, + parameters: WebApplicationFirewallPolicy, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[WebApplicationFirewallPolicy]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + policy_name: str, + parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[WebApplicationFirewallPolicy]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + policy_name: str, + parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[WebApplicationFirewallPolicy]: ... + + @distributed_trace_async + async def begin_delete( + self, + resource_group_name: str, + policy_name: str, + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + policy_name: str, + parameters: TagsObject, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[WebApplicationFirewallPolicy]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + policy_name: str, + parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[WebApplicationFirewallPolicy]: ... + + @overload + async def begin_update( + self, + resource_group_name: str, + policy_name: str, + parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[WebApplicationFirewallPolicy]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + policy_name: str, + **kwargs: Any + ) -> WebApplicationFirewallPolicy: ... + + @distributed_trace + def list( + self, + resource_group_name: str, + **kwargs: Any + ) -> AsyncItemPaged[WebApplicationFirewallPolicy]: ... + + @distributed_trace + def list_by_subscription(self, **kwargs: Any) -> AsyncItemPaged[WebApplicationFirewallPolicy]: ... + + + class azure.mgmt.frontdoor.aio.operations.PreconfiguredEndpointsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list( + self, + resource_group_name: str, + profile_name: str, + **kwargs: Any + ) -> AsyncItemPaged[PreconfiguredEndpoint]: ... + + + class azure.mgmt.frontdoor.aio.operations.ReportsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace_async + async def get_latency_scorecards( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + *, + aggregation_interval: Union[str, LatencyScorecardAggregationInterval], + country: Optional[str] = ..., + end_date_time_utc: Optional[str] = ..., + **kwargs: Any + ) -> LatencyScorecard: ... + + @distributed_trace_async + async def get_timeseries( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + *, + aggregation_interval: Union[str, TimeseriesAggregationInterval], + country: Optional[str] = ..., + end_date_time_utc: datetime, + endpoint: Optional[str] = ..., + start_date_time_utc: datetime, + timeseries_type: Union[str, TimeseriesType], + **kwargs: Any + ) -> Timeseries: ... + + + class azure.mgmt.frontdoor.aio.operations.RulesEnginesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + front_door_name: str, + rules_engine_name: str, + rules_engine_parameters: RulesEngine, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[RulesEngine]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + front_door_name: str, + rules_engine_name: str, + rules_engine_parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[RulesEngine]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + front_door_name: str, + rules_engine_name: str, + rules_engine_parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[RulesEngine]: ... + + @distributed_trace_async + async def begin_delete( + self, + resource_group_name: str, + front_door_name: str, + rules_engine_name: str, + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + front_door_name: str, + rules_engine_name: str, + **kwargs: Any + ) -> RulesEngine: ... + + @distributed_trace + def list_by_front_door( + self, + resource_group_name: str, + front_door_name: str, + **kwargs: Any + ) -> AsyncItemPaged[RulesEngine]: ... + + +namespace azure.mgmt.frontdoor.models + + class azure.mgmt.frontdoor.models.ActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ALLOW = "Allow" + ANOMALY_SCORING = "AnomalyScoring" + BLOCK = "Block" + CAPTCHA = "CAPTCHA" + JS_CHALLENGE = "JSChallenge" + LOG = "Log" + REDIRECT = "Redirect" + + + class azure.mgmt.frontdoor.models.AggregationInterval(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DAILY = "Daily" + HOURLY = "Hourly" + + + class azure.mgmt.frontdoor.models.Availability(str, Enum, metaclass=CaseInsensitiveEnumMeta): + AVAILABLE = "Available" + UNAVAILABLE = "Unavailable" + + + class azure.mgmt.frontdoor.models.Backend(_Model): + address: Optional[str] + backend_host_header: Optional[str] + enabled_state: Optional[Union[str, BackendEnabledState]] + http_port: Optional[int] + https_port: Optional[int] + priority: Optional[int] + private_endpoint_status: Optional[Union[str, PrivateEndpointStatus]] + private_link_alias: Optional[str] + private_link_approval_message: Optional[str] + private_link_location: Optional[str] + private_link_resource_id: Optional[str] + weight: Optional[int] + + @overload + def __init__( + self, + *, + address: Optional[str] = ..., + backend_host_header: Optional[str] = ..., + enabled_state: Optional[Union[str, BackendEnabledState]] = ..., + http_port: Optional[int] = ..., + https_port: Optional[int] = ..., + priority: Optional[int] = ..., + private_link_alias: Optional[str] = ..., + private_link_approval_message: Optional[str] = ..., + private_link_location: Optional[str] = ..., + private_link_resource_id: Optional[str] = ..., + weight: Optional[int] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.BackendEnabledState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + + class azure.mgmt.frontdoor.models.BackendPool(SubResource): + id: str + name: Optional[str] + properties: Optional[BackendPoolProperties] + type: Optional[str] + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + id: Optional[str] = ..., + name: Optional[str] = ..., + properties: Optional[BackendPoolProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.frontdoor.models.BackendPoolProperties(BackendPoolUpdateParameters): + backends: list[Backend] + health_probe_settings: SubResource + load_balancing_settings: SubResource + resource_state: Optional[Union[str, FrontDoorResourceState]] + + @overload + def __init__( + self, + *, + backends: Optional[list[Backend]] = ..., + health_probe_settings: Optional[SubResource] = ..., + load_balancing_settings: Optional[SubResource] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.BackendPoolUpdateParameters(_Model): + backends: Optional[list[Backend]] + health_probe_settings: Optional[SubResource] + load_balancing_settings: Optional[SubResource] + + @overload + def __init__( + self, + *, + backends: Optional[list[Backend]] = ..., + health_probe_settings: Optional[SubResource] = ..., + load_balancing_settings: Optional[SubResource] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.BackendPoolsSettings(_Model): + enforce_certificate_name_check: Optional[Union[str, EnforceCertificateNameCheckEnabledState]] + send_recv_timeout_seconds: Optional[int] + + @overload + def __init__( + self, + *, + enforce_certificate_name_check: Optional[Union[str, EnforceCertificateNameCheckEnabledState]] = ..., + send_recv_timeout_seconds: Optional[int] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.BasicResource(_Model): + id: Optional[str] + name: Optional[str] + type: Optional[str] + + + class azure.mgmt.frontdoor.models.BasicResourceWithSettableIDName(_Model): + id: Optional[str] + name: Optional[str] + type: Optional[str] + + @overload + def __init__( + self, + *, + id: Optional[str] = ..., + name: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.CacheConfiguration(_Model): + cache_duration: Optional[timedelta] + dynamic_compression: Optional[Union[str, DynamicCompressionEnabled]] + query_parameter_strip_directive: Optional[Union[str, FrontDoorQuery]] + query_parameters: Optional[str] + + @overload + def __init__( + self, + *, + cache_duration: Optional[timedelta] = ..., + dynamic_compression: Optional[Union[str, DynamicCompressionEnabled]] = ..., + query_parameter_strip_directive: Optional[Union[str, FrontDoorQuery]] = ..., + query_parameters: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.CheckNameAvailabilityInput(_Model): + name: str + type: Union[str, ResourceType] + + @overload + def __init__( + self, + *, + name: str, + type: Union[str, ResourceType] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.CheckNameAvailabilityOutput(_Model): + message: Optional[str] + name_availability: Optional[Union[str, Availability]] + reason: Optional[str] + + + class azure.mgmt.frontdoor.models.CustomHttpsConfiguration(_Model): + certificate_source: Union[str, FrontDoorCertificateSource] + front_door_certificate_source_parameters: Optional[FrontDoorCertificateSourceParameters] + key_vault_certificate_source_parameters: Optional[KeyVaultCertificateSourceParameters] + minimum_tls_version: Union[str, MinimumTLSVersion] + protocol_type: Union[str, FrontDoorTlsProtocolType] + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + certificate_source: Union[str, FrontDoorCertificateSource], + front_door_certificate_source_parameters: Optional[FrontDoorCertificateSourceParameters] = ..., + key_vault_certificate_source_parameters: Optional[KeyVaultCertificateSourceParameters] = ..., + minimum_tls_version: Union[str, MinimumTLSVersion], + protocol_type: Union[str, FrontDoorTlsProtocolType] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.frontdoor.models.CustomHttpsProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + DISABLING = "Disabling" + ENABLED = "Enabled" + ENABLING = "Enabling" + FAILED = "Failed" + + + class azure.mgmt.frontdoor.models.CustomHttpsProvisioningSubstate(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CERTIFICATE_DELETED = "CertificateDeleted" + CERTIFICATE_DEPLOYED = "CertificateDeployed" + DELETING_CERTIFICATE = "DeletingCertificate" + DEPLOYING_CERTIFICATE = "DeployingCertificate" + DOMAIN_CONTROL_VALIDATION_REQUEST_APPROVED = "DomainControlValidationRequestApproved" + DOMAIN_CONTROL_VALIDATION_REQUEST_REJECTED = "DomainControlValidationRequestRejected" + DOMAIN_CONTROL_VALIDATION_REQUEST_TIMED_OUT = "DomainControlValidationRequestTimedOut" + ISSUING_CERTIFICATE = "IssuingCertificate" + PENDING_DOMAIN_CONTROL_VALIDATION_R_EQUEST_APPROVAL = "PendingDomainControlValidationREquestApproval" + SUBMITTING_DOMAIN_CONTROL_VALIDATION_REQUEST = "SubmittingDomainControlValidationRequest" + + + class azure.mgmt.frontdoor.models.CustomRule(_Model): + action: Union[str, ActionType] + enabled_state: Optional[Union[str, CustomRuleEnabledState]] + group_by: Optional[list[GroupByVariable]] + match_conditions: list[MatchCondition] + name: Optional[str] + priority: int + rate_limit_duration_in_minutes: Optional[int] + rate_limit_threshold: Optional[int] + rule_type: Union[str, RuleType] + + @overload + def __init__( + self, + *, + action: Union[str, ActionType], + enabled_state: Optional[Union[str, CustomRuleEnabledState]] = ..., + group_by: Optional[list[GroupByVariable]] = ..., + match_conditions: list[MatchCondition], + name: Optional[str] = ..., + priority: int, + rate_limit_duration_in_minutes: Optional[int] = ..., + rate_limit_threshold: Optional[int] = ..., + rule_type: Union[str, RuleType] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.CustomRuleEnabledState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + + class azure.mgmt.frontdoor.models.CustomRuleList(_Model): + rules: Optional[list[CustomRule]] + + @overload + def __init__( + self, + *, + rules: Optional[list[CustomRule]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.DefaultErrorResponse(_Model): + error: Optional[DefaultErrorResponseError] + + @overload + def __init__( + self, + *, + error: Optional[DefaultErrorResponseError] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.DefaultErrorResponseError(_Model): + code: Optional[str] + message: Optional[str] + + + class azure.mgmt.frontdoor.models.DynamicCompressionEnabled(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + + class azure.mgmt.frontdoor.models.Endpoint(_Model): + endpoint: Optional[str] + name: Optional[str] + + @overload + def __init__( + self, + *, + endpoint: Optional[str] = ..., + name: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.EndpointType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + AFD = "AFD" + ATM = "ATM" + AZURE_REGION = "AzureRegion" + CDN = "CDN" + + + class azure.mgmt.frontdoor.models.EnforceCertificateNameCheckEnabledState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + + class azure.mgmt.frontdoor.models.ErrorResponse(_Model): + code: Optional[str] + message: Optional[str] + + + class azure.mgmt.frontdoor.models.Experiment(Resource): + id: str + location: str + name: str + properties: Optional[ExperimentProperties] + tags: dict[str, str] + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + location: Optional[str] = ..., + properties: Optional[ExperimentProperties] = ..., + 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.frontdoor.models.ExperimentProperties(_Model): + description: Optional[str] + enabled_state: Optional[Union[str, State]] + endpoint_a: Optional[Endpoint] + endpoint_b: Optional[Endpoint] + resource_state: Optional[Union[str, NetworkExperimentResourceState]] + script_file_uri: Optional[str] + status: Optional[str] + + @overload + def __init__( + self, + *, + description: Optional[str] = ..., + enabled_state: Optional[Union[str, State]] = ..., + endpoint_a: Optional[Endpoint] = ..., + endpoint_b: Optional[Endpoint] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.ExperimentUpdateModel(_Model): + properties: Optional[ExperimentUpdateProperties] + tags: Optional[dict[str, str]] + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + properties: Optional[ExperimentUpdateProperties] = ..., + 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.frontdoor.models.ExperimentUpdateProperties(_Model): + description: Optional[str] + enabled_state: Optional[Union[str, State]] + + @overload + def __init__( + self, + *, + description: Optional[str] = ..., + enabled_state: Optional[Union[str, State]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.ForwardingConfiguration(RouteConfiguration, discriminator='#Microsoft.Azure.FrontDoor.Models.FrontdoorForwardingConfiguration'): + backend_pool: Optional[SubResource] + cache_configuration: Optional[CacheConfiguration] + custom_forwarding_path: Optional[str] + forwarding_protocol: Optional[Union[str, FrontDoorForwardingProtocol]] + odata_type: Literal["#FrontdoorForwardingConfiguration"] + + @overload + def __init__( + self, + *, + backend_pool: Optional[SubResource] = ..., + cache_configuration: Optional[CacheConfiguration] = ..., + custom_forwarding_path: Optional[str] = ..., + forwarding_protocol: Optional[Union[str, FrontDoorForwardingProtocol]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.FrontDoor(Resource): + id: str + location: str + name: str + properties: Optional[FrontDoorProperties] + tags: dict[str, str] + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + location: Optional[str] = ..., + properties: Optional[FrontDoorProperties] = ..., + 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.frontdoor.models.FrontDoorCertificateSource(str, Enum, metaclass=CaseInsensitiveEnumMeta): + AZURE_KEY_VAULT = "AzureKeyVault" + FRONT_DOOR = "FrontDoor" + + + class azure.mgmt.frontdoor.models.FrontDoorCertificateSourceParameters(_Model): + certificate_type: Optional[Union[str, FrontDoorCertificateType]] + + @overload + def __init__( + self, + *, + certificate_type: Optional[Union[str, FrontDoorCertificateType]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.FrontDoorCertificateType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DEDICATED = "Dedicated" + + + class azure.mgmt.frontdoor.models.FrontDoorEnabledState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + + class azure.mgmt.frontdoor.models.FrontDoorForwardingProtocol(str, Enum, metaclass=CaseInsensitiveEnumMeta): + HTTPS_ONLY = "HttpsOnly" + HTTP_ONLY = "HttpOnly" + MATCH_REQUEST = "MatchRequest" + + + class azure.mgmt.frontdoor.models.FrontDoorHealthProbeMethod(str, Enum, metaclass=CaseInsensitiveEnumMeta): + GET = "GET" + HEAD = "HEAD" + + + class azure.mgmt.frontdoor.models.FrontDoorProperties(FrontDoorUpdateParameters): + backend_pools: list[BackendPool] + backend_pools_settings: BackendPoolsSettings + cname: Optional[str] + enabled_state: Union[str, FrontDoorEnabledState] + extended_properties: Optional[dict[str, str]] + friendly_name: str + frontdoor_id: Optional[str] + frontend_endpoints: list[FrontendEndpoint] + health_probe_settings: list[HealthProbeSettingsModel] + load_balancing_settings: list[LoadBalancingSettingsModel] + provisioning_state: Optional[str] + resource_state: Optional[Union[str, FrontDoorResourceState]] + routing_rules: list[RoutingRule] + rules_engines: Optional[list[RulesEngine]] + + @overload + def __init__( + self, + *, + backend_pools: Optional[list[BackendPool]] = ..., + backend_pools_settings: Optional[BackendPoolsSettings] = ..., + enabled_state: Optional[Union[str, FrontDoorEnabledState]] = ..., + friendly_name: Optional[str] = ..., + frontend_endpoints: Optional[list[FrontendEndpoint]] = ..., + health_probe_settings: Optional[list[HealthProbeSettingsModel]] = ..., + load_balancing_settings: Optional[list[LoadBalancingSettingsModel]] = ..., + routing_rules: Optional[list[RoutingRule]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.FrontDoorProtocol(str, Enum, metaclass=CaseInsensitiveEnumMeta): + HTTP = "Http" + HTTPS = "Https" + + + class azure.mgmt.frontdoor.models.FrontDoorQuery(str, Enum, metaclass=CaseInsensitiveEnumMeta): + STRIP_ALL = "StripAll" + STRIP_ALL_EXCEPT = "StripAllExcept" + STRIP_NONE = "StripNone" + STRIP_ONLY = "StripOnly" + + + class azure.mgmt.frontdoor.models.FrontDoorRedirectProtocol(str, Enum, metaclass=CaseInsensitiveEnumMeta): + HTTPS_ONLY = "HttpsOnly" + HTTP_ONLY = "HttpOnly" + MATCH_REQUEST = "MatchRequest" + + + class azure.mgmt.frontdoor.models.FrontDoorRedirectType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + FOUND = "Found" + MOVED = "Moved" + PERMANENT_REDIRECT = "PermanentRedirect" + TEMPORARY_REDIRECT = "TemporaryRedirect" + + + class azure.mgmt.frontdoor.models.FrontDoorResourceState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CREATING = "Creating" + DELETING = "Deleting" + DISABLED = "Disabled" + DISABLING = "Disabling" + ENABLED = "Enabled" + ENABLING = "Enabling" + MIGRATED = "Migrated" + MIGRATING = "Migrating" + + + class azure.mgmt.frontdoor.models.FrontDoorTlsProtocolType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + SERVER_NAME_INDICATION = "ServerNameIndication" + + + class azure.mgmt.frontdoor.models.FrontDoorUpdateParameters(_Model): + backend_pools: Optional[list[BackendPool]] + backend_pools_settings: Optional[BackendPoolsSettings] + enabled_state: Optional[Union[str, FrontDoorEnabledState]] + friendly_name: Optional[str] + frontend_endpoints: Optional[list[FrontendEndpoint]] + health_probe_settings: Optional[list[HealthProbeSettingsModel]] + load_balancing_settings: Optional[list[LoadBalancingSettingsModel]] + routing_rules: Optional[list[RoutingRule]] + + @overload + def __init__( + self, + *, + backend_pools: Optional[list[BackendPool]] = ..., + backend_pools_settings: Optional[BackendPoolsSettings] = ..., + enabled_state: Optional[Union[str, FrontDoorEnabledState]] = ..., + friendly_name: Optional[str] = ..., + frontend_endpoints: Optional[list[FrontendEndpoint]] = ..., + health_probe_settings: Optional[list[HealthProbeSettingsModel]] = ..., + load_balancing_settings: Optional[list[LoadBalancingSettingsModel]] = ..., + routing_rules: Optional[list[RoutingRule]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.FrontendEndpoint(BasicResourceWithSettableIDName): + id: str + name: str + properties: Optional[FrontendEndpointProperties] + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + id: Optional[str] = ..., + name: Optional[str] = ..., + properties: Optional[FrontendEndpointProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.frontdoor.models.FrontendEndpointLink(_Model): + id: Optional[str] + + @overload + def __init__( + self, + *, + id: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.FrontendEndpointProperties(FrontendEndpointUpdateParameters): + custom_https_configuration: Optional[CustomHttpsConfiguration] + custom_https_provisioning_state: Optional[Union[str, CustomHttpsProvisioningState]] + custom_https_provisioning_substate: Optional[Union[str, CustomHttpsProvisioningSubstate]] + host_name: str + resource_state: Optional[Union[str, FrontDoorResourceState]] + session_affinity_enabled_state: Union[str, SessionAffinityEnabledState] + session_affinity_ttl_seconds: int + web_application_firewall_policy_link: FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink + + @overload + def __init__( + self, + *, + host_name: Optional[str] = ..., + session_affinity_enabled_state: Optional[Union[str, SessionAffinityEnabledState]] = ..., + session_affinity_ttl_seconds: Optional[int] = ..., + web_application_firewall_policy_link: Optional[FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.FrontendEndpointUpdateParameters(_Model): + host_name: Optional[str] + session_affinity_enabled_state: Optional[Union[str, SessionAffinityEnabledState]] + session_affinity_ttl_seconds: Optional[int] + web_application_firewall_policy_link: Optional[FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink] + + @overload + def __init__( + self, + *, + host_name: Optional[str] = ..., + session_affinity_enabled_state: Optional[Union[str, SessionAffinityEnabledState]] = ..., + session_affinity_ttl_seconds: Optional[int] = ..., + web_application_firewall_policy_link: Optional[FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.FrontendEndpointUpdateParametersWebApplicationFirewallPolicyLink(_Model): + id: Optional[str] + + @overload + def __init__( + self, + *, + id: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.GroupByVariable(_Model): + variable_name: Union[str, VariableName] + + @overload + def __init__( + self, + *, + variable_name: Union[str, VariableName] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.HeaderAction(_Model): + header_action_type: Union[str, HeaderActionType] + header_name: str + value: Optional[str] + + @overload + def __init__( + self, + *, + header_action_type: Union[str, HeaderActionType], + header_name: str, + value: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.HeaderActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + APPEND = "Append" + DELETE = "Delete" + OVERWRITE = "Overwrite" + + + class azure.mgmt.frontdoor.models.HealthProbeEnabled(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + + class azure.mgmt.frontdoor.models.HealthProbeSettingsModel(SubResource): + id: str + name: Optional[str] + properties: Optional[HealthProbeSettingsProperties] + type: Optional[str] + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + id: Optional[str] = ..., + name: Optional[str] = ..., + properties: Optional[HealthProbeSettingsProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.frontdoor.models.HealthProbeSettingsProperties(HealthProbeSettingsUpdateParameters): + enabled_state: Union[str, HealthProbeEnabled] + health_probe_method: Union[str, FrontDoorHealthProbeMethod] + interval_in_seconds: int + path: str + protocol: Union[str, FrontDoorProtocol] + resource_state: Optional[Union[str, FrontDoorResourceState]] + + @overload + def __init__( + self, + *, + enabled_state: Optional[Union[str, HealthProbeEnabled]] = ..., + health_probe_method: Optional[Union[str, FrontDoorHealthProbeMethod]] = ..., + interval_in_seconds: Optional[int] = ..., + path: Optional[str] = ..., + protocol: Optional[Union[str, FrontDoorProtocol]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.HealthProbeSettingsUpdateParameters(_Model): + enabled_state: Optional[Union[str, HealthProbeEnabled]] + health_probe_method: Optional[Union[str, FrontDoorHealthProbeMethod]] + interval_in_seconds: Optional[int] + path: Optional[str] + protocol: Optional[Union[str, FrontDoorProtocol]] + + @overload + def __init__( + self, + *, + enabled_state: Optional[Union[str, HealthProbeEnabled]] = ..., + health_probe_method: Optional[Union[str, FrontDoorHealthProbeMethod]] = ..., + interval_in_seconds: Optional[int] = ..., + path: Optional[str] = ..., + protocol: Optional[Union[str, FrontDoorProtocol]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.KeyVaultCertificateSourceParameters(_Model): + secret_name: Optional[str] + secret_version: Optional[str] + vault: Optional[KeyVaultCertificateSourceParametersVault] + + @overload + def __init__( + self, + *, + secret_name: Optional[str] = ..., + secret_version: Optional[str] = ..., + vault: Optional[KeyVaultCertificateSourceParametersVault] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.KeyVaultCertificateSourceParametersVault(_Model): + id: Optional[str] + + @overload + def __init__( + self, + *, + id: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.LatencyMetric(_Model): + a_c_lower95_ci: Optional[float] + a_h_upper95_ci: Optional[float] + a_value: Optional[float] + b_c_lower95_ci: Optional[float] + b_upper95_ci: Optional[float] + b_value: Optional[float] + delta: Optional[float] + delta_percent: Optional[float] + end_date_time_utc: Optional[str] + name: Optional[str] + + + class azure.mgmt.frontdoor.models.LatencyScorecard(Resource): + id: str + location: str + name: str + properties: Optional[LatencyScorecardProperties] + tags: dict[str, str] + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + location: Optional[str] = ..., + properties: Optional[LatencyScorecardProperties] = ..., + 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.frontdoor.models.LatencyScorecardAggregationInterval(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DAILY = "Daily" + MONTHLY = "Monthly" + WEEKLY = "Weekly" + + + class azure.mgmt.frontdoor.models.LatencyScorecardProperties(_Model): + country: Optional[str] + description: Optional[str] + end_date_time_utc: Optional[datetime] + endpoint_a: Optional[str] + endpoint_b: Optional[str] + id: Optional[str] + latency_metrics: Optional[list[LatencyMetric]] + name: Optional[str] + start_date_time_utc: Optional[datetime] + + @overload + def __init__( + self, + *, + latency_metrics: Optional[list[LatencyMetric]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.LoadBalancingSettingsModel(SubResource): + id: str + name: Optional[str] + properties: Optional[LoadBalancingSettingsProperties] + type: Optional[str] + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + id: Optional[str] = ..., + name: Optional[str] = ..., + properties: Optional[LoadBalancingSettingsProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.frontdoor.models.LoadBalancingSettingsProperties(LoadBalancingSettingsUpdateParameters): + additional_latency_milliseconds: int + resource_state: Optional[Union[str, FrontDoorResourceState]] + sample_size: int + successful_samples_required: int + + @overload + def __init__( + self, + *, + additional_latency_milliseconds: Optional[int] = ..., + sample_size: Optional[int] = ..., + successful_samples_required: Optional[int] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.LoadBalancingSettingsUpdateParameters(_Model): + additional_latency_milliseconds: Optional[int] + sample_size: Optional[int] + successful_samples_required: Optional[int] + + @overload + def __init__( + self, + *, + additional_latency_milliseconds: Optional[int] = ..., + sample_size: Optional[int] = ..., + successful_samples_required: Optional[int] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.ManagedRuleDefinition(_Model): + default_action: Optional[Union[str, ActionType]] + default_sensitivity: Optional[Union[str, SensitivityType]] + default_state: Optional[Union[str, ManagedRuleEnabledState]] + description: Optional[str] + rule_id: Optional[str] + + + class azure.mgmt.frontdoor.models.ManagedRuleEnabledState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + + class azure.mgmt.frontdoor.models.ManagedRuleExclusion(_Model): + match_variable: Union[str, ManagedRuleExclusionMatchVariable] + selector: str + selector_match_operator: Union[str, ManagedRuleExclusionSelectorMatchOperator] + + @overload + def __init__( + self, + *, + match_variable: Union[str, ManagedRuleExclusionMatchVariable], + selector: str, + selector_match_operator: Union[str, ManagedRuleExclusionSelectorMatchOperator] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.ManagedRuleExclusionMatchVariable(str, Enum, metaclass=CaseInsensitiveEnumMeta): + QUERY_STRING_ARG_NAMES = "QueryStringArgNames" + REQUEST_BODY_JSON_ARG_NAMES = "RequestBodyJsonArgNames" + REQUEST_BODY_POST_ARG_NAMES = "RequestBodyPostArgNames" + REQUEST_COOKIE_NAMES = "RequestCookieNames" + REQUEST_HEADER_NAMES = "RequestHeaderNames" + + + class azure.mgmt.frontdoor.models.ManagedRuleExclusionSelectorMatchOperator(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CONTAINS = "Contains" + ENDS_WITH = "EndsWith" + EQUALS = "Equals" + EQUALS_ANY = "EqualsAny" + STARTS_WITH = "StartsWith" + + + class azure.mgmt.frontdoor.models.ManagedRuleGroupDefinition(_Model): + description: Optional[str] + rule_group_name: Optional[str] + rules: Optional[list[ManagedRuleDefinition]] + + + class azure.mgmt.frontdoor.models.ManagedRuleGroupOverride(_Model): + exclusions: Optional[list[ManagedRuleExclusion]] + rule_group_name: str + rules: Optional[list[ManagedRuleOverride]] + + @overload + def __init__( + self, + *, + exclusions: Optional[list[ManagedRuleExclusion]] = ..., + rule_group_name: str, + rules: Optional[list[ManagedRuleOverride]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.ManagedRuleOverride(_Model): + action: Optional[Union[str, ActionType]] + enabled_state: Optional[Union[str, ManagedRuleEnabledState]] + exclusions: Optional[list[ManagedRuleExclusion]] + rule_id: str + sensitivity: Optional[Union[str, SensitivityType]] + + @overload + def __init__( + self, + *, + action: Optional[Union[str, ActionType]] = ..., + enabled_state: Optional[Union[str, ManagedRuleEnabledState]] = ..., + exclusions: Optional[list[ManagedRuleExclusion]] = ..., + rule_id: str, + sensitivity: Optional[Union[str, SensitivityType]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.ManagedRuleSet(_Model): + exclusions: Optional[list[ManagedRuleExclusion]] + rule_group_overrides: Optional[list[ManagedRuleGroupOverride]] + rule_set_action: Optional[Union[str, ManagedRuleSetActionType]] + rule_set_type: str + rule_set_version: str + + @overload + def __init__( + self, + *, + exclusions: Optional[list[ManagedRuleExclusion]] = ..., + rule_group_overrides: Optional[list[ManagedRuleGroupOverride]] = ..., + rule_set_action: Optional[Union[str, ManagedRuleSetActionType]] = ..., + rule_set_type: str, + rule_set_version: str + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.ManagedRuleSetActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + BLOCK = "Block" + LOG = "Log" + REDIRECT = "Redirect" + + + class azure.mgmt.frontdoor.models.ManagedRuleSetDefinition(Resource): + id: str + location: str + name: str + properties: Optional[ManagedRuleSetDefinitionProperties] + tags: dict[str, str] + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + location: Optional[str] = ..., + properties: Optional[ManagedRuleSetDefinitionProperties] = ..., + 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.frontdoor.models.ManagedRuleSetDefinitionProperties(_Model): + provisioning_state: Optional[str] + rule_groups: Optional[list[ManagedRuleGroupDefinition]] + rule_set_id: Optional[str] + rule_set_type: Optional[str] + rule_set_version: Optional[str] + + + class azure.mgmt.frontdoor.models.ManagedRuleSetList(_Model): + managed_rule_sets: Optional[list[ManagedRuleSet]] + + @overload + def __init__( + self, + *, + managed_rule_sets: Optional[list[ManagedRuleSet]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.MatchCondition(_Model): + match_value: list[str] + match_variable: Union[str, MatchVariable] + negate_condition: Optional[bool] + operator: Union[str, Operator] + selector: Optional[str] + transforms: Optional[list[Union[str, TransformType]]] + + @overload + def __init__( + self, + *, + match_value: list[str], + match_variable: Union[str, MatchVariable], + negate_condition: Optional[bool] = ..., + operator: Union[str, Operator], + selector: Optional[str] = ..., + transforms: Optional[list[Union[str, TransformType]]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.MatchProcessingBehavior(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CONTINUE_ENUM = "Continue" + STOP = "Stop" + + + class azure.mgmt.frontdoor.models.MatchVariable(str, Enum, metaclass=CaseInsensitiveEnumMeta): + COOKIES = "Cookies" + POST_ARGS = "PostArgs" + QUERY_STRING = "QueryString" + REMOTE_ADDR = "RemoteAddr" + REQUEST_BODY = "RequestBody" + REQUEST_HEADER = "RequestHeader" + REQUEST_METHOD = "RequestMethod" + REQUEST_URI = "RequestUri" + SOCKET_ADDR = "SocketAddr" + + + class azure.mgmt.frontdoor.models.MinimumTLSVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ONE0 = "1.0" + ONE2 = "1.2" + + + class azure.mgmt.frontdoor.models.NetworkExperimentResourceState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CREATING = "Creating" + DELETING = "Deleting" + DISABLED = "Disabled" + DISABLING = "Disabling" + ENABLED = "Enabled" + ENABLING = "Enabling" + + + class azure.mgmt.frontdoor.models.Operator(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ANY = "Any" + BEGINS_WITH = "BeginsWith" + CONTAINS = "Contains" + ENDS_WITH = "EndsWith" + EQUAL = "Equal" + GEO_MATCH = "GeoMatch" + GREATER_THAN = "GreaterThan" + GREATER_THAN_OR_EQUAL = "GreaterThanOrEqual" + IP_MATCH = "IPMatch" + LESS_THAN = "LessThan" + LESS_THAN_OR_EQUAL = "LessThanOrEqual" + REG_EX = "RegEx" + SERVICE_TAG_MATCH = "ServiceTagMatch" + + + class azure.mgmt.frontdoor.models.PolicyEnabledState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + + class azure.mgmt.frontdoor.models.PolicyMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DETECTION = "Detection" + PREVENTION = "Prevention" + + + class azure.mgmt.frontdoor.models.PolicyRequestBodyCheck(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + + class azure.mgmt.frontdoor.models.PolicyResourceState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CREATING = "Creating" + DELETING = "Deleting" + DISABLED = "Disabled" + DISABLING = "Disabling" + ENABLED = "Enabled" + ENABLING = "Enabling" + + + class azure.mgmt.frontdoor.models.PolicySettings(_Model): + captcha_expiration_in_minutes: Optional[int] + custom_block_response_body: Optional[str] + custom_block_response_status_code: Optional[int] + enabled_state: Optional[Union[str, PolicyEnabledState]] + javascript_challenge_expiration_in_minutes: Optional[int] + log_scrubbing: Optional[PolicySettingsLogScrubbing] + mode: Optional[Union[str, PolicyMode]] + redirect_url: Optional[str] + request_body_check: Optional[Union[str, PolicyRequestBodyCheck]] + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + captcha_expiration_in_minutes: Optional[int] = ..., + custom_block_response_body: Optional[str] = ..., + custom_block_response_status_code: Optional[int] = ..., + enabled_state: Optional[Union[str, PolicyEnabledState]] = ..., + javascript_challenge_expiration_in_minutes: Optional[int] = ..., + log_scrubbing: Optional[PolicySettingsLogScrubbing] = ..., + mode: Optional[Union[str, PolicyMode]] = ..., + redirect_url: Optional[str] = ..., + request_body_check: Optional[Union[str, PolicyRequestBodyCheck]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.frontdoor.models.PolicySettingsLogScrubbing(_Model): + scrubbing_rules: Optional[list[WebApplicationFirewallScrubbingRules]] + state: Optional[Union[str, WebApplicationFirewallScrubbingState]] + + @overload + def __init__( + self, + *, + scrubbing_rules: Optional[list[WebApplicationFirewallScrubbingRules]] = ..., + state: Optional[Union[str, WebApplicationFirewallScrubbingState]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.PreconfiguredEndpoint(ResourcewithSettableName): + id: str + location: str + name: str + properties: Optional[PreconfiguredEndpointProperties] + tags: dict[str, str] + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + location: Optional[str] = ..., + properties: Optional[PreconfiguredEndpointProperties] = ..., + 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.frontdoor.models.PreconfiguredEndpointProperties(_Model): + backend: Optional[str] + description: Optional[str] + endpoint: Optional[str] + endpoint_type: Optional[Union[str, EndpointType]] + + @overload + def __init__( + self, + *, + backend: Optional[str] = ..., + description: Optional[str] = ..., + endpoint: Optional[str] = ..., + endpoint_type: Optional[Union[str, EndpointType]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.PrivateEndpointStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + APPROVED = "Approved" + DISCONNECTED = "Disconnected" + PENDING = "Pending" + REJECTED = "Rejected" + TIMEOUT = "Timeout" + + + class azure.mgmt.frontdoor.models.Profile(ResourcewithSettableName): + etag: Optional[str] + id: str + location: str + name: str + properties: Optional[ProfileProperties] + tags: dict[str, str] + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + etag: Optional[str] = ..., + location: Optional[str] = ..., + properties: Optional[ProfileProperties] = ..., + 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.frontdoor.models.ProfileProperties(_Model): + enabled_state: Optional[Union[str, State]] + resource_state: Optional[Union[str, NetworkExperimentResourceState]] + + @overload + def __init__( + self, + *, + enabled_state: Optional[Union[str, State]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.ProfileUpdateModel(_Model): + properties: Optional[ProfileUpdateProperties] + tags: Optional[dict[str, str]] + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + properties: Optional[ProfileUpdateProperties] = ..., + 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.frontdoor.models.ProfileUpdateProperties(_Model): + enabled_state: Optional[Union[str, State]] + + @overload + def __init__( + self, + *, + enabled_state: Optional[Union[str, State]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.PurgeParameters(_Model): + content_paths: list[str] + + @overload + def __init__( + self, + *, + content_paths: list[str] + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.RedirectConfiguration(RouteConfiguration, discriminator='#Microsoft.Azure.FrontDoor.Models.FrontdoorRedirectConfiguration'): + custom_fragment: Optional[str] + custom_host: Optional[str] + custom_path: Optional[str] + custom_query_string: Optional[str] + odata_type: Literal["#FrontdoorRedirectConfiguration"] + redirect_protocol: Optional[Union[str, FrontDoorRedirectProtocol]] + redirect_type: Optional[Union[str, FrontDoorRedirectType]] + + @overload + def __init__( + self, + *, + custom_fragment: Optional[str] = ..., + custom_host: Optional[str] = ..., + custom_path: Optional[str] = ..., + custom_query_string: Optional[str] = ..., + redirect_protocol: Optional[Union[str, FrontDoorRedirectProtocol]] = ..., + redirect_type: Optional[Union[str, FrontDoorRedirectType]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.Resource(_Model): + id: Optional[str] + location: Optional[str] + name: Optional[str] + tags: Optional[dict[str, str]] + type: Optional[str] + + @overload + def __init__( + self, + *, + location: Optional[str] = ..., + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.ResourceType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + MICROSOFT_NETWORK_FRONT_DOORS = "Microsoft.Network/frontDoors" + MICROSOFT_NETWORK_FRONT_DOORS_FRONTEND_ENDPOINTS = "Microsoft.Network/frontDoors/frontendEndpoints" + + + class azure.mgmt.frontdoor.models.ResourcewithSettableName(_Model): + id: Optional[str] + location: Optional[str] + name: Optional[str] + tags: Optional[dict[str, str]] + type: Optional[str] + + @overload + def __init__( + self, + *, + location: Optional[str] = ..., + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.RouteConfiguration(_Model): + odata_type: str + + @overload + def __init__( + self, + *, + odata_type: str + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.RoutingRule(SubResource): + id: str + name: Optional[str] + properties: Optional[RoutingRuleProperties] + type: Optional[str] + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + id: Optional[str] = ..., + name: Optional[str] = ..., + properties: Optional[RoutingRuleProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.frontdoor.models.RoutingRuleEnabledState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + + class azure.mgmt.frontdoor.models.RoutingRuleLink(_Model): + id: Optional[str] + + @overload + def __init__( + self, + *, + id: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.RoutingRuleProperties(RoutingRuleUpdateParameters): + accepted_protocols: Union[list[str, FrontDoorProtocol]] + enabled_state: Union[str, RoutingRuleEnabledState] + frontend_endpoints: list[SubResource] + patterns_to_match: list[str] + resource_state: Optional[Union[str, FrontDoorResourceState]] + route_configuration: RouteConfiguration + rules_engine: SubResource + web_application_firewall_policy_link: RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink + + @overload + def __init__( + self, + *, + accepted_protocols: Optional[list[Union[str, FrontDoorProtocol]]] = ..., + enabled_state: Optional[Union[str, RoutingRuleEnabledState]] = ..., + frontend_endpoints: Optional[list[SubResource]] = ..., + patterns_to_match: Optional[list[str]] = ..., + route_configuration: Optional[RouteConfiguration] = ..., + rules_engine: Optional[SubResource] = ..., + web_application_firewall_policy_link: Optional[RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.RoutingRuleUpdateParameters(_Model): + accepted_protocols: Optional[list[Union[str, FrontDoorProtocol]]] + enabled_state: Optional[Union[str, RoutingRuleEnabledState]] + frontend_endpoints: Optional[list[SubResource]] + patterns_to_match: Optional[list[str]] + route_configuration: Optional[RouteConfiguration] + rules_engine: Optional[SubResource] + web_application_firewall_policy_link: Optional[RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink] + + @overload + def __init__( + self, + *, + accepted_protocols: Optional[list[Union[str, FrontDoorProtocol]]] = ..., + enabled_state: Optional[Union[str, RoutingRuleEnabledState]] = ..., + frontend_endpoints: Optional[list[SubResource]] = ..., + patterns_to_match: Optional[list[str]] = ..., + route_configuration: Optional[RouteConfiguration] = ..., + rules_engine: Optional[SubResource] = ..., + web_application_firewall_policy_link: Optional[RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.RoutingRuleUpdateParametersWebApplicationFirewallPolicyLink(_Model): + id: Optional[str] + + @overload + def __init__( + self, + *, + id: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.RuleType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + MATCH_RULE = "MatchRule" + RATE_LIMIT_RULE = "RateLimitRule" + + + class azure.mgmt.frontdoor.models.RulesEngine(BasicResource): + id: str + name: str + properties: Optional[RulesEngineProperties] + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + properties: Optional[RulesEngineProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + def __setattr__( + self, + key: str, + value: Any + ) -> None: ... + + + class azure.mgmt.frontdoor.models.RulesEngineAction(_Model): + request_header_actions: Optional[list[HeaderAction]] + response_header_actions: Optional[list[HeaderAction]] + route_configuration_override: Optional[RouteConfiguration] + + @overload + def __init__( + self, + *, + request_header_actions: Optional[list[HeaderAction]] = ..., + response_header_actions: Optional[list[HeaderAction]] = ..., + route_configuration_override: Optional[RouteConfiguration] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.RulesEngineMatchCondition(_Model): + negate_condition: Optional[bool] + rules_engine_match_value: list[str] + rules_engine_match_variable: Union[str, RulesEngineMatchVariable] + rules_engine_operator: Union[str, RulesEngineOperator] + selector: Optional[str] + transforms: Optional[list[Union[str, Transform]]] + + @overload + def __init__( + self, + *, + negate_condition: Optional[bool] = ..., + rules_engine_match_value: list[str], + rules_engine_match_variable: Union[str, RulesEngineMatchVariable], + rules_engine_operator: Union[str, RulesEngineOperator], + selector: Optional[str] = ..., + transforms: Optional[list[Union[str, Transform]]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.RulesEngineMatchVariable(str, Enum, metaclass=CaseInsensitiveEnumMeta): + IS_MOBILE = "IsMobile" + POST_ARGS = "PostArgs" + QUERY_STRING = "QueryString" + REMOTE_ADDR = "RemoteAddr" + REQUEST_BODY = "RequestBody" + REQUEST_FILENAME = "RequestFilename" + REQUEST_FILENAME_EXTENSION = "RequestFilenameExtension" + REQUEST_HEADER = "RequestHeader" + REQUEST_METHOD = "RequestMethod" + REQUEST_PATH = "RequestPath" + REQUEST_SCHEME = "RequestScheme" + REQUEST_URI = "RequestUri" + + + class azure.mgmt.frontdoor.models.RulesEngineOperator(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ANY = "Any" + BEGINS_WITH = "BeginsWith" + CONTAINS = "Contains" + ENDS_WITH = "EndsWith" + EQUAL = "Equal" + GEO_MATCH = "GeoMatch" + GREATER_THAN = "GreaterThan" + GREATER_THAN_OR_EQUAL = "GreaterThanOrEqual" + IP_MATCH = "IPMatch" + LESS_THAN = "LessThan" + LESS_THAN_OR_EQUAL = "LessThanOrEqual" + + + class azure.mgmt.frontdoor.models.RulesEngineProperties(RulesEngineUpdateParameters): + resource_state: Optional[Union[str, FrontDoorResourceState]] + rules: list[RulesEngineRule] + + @overload + def __init__( + self, + *, + rules: Optional[list[RulesEngineRule]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.RulesEngineRule(_Model): + action: RulesEngineAction + match_conditions: Optional[list[RulesEngineMatchCondition]] + match_processing_behavior: Optional[Union[str, MatchProcessingBehavior]] + name: str + priority: int + + @overload + def __init__( + self, + *, + action: RulesEngineAction, + match_conditions: Optional[list[RulesEngineMatchCondition]] = ..., + match_processing_behavior: Optional[Union[str, MatchProcessingBehavior]] = ..., + name: str, + priority: int + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.RulesEngineUpdateParameters(_Model): + rules: Optional[list[RulesEngineRule]] + + @overload + def __init__( + self, + *, + rules: Optional[list[RulesEngineRule]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.ScrubbingRuleEntryMatchOperator(str, Enum, metaclass=CaseInsensitiveEnumMeta): + EQUALS = "Equals" + EQUALS_ANY = "EqualsAny" + + + class azure.mgmt.frontdoor.models.ScrubbingRuleEntryMatchVariable(str, Enum, metaclass=CaseInsensitiveEnumMeta): + QUERY_STRING_ARG_NAMES = "QueryStringArgNames" + REQUEST_BODY_JSON_ARG_NAMES = "RequestBodyJsonArgNames" + REQUEST_BODY_POST_ARG_NAMES = "RequestBodyPostArgNames" + REQUEST_COOKIE_NAMES = "RequestCookieNames" + REQUEST_HEADER_NAMES = "RequestHeaderNames" + REQUEST_IP_ADDRESS = "RequestIPAddress" + REQUEST_URI = "RequestUri" + + + class azure.mgmt.frontdoor.models.ScrubbingRuleEntryState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + + class azure.mgmt.frontdoor.models.SecurityPolicyLink(_Model): + id: Optional[str] + + @overload + def __init__( + self, + *, + id: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.SensitivityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + HIGH = "High" + LOW = "Low" + MEDIUM = "Medium" + + + class azure.mgmt.frontdoor.models.SessionAffinityEnabledState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + + class azure.mgmt.frontdoor.models.Sku(_Model): + name: Optional[Union[str, SkuName]] + + @overload + def __init__( + self, + *, + name: Optional[Union[str, SkuName]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.SkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CLASSIC_AZURE_FRONT_DOOR = "Classic_AzureFrontDoor" + PREMIUM_AZURE_FRONT_DOOR = "Premium_AzureFrontDoor" + STANDARD_AZURE_FRONT_DOOR = "Standard_AzureFrontDoor" + + + class azure.mgmt.frontdoor.models.State(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + + class azure.mgmt.frontdoor.models.SubResource(_Model): + id: Optional[str] + + @overload + def __init__( + self, + *, + id: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.TagsObject(_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.frontdoor.models.Timeseries(Resource): + id: str + location: str + name: str + properties: Optional[TimeseriesProperties] + tags: dict[str, str] + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + location: Optional[str] = ..., + properties: Optional[TimeseriesProperties] = ..., + 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.frontdoor.models.TimeseriesAggregationInterval(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DAILY = "Daily" + HOURLY = "Hourly" + + + class azure.mgmt.frontdoor.models.TimeseriesDataPoint(_Model): + date_time_utc: Optional[str] + value: Optional[float] + + @overload + def __init__( + self, + *, + date_time_utc: Optional[str] = ..., + value: Optional[float] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.TimeseriesProperties(_Model): + aggregation_interval: Optional[Union[str, AggregationInterval]] + country: Optional[str] + end_date_time_utc: Optional[str] + endpoint: Optional[str] + start_date_time_utc: Optional[str] + timeseries_data: Optional[list[TimeseriesDataPoint]] + timeseries_type: Optional[Union[str, TimeseriesType]] + + @overload + def __init__( + self, + *, + aggregation_interval: Optional[Union[str, AggregationInterval]] = ..., + country: Optional[str] = ..., + end_date_time_utc: Optional[str] = ..., + endpoint: Optional[str] = ..., + start_date_time_utc: Optional[str] = ..., + timeseries_data: Optional[list[TimeseriesDataPoint]] = ..., + timeseries_type: Optional[Union[str, TimeseriesType]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.TimeseriesType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + LATENCY_P50 = "LatencyP50" + LATENCY_P75 = "LatencyP75" + LATENCY_P95 = "LatencyP95" + MEASUREMENT_COUNTS = "MeasurementCounts" + + + class azure.mgmt.frontdoor.models.Transform(str, Enum, metaclass=CaseInsensitiveEnumMeta): + LOWERCASE = "Lowercase" + REMOVE_NULLS = "RemoveNulls" + TRIM = "Trim" + UPPERCASE = "Uppercase" + URL_DECODE = "UrlDecode" + URL_ENCODE = "UrlEncode" + + + class azure.mgmt.frontdoor.models.TransformType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + LOWERCASE = "Lowercase" + REMOVE_NULLS = "RemoveNulls" + TRIM = "Trim" + UPPERCASE = "Uppercase" + URL_DECODE = "UrlDecode" + URL_ENCODE = "UrlEncode" + + + class azure.mgmt.frontdoor.models.ValidateCustomDomainInput(_Model): + host_name: str + + @overload + def __init__( + self, + *, + host_name: str + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.ValidateCustomDomainOutput(_Model): + custom_domain_validated: Optional[bool] + message: Optional[str] + reason: Optional[str] + + + class azure.mgmt.frontdoor.models.VariableName(str, Enum, metaclass=CaseInsensitiveEnumMeta): + GEO_LOCATION = "GeoLocation" + NONE = "None" + SOCKET_ADDR = "SocketAddr" + + + class azure.mgmt.frontdoor.models.WebApplicationFirewallPolicy(Resource): + etag: Optional[str] + id: str + location: str + name: str + properties: Optional[WebApplicationFirewallPolicyProperties] + sku: Optional[Sku] + tags: dict[str, str] + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + etag: Optional[str] = ..., + location: Optional[str] = ..., + properties: Optional[WebApplicationFirewallPolicyProperties] = ..., + sku: Optional[Sku] = ..., + 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.frontdoor.models.WebApplicationFirewallPolicyProperties(_Model): + custom_rules: Optional[CustomRuleList] + frontend_endpoint_links: Optional[list[FrontendEndpointLink]] + managed_rules: Optional[ManagedRuleSetList] + policy_settings: Optional[PolicySettings] + provisioning_state: Optional[str] + resource_state: Optional[Union[str, PolicyResourceState]] + routing_rule_links: Optional[list[RoutingRuleLink]] + security_policy_links: Optional[list[SecurityPolicyLink]] + + @overload + def __init__( + self, + *, + custom_rules: Optional[CustomRuleList] = ..., + managed_rules: Optional[ManagedRuleSetList] = ..., + policy_settings: Optional[PolicySettings] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.WebApplicationFirewallScrubbingRules(_Model): + match_variable: Union[str, ScrubbingRuleEntryMatchVariable] + selector: Optional[str] + selector_match_operator: Union[str, ScrubbingRuleEntryMatchOperator] + state: Optional[Union[str, ScrubbingRuleEntryState]] + + @overload + def __init__( + self, + *, + match_variable: Union[str, ScrubbingRuleEntryMatchVariable], + selector: Optional[str] = ..., + selector_match_operator: Union[str, ScrubbingRuleEntryMatchOperator], + state: Optional[Union[str, ScrubbingRuleEntryState]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.frontdoor.models.WebApplicationFirewallScrubbingState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + + +namespace azure.mgmt.frontdoor.operations + + class azure.mgmt.frontdoor.operations.EndpointsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_purge_content( + self, + resource_group_name: str, + front_door_name: str, + content_file_paths: PurgeParameters, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[None]: ... + + @overload + def begin_purge_content( + self, + resource_group_name: str, + front_door_name: str, + content_file_paths: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[None]: ... + + @overload + def begin_purge_content( + self, + resource_group_name: str, + front_door_name: str, + content_file_paths: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[None]: ... + + + class azure.mgmt.frontdoor.operations.ExperimentsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + parameters: Experiment, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[Experiment]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[Experiment]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[Experiment]: ... + + @distributed_trace + def begin_delete( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + **kwargs: Any + ) -> LROPoller[None]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + parameters: ExperimentUpdateModel, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[Experiment]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[Experiment]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[Experiment]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + **kwargs: Any + ) -> Experiment: ... + + @distributed_trace + def list_by_profile( + self, + resource_group_name: str, + profile_name: str, + **kwargs: Any + ) -> ItemPaged[Experiment]: ... + + + class azure.mgmt.frontdoor.operations.FrontDoorNameAvailabilityOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def check( + self, + check_front_door_name_availability_input: CheckNameAvailabilityInput, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + @overload + def check( + self, + check_front_door_name_availability_input: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + @overload + def check( + self, + check_front_door_name_availability_input: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + + class azure.mgmt.frontdoor.operations.FrontDoorNameAvailabilityWithSubscriptionOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def check( + self, + check_front_door_name_availability_input: CheckNameAvailabilityInput, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + @overload + def check( + self, + check_front_door_name_availability_input: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + @overload + def check( + self, + check_front_door_name_availability_input: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + + class azure.mgmt.frontdoor.operations.FrontDoorsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + front_door_name: str, + front_door_parameters: FrontDoor, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[FrontDoor]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + front_door_name: str, + front_door_parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[FrontDoor]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + front_door_name: str, + front_door_parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[FrontDoor]: ... + + @distributed_trace + def begin_delete( + self, + resource_group_name: str, + front_door_name: str, + **kwargs: Any + ) -> LROPoller[None]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + front_door_name: str, + **kwargs: Any + ) -> FrontDoor: ... + + @distributed_trace + def list(self, **kwargs: Any) -> ItemPaged[FrontDoor]: ... + + @distributed_trace + def list_by_resource_group( + self, + resource_group_name: str, + **kwargs: Any + ) -> ItemPaged[FrontDoor]: ... + + @overload + def validate_custom_domain( + self, + resource_group_name: str, + front_door_name: str, + custom_domain_properties: ValidateCustomDomainInput, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> ValidateCustomDomainOutput: ... + + @overload + def validate_custom_domain( + self, + resource_group_name: str, + front_door_name: str, + custom_domain_properties: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> ValidateCustomDomainOutput: ... + + @overload + def validate_custom_domain( + self, + resource_group_name: str, + front_door_name: str, + custom_domain_properties: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> ValidateCustomDomainOutput: ... + + + class azure.mgmt.frontdoor.operations.FrontendEndpointsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def begin_disable_https( + self, + resource_group_name: str, + front_door_name: str, + frontend_endpoint_name: str, + **kwargs: Any + ) -> LROPoller[None]: ... + + @overload + def begin_enable_https( + self, + resource_group_name: str, + front_door_name: str, + frontend_endpoint_name: str, + custom_https_configuration: CustomHttpsConfiguration, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[None]: ... + + @overload + def begin_enable_https( + self, + resource_group_name: str, + front_door_name: str, + frontend_endpoint_name: str, + custom_https_configuration: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[None]: ... + + @overload + def begin_enable_https( + self, + resource_group_name: str, + front_door_name: str, + frontend_endpoint_name: str, + custom_https_configuration: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[None]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + front_door_name: str, + frontend_endpoint_name: str, + **kwargs: Any + ) -> FrontendEndpoint: ... + + @distributed_trace + def list_by_front_door( + self, + resource_group_name: str, + front_door_name: str, + **kwargs: Any + ) -> ItemPaged[FrontendEndpoint]: ... + + + class azure.mgmt.frontdoor.operations.ManagedRuleSetsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list(self, **kwargs: Any) -> ItemPaged[ManagedRuleSetDefinition]: ... + + + class azure.mgmt.frontdoor.operations.NetworkExperimentProfilesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + profile_name: str, + resource_group_name: str, + parameters: Profile, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[Profile]: ... + + @overload + def begin_create_or_update( + self, + profile_name: str, + resource_group_name: str, + parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[Profile]: ... + + @overload + def begin_create_or_update( + self, + profile_name: str, + resource_group_name: str, + parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[Profile]: ... + + @distributed_trace + def begin_delete( + self, + resource_group_name: str, + profile_name: str, + **kwargs: Any + ) -> LROPoller[None]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + profile_name: str, + parameters: ProfileUpdateModel, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[Profile]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + profile_name: str, + parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[Profile]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + profile_name: str, + parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[Profile]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + profile_name: str, + **kwargs: Any + ) -> Profile: ... + + @distributed_trace + def list(self, **kwargs: Any) -> ItemPaged[Profile]: ... + + @distributed_trace + def list_by_resource_group( + self, + resource_group_name: str, + **kwargs: Any + ) -> ItemPaged[Profile]: ... + + + class azure.mgmt.frontdoor.operations.PoliciesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + policy_name: str, + parameters: WebApplicationFirewallPolicy, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[WebApplicationFirewallPolicy]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + policy_name: str, + parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[WebApplicationFirewallPolicy]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + policy_name: str, + parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[WebApplicationFirewallPolicy]: ... + + @distributed_trace + def begin_delete( + self, + resource_group_name: str, + policy_name: str, + **kwargs: Any + ) -> LROPoller[None]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + policy_name: str, + parameters: TagsObject, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[WebApplicationFirewallPolicy]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + policy_name: str, + parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[WebApplicationFirewallPolicy]: ... + + @overload + def begin_update( + self, + resource_group_name: str, + policy_name: str, + parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[WebApplicationFirewallPolicy]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + policy_name: str, + **kwargs: Any + ) -> WebApplicationFirewallPolicy: ... + + @distributed_trace + def list( + self, + resource_group_name: str, + **kwargs: Any + ) -> ItemPaged[WebApplicationFirewallPolicy]: ... + + @distributed_trace + def list_by_subscription(self, **kwargs: Any) -> ItemPaged[WebApplicationFirewallPolicy]: ... + + + class azure.mgmt.frontdoor.operations.PreconfiguredEndpointsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list( + self, + resource_group_name: str, + profile_name: str, + **kwargs: Any + ) -> ItemPaged[PreconfiguredEndpoint]: ... + + + class azure.mgmt.frontdoor.operations.ReportsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def get_latency_scorecards( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + *, + aggregation_interval: Union[str, LatencyScorecardAggregationInterval], + country: Optional[str] = ..., + end_date_time_utc: Optional[str] = ..., + **kwargs: Any + ) -> LatencyScorecard: ... + + @distributed_trace + def get_timeseries( + self, + resource_group_name: str, + profile_name: str, + experiment_name: str, + *, + aggregation_interval: Union[str, TimeseriesAggregationInterval], + country: Optional[str] = ..., + end_date_time_utc: datetime, + endpoint: Optional[str] = ..., + start_date_time_utc: datetime, + timeseries_type: Union[str, TimeseriesType], + **kwargs: Any + ) -> Timeseries: ... + + + class azure.mgmt.frontdoor.operations.RulesEnginesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + front_door_name: str, + rules_engine_name: str, + rules_engine_parameters: RulesEngine, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[RulesEngine]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + front_door_name: str, + rules_engine_name: str, + rules_engine_parameters: JSON, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[RulesEngine]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + front_door_name: str, + rules_engine_name: str, + rules_engine_parameters: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[RulesEngine]: ... + + @distributed_trace + def begin_delete( + self, + resource_group_name: str, + front_door_name: str, + rules_engine_name: str, + **kwargs: Any + ) -> LROPoller[None]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + front_door_name: str, + rules_engine_name: str, + **kwargs: Any + ) -> RulesEngine: ... + + @distributed_trace + def list_by_front_door( + self, + resource_group_name: str, + front_door_name: str, + **kwargs: Any + ) -> ItemPaged[RulesEngine]: ... + + +``` \ No newline at end of file diff --git a/sdk/network/azure-mgmt-frontdoor/api.metadata.yml b/sdk/network/azure-mgmt-frontdoor/api.metadata.yml new file mode 100644 index 000000000000..591f53409073 --- /dev/null +++ b/sdk/network/azure-mgmt-frontdoor/api.metadata.yml @@ -0,0 +1,3 @@ +apiMdSha256: 36b6ae1a14155bec514c286c2a23f098adb9eca1fb6c493f783a72b7a0292412 +parserVersion: 0.3.28 +pythonVersion: 3.13.13 diff --git a/sdk/network/azure-mgmt-frontdoor/apiview-properties.json b/sdk/network/azure-mgmt-frontdoor/apiview-properties.json index fc5231820b80..55584b0f5604 100644 --- a/sdk/network/azure-mgmt-frontdoor/apiview-properties.json +++ b/sdk/network/azure-mgmt-frontdoor/apiview-properties.json @@ -223,5 +223,6 @@ "azure.mgmt.frontdoor.aio.operations.FrontDoorNameAvailabilityOperations.check": "Microsoft.Network.FrontDoorNameAvailabilityOperationGroup.check", "azure.mgmt.frontdoor.operations.FrontDoorNameAvailabilityWithSubscriptionOperations.check": "Microsoft.Network.FrontDoorNameAvailabilityWithSubscriptionOperationGroup.check", "azure.mgmt.frontdoor.aio.operations.FrontDoorNameAvailabilityWithSubscriptionOperations.check": "Microsoft.Network.FrontDoorNameAvailabilityWithSubscriptionOperationGroup.check" - } + }, + "CrossLanguageVersion": "b4a622d256e5" } \ No newline at end of file diff --git a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_client.py b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_client.py index 1516f40e2491..358f583f496f 100644 --- a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_client.py +++ b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_client.py @@ -7,8 +7,8 @@ # -------------------------------------------------------------------------- from copy import deepcopy +import sys from typing import Any, Optional, TYPE_CHECKING, cast -from typing_extensions import Self from azure.core.pipeline import policies from azure.core.rest import HttpRequest, HttpResponse @@ -34,6 +34,11 @@ RulesEnginesOperations, ) +if sys.version_info >= (3, 11): + from typing import Self +else: + from typing_extensions import Self # type: ignore + if TYPE_CHECKING: from azure.core import AzureClouds from azure.core.credentials import TokenCredential @@ -81,8 +86,8 @@ class FrontDoorManagementClient: # pylint: disable=too-many-instance-attributes None. :paramtype cloud_setting: ~azure.core.AzureClouds :keyword api_version: The API version to use for this operation. Known values are "2025-10-01" - and None. Default value is "2025-10-01". Note that overriding this default value may result in - unsupported behavior. + 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. diff --git a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_configuration.py b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_configuration.py index 753e2ad52f20..0180ede7e61e 100644 --- a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_configuration.py +++ b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_configuration.py @@ -34,8 +34,8 @@ class FrontDoorManagementClientConfiguration: # pylint: disable=too-many-instan None. :type cloud_setting: ~azure.core.AzureClouds :keyword api_version: The API version to use for this operation. Known values are "2025-10-01" - and None. Default value is "2025-10-01". Note that overriding this default value may result in - unsupported behavior. + 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 """ diff --git a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_utils/model_base.py b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_utils/model_base.py index 7b7f8ba67b53..b93f5120d517 100644 --- a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_utils/model_base.py +++ b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_utils/model_base.py @@ -23,14 +23,19 @@ from json import JSONEncoder import xml.etree.ElementTree as ET from collections.abc import MutableMapping -from typing_extensions import Self import isodate from azure.core.exceptions import DeserializationError from azure.core import CaseInsensitiveEnumMeta from azure.core.pipeline import PipelineResponse from azure.core.serialization import _Null + from azure.core.rest import HttpResponse +if sys.version_info >= (3, 11): + from typing import Self +else: + from typing_extensions import Self + _LOGGER = logging.getLogger(__name__) __all__ = ["SdkJSONEncoder", "Model", "rest_field", "rest_discriminator"] @@ -104,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": @@ -296,6 +324,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 @@ -325,6 +359,10 @@ 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"), } @@ -559,7 +597,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 @@ -585,6 +623,239 @@ def _create_value(rf: typing.Optional["_RestField"], value: typing.Any) -> typin return _serialize(value, rf._format) +# ============================================================================ +# Fast-path scalar deserializer functions for rest_field(deserializer=...) +# These are referenced from rest_field declarations to bypass the generic +# _deserialize -> _deserialize_with_callable chain. +# Only simple/primitive types — no models or container types. +# ============================================================================ + + +def _xml_deser_str(value): + if isinstance(value, ET.Element): + return value.text or "" + return str(value) if value is not None else None + + +def _xml_deser_int(value): + if isinstance(value, ET.Element): + return int(value.text) if value.text else None + return int(value) if value is not None else None + + +def _xml_deser_float(value): + if isinstance(value, ET.Element): + return float(value.text) if value.text else None + return float(value) if value is not None else None + + +def _xml_deser_bool(value): + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + if text in (True, False): + return text + return text.lower() == "true" + + +# pylint: disable=docstring-missing-param +def _xml_deser_bytes(value): + """Deserialize bytes from XML (base64).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_bytes(text) + + +def _xml_deser_bytes_base64url(value): + """Deserialize bytes from XML (base64url).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_bytes_base64(text) + + +def _xml_deser_datetime(value): + """Deserialize a datetime from XML (ISO 8601 / rfc3339).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_datetime(text) + + +def _xml_deser_datetime_rfc7231(value): + """Deserialize a datetime from XML (RFC7231 format).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_datetime_rfc7231(text) + + +def _xml_deser_datetime_unix_timestamp(value): + """Deserialize a datetime from XML (Unix timestamp).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_datetime_unix_timestamp(float(text)) + + +def _xml_deser_date(value): + """Deserialize a date from XML (ISO 8601).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_date(text) + + +def _xml_deser_time(value): + """Deserialize a time from XML (ISO 8601).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_time(text) + + +def _xml_deser_duration(value): + """Deserialize a timedelta from XML (ISO 8601 duration).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_duration(text) + + +def _xml_deser_decimal(value): + """Deserialize a Decimal from XML.""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_decimal(text) + + +def _xml_deser_enum_or_str(enum_cls, value): + """Deserialize a Union[EnumType, str] from XML.""" + text = value.text if isinstance(value, ET.Element) else value + if text is None: + return None + try: + return enum_cls(text) + except ValueError: + return text + + +def _extract_xml_model_type(rf_type): + """Extract the concrete Model class from a resolved rf._type partial chain. + + Unwraps ``Optional[Model]`` and ``_deserialize_model(Model, ...)`` + wrappers. Only handles Model and Optional[Model] — other composite + types (List, Dict, Union, etc.) return None and fall through to the + generic ``_deserialize`` path at runtime. + """ + if rf_type is None: + return None + if isinstance(rf_type, type) and _is_model(rf_type): + return rf_type + if not isinstance(rf_type, functools.partial): + return None + func = rf_type.func + args = rf_type.args + if func is _deserialize_with_optional and args: + return _extract_xml_model_type(args[0]) + if func is _deserialize_model and args: + cls = args[0] + return cls if isinstance(cls, type) and _is_model(cls) else None + return None + + +def _build_xml_field_plan( # pylint: disable=docstring-missing-return, docstring-missing-rtype, unused-variable + cls, attr_to_rest_field: dict +) -> list: + """Build a precomputed XML field plan for fast _init_from_xml iteration. + + Called once per model class in __new__. Returns a list of tuples: + (rest_name, xml_name, kind, deser, rf_type, is_optional, items_name) + + kind: 0=wrapped, 1=attribute, 2=unwrapped, 3=text + + For Model and Optional[Model] fields that lack a scalar + ``_deserializer``, this function precomputes the Model class as the + deserializer so ``_init_from_xml`` can call ``ModelClass(element)`` + directly instead of going through the expensive + ``_get_deserialize_callable_from_annotation`` chain at runtime. + """ + model_meta = getattr(cls, "_xml", {}) + model_ns = model_meta.get("ns") or model_meta.get("namespace") + plan = [] + + for rf in attr_to_rest_field.values(): + prop_meta = getattr(rf, "_xml", {}) + deser = rf._deserializer + + xml_name = prop_meta.get("name", rf._rest_name) + xml_ns = _resolve_xml_ns(prop_meta, model_meta) + if xml_ns: + xml_name = "{" + xml_ns + "}" + xml_name + + is_optional = rf._is_optional + + # For Model / Optional[Model] fields without a scalar deserializer, + # precompute the Model class as the deserializer. + if deser is None and rf._type is not None: + model_cls = _extract_xml_model_type(rf._type) + if model_cls is not None: + deser = model_cls + + if prop_meta.get("attribute", False): + plan.append((rf._rest_name, xml_name, 1, deser, rf._type, is_optional, None)) + elif prop_meta.get("unwrapped", False): + items_name = prop_meta.get("itemsName") + if items_name: + items_ns = prop_meta.get("itemsNs") + if items_ns is not None: + xml_ns = items_ns + if xml_ns: + items_name = "{" + xml_ns + "}" + items_name + else: + items_name = xml_name + plan.append((rf._rest_name, xml_name, 2, deser, rf._type, is_optional, items_name)) + elif prop_meta.get("text", False): + plan.append((rf._rest_name, xml_name, 3, deser, rf._type, is_optional, None)) + else: + plan.append((rf._rest_name, xml_name, 0, deser, rf._type, is_optional, None)) + + return plan + + +# pylint: enable=docstring-missing-param class Model(_MyMutableMapping): _is_model = True # label whether current class's _attr_to_rest_field has been calculated @@ -595,62 +866,10 @@ def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None: class_name = self.__class__.__name__ if len(args) > 1: raise TypeError(f"{class_name}.__init__() takes 2 positional arguments but {len(args) + 1} were given") - dict_to_pass = { - rest_field._rest_name: rest_field._default - for rest_field in self._attr_to_rest_field.values() - if rest_field._default is not _UNSET - } - if args: # pylint: disable=too-many-nested-blocks + dict_to_pass: dict[str, typing.Any] = {} + if args: if isinstance(args[0], ET.Element): - existed_attr_keys = [] - model_meta = getattr(self, "_xml", {}) - - for rf in self._attr_to_rest_field.values(): - prop_meta = getattr(rf, "_xml", {}) - xml_name = prop_meta.get("name", rf._rest_name) - xml_ns = prop_meta.get("ns", model_meta.get("ns", None)) - if xml_ns: - xml_name = "{" + xml_ns + "}" + xml_name - - # attribute - if prop_meta.get("attribute", False) and args[0].get(xml_name) is not None: - existed_attr_keys.append(xml_name) - dict_to_pass[rf._rest_name] = _deserialize(rf._type, args[0].get(xml_name)) - continue - - # unwrapped element is array - if prop_meta.get("unwrapped", False): - # unwrapped array could either use prop items meta/prop meta - if prop_meta.get("itemsName"): - xml_name = prop_meta.get("itemsName") - xml_ns = prop_meta.get("itemNs") - if xml_ns: - xml_name = "{" + xml_ns + "}" + xml_name - items = args[0].findall(xml_name) # pyright: ignore - if len(items) > 0: - existed_attr_keys.append(xml_name) - dict_to_pass[rf._rest_name] = _deserialize(rf._type, items) - elif not rf._is_optional: - existed_attr_keys.append(xml_name) - dict_to_pass[rf._rest_name] = [] - continue - - # text element is primitive type - if prop_meta.get("text", False): - if args[0].text is not None: - dict_to_pass[rf._rest_name] = _deserialize(rf._type, args[0].text) - continue - - # wrapped element could be normal property or array, it should only have one element - item = args[0].find(xml_name) - if item is not None: - existed_attr_keys.append(xml_name) - dict_to_pass[rf._rest_name] = _deserialize(rf._type, item) - - # rest thing is additional properties - for e in args[0]: - if e.tag not in existed_attr_keys: - dict_to_pass[e.tag] = _convert_element(e) + dict_to_pass.update(self._init_from_xml(args[0])) else: dict_to_pass.update( {k: _create_value(_get_rest_field(self._attr_to_rest_field, k), v) for k, v in args[0].items()} @@ -667,8 +886,117 @@ def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None: if v is not None } ) + # Apply client default values for fields the caller didn't set so that + # defaults are part of `_data` and therefore included during serialization. + for rf in self._attr_to_rest_field.values(): + if rf._default is _UNSET: + continue + if rf._rest_name in dict_to_pass: + continue + dict_to_pass[rf._rest_name] = _create_value(rf, rf._default) super().__init__(dict_to_pass) + def _init_from_xml( # pylint: disable=too-many-branches, too-many-statements + self, element: ET.Element + ) -> dict[str, typing.Any]: + """Deserialize an XML element into a dict mapping rest field names to values. + + :param ET.Element element: The XML element to deserialize from. + :returns: A dictionary of rest_name to deserialized value pairs. + :rtype: dict + """ + result: dict[str, typing.Any] = {} + existed_attr_keys: list[str] = [] + + field_plan = getattr(self, "_xml_field_plan", None) + if field_plan: + for rest_name, xml_name, kind, deser, rf_type, is_optional, items_name in field_plan: + if kind == 0: # wrapped element (most common) + item = element.find(xml_name) + if item is not None: + existed_attr_keys.append(xml_name) + if deser: + result[rest_name] = deser(item) + else: + result[rest_name] = _deserialize(rf_type, item) + elif kind == 1: # attribute + attr_val = element.get(xml_name) + if attr_val is not None: + existed_attr_keys.append(xml_name) + if deser: + result[rest_name] = deser(attr_val) + else: + result[rest_name] = attr_val + elif kind == 2: # unwrapped array + items = element.findall(items_name) # pyright: ignore + if len(items) > 0: + existed_attr_keys.append(items_name) + if deser: + result[rest_name] = deser(items) + else: + result[rest_name] = _deserialize(rf_type, items) + elif not is_optional: + existed_attr_keys.append(items_name) + result[rest_name] = [] + elif kind == 3: # text + if element.text is not None: + if deser: + result[rest_name] = deser(element.text) + else: + result[rest_name] = element.text + else: + model_meta = getattr(self, "_xml", {}) + for rf in self._attr_to_rest_field.values(): + prop_meta = getattr(rf, "_xml", {}) + xml_name = prop_meta.get("name", rf._rest_name) + xml_ns = _resolve_xml_ns(prop_meta, model_meta) + if xml_ns: + xml_name = "{" + xml_ns + "}" + xml_name + + # attribute + if prop_meta.get("attribute", False) and element.get(xml_name) is not None: + existed_attr_keys.append(xml_name) + result[rf._rest_name] = _deserialize(rf._type, element.get(xml_name)) + continue + + # unwrapped element is array + if prop_meta.get("unwrapped", False): + _items_name = prop_meta.get("itemsName") + if _items_name: + xml_name = _items_name + _items_ns = prop_meta.get("itemsNs") + if _items_ns is not None: + xml_ns = _items_ns + if xml_ns: + xml_name = "{" + xml_ns + "}" + xml_name + items = element.findall(xml_name) # pyright: ignore + if len(items) > 0: + existed_attr_keys.append(xml_name) + result[rf._rest_name] = _deserialize(rf._type, items) + elif not rf._is_optional: + existed_attr_keys.append(xml_name) + result[rf._rest_name] = [] + continue + + # text element is primitive type + if prop_meta.get("text", False): + if element.text is not None: + result[rf._rest_name] = _deserialize(rf._type, element.text) + continue + + # wrapped element could be normal property or array + item = element.find(xml_name) + if item is not None: + existed_attr_keys.append(xml_name) + result[rf._rest_name] = _deserialize(rf._type, item) + + # rest thing is additional properties + for e in element: + if e.tag not in existed_attr_keys: + result[e.tag] = _convert_element(e) + + return result + def copy(self) -> "Model": return Model(self.__dict__) @@ -693,6 +1021,9 @@ def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> Self: if not rf._rest_name_input: rf._rest_name_input = attr cls._attr_to_rest_field: dict[str, _RestField] = dict(attr_to_rest_field.items()) + # Build XML field plan for fast _init_from_xml (only for XML models) + if getattr(cls, "_xml", None): + cls._xml_field_plan = _build_xml_field_plan(cls, attr_to_rest_field) cls._calculated.add(f"{cls.__module__}.{cls.__qualname__}") return super().__new__(cls) @@ -721,7 +1052,7 @@ def _deserialize(cls, data, exist_discriminators): model_meta = getattr(cls, "_xml", {}) prop_meta = getattr(discriminator, "_xml", {}) xml_name = prop_meta.get("name", discriminator._rest_name) - xml_ns = prop_meta.get("ns", model_meta.get("ns", None)) + xml_ns = _resolve_xml_ns(prop_meta, model_meta) if xml_ns: xml_name = "{" + xml_ns + "}" + xml_name @@ -1067,6 +1398,7 @@ def __init__( format: typing.Optional[str] = None, is_multipart_file_input: bool = False, xml: typing.Optional[dict[str, typing.Any]] = None, + deserializer: typing.Optional[typing.Callable] = None, ): self._type = type self._rest_name_input = name @@ -1079,6 +1411,7 @@ def __init__( self._format = format self._is_multipart_file_input = is_multipart_file_input self._xml = xml if xml is not None else {} + self._deserializer = deserializer @property def _class_type(self) -> typing.Any: @@ -1098,7 +1431,10 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin # by this point, type and rest_name will have a value bc we default # them in __new__ of the Model class # Use _data.get() directly to avoid triggering __getitem__ which clears the cache - item = obj._data.get(self._rest_name) + item = obj._data.get(self._rest_name, _UNSET) + if item is _UNSET: + # Field not set by user; return the client default if one exists, otherwise None + return self._default if self._default is not _UNSET else None if item is None: return item if self._is_model: @@ -1111,7 +1447,11 @@ def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin # Return the value from _data directly (it's been deserialized in place) return obj._data.get(self._rest_name) - deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + # Fast path: use _deserializer directly (avoids _serialize/_deserialize chain) + if self._deserializer: + deserialized = self._deserializer(item) + else: + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) # For mutable types, store the deserialized value back in _data # so mutations directly affect _data @@ -1157,6 +1497,7 @@ def rest_field( format: typing.Optional[str] = None, is_multipart_file_input: bool = False, xml: typing.Optional[dict[str, typing.Any]] = None, + deserializer: typing.Optional[typing.Callable] = None, ) -> typing.Any: return _RestField( name=name, @@ -1166,6 +1507,7 @@ def rest_field( format=format, is_multipart_file_input=is_multipart_file_input, xml=xml, + deserializer=deserializer, ) @@ -1190,6 +1532,56 @@ def serialize_xml(model: Model, exclude_readonly: bool = False) -> str: return ET.tostring(_get_element(model, exclude_readonly), encoding="unicode") # type: ignore +def _get_xml_ns(meta: dict[str, typing.Any]) -> typing.Optional[str]: + """Return the XML namespace from a metadata dict, checking both 'ns' (old-style) and 'namespace' (DPG) keys. + + :param dict meta: The metadata dictionary to extract namespace from. + :returns: The namespace string if 'ns' or 'namespace' key is present, None otherwise. + :rtype: str or None + """ + ns = meta.get("ns") + if ns is None: + ns = meta.get("namespace") + return ns + + +def _resolve_xml_ns( + prop_meta: dict[str, typing.Any], model_meta: typing.Optional[dict[str, typing.Any]] = None +) -> typing.Optional[str]: + """Resolve XML namespace for a property, falling back to model namespace when appropriate. + + Checks the property metadata first; if no namespace is found and the model does not declare + an explicit prefix, falls back to the model-level namespace. + + :param dict prop_meta: The property metadata dictionary. + :param dict model_meta: The model metadata dictionary, used as fallback. + :returns: The resolved namespace string, or None. + :rtype: str or None + """ + ns = _get_xml_ns(prop_meta) + if ns is None and model_meta is not None and not model_meta.get("prefix"): + ns = _get_xml_ns(model_meta) + return ns + + +def _set_xml_attribute(element: ET.Element, name: str, value: typing.Any, prop_meta: dict[str, typing.Any]) -> None: + """Set an XML attribute on an element, handling namespace prefix registration. + + :param ET.Element element: The element to set the attribute on. + :param str name: The default attribute name (wire name). + :param any value: The attribute value. + :param dict prop_meta: The property metadata dictionary. + """ + xml_name = prop_meta.get("name", name) + _attr_ns = _get_xml_ns(prop_meta) + if _attr_ns: + _attr_prefix = prop_meta.get("prefix") + if _attr_prefix: + _safe_register_namespace(_attr_prefix, _attr_ns) + xml_name = "{" + _attr_ns + "}" + xml_name + element.set(xml_name, _get_primitive_type_value(value)) + + def _get_element( o: typing.Any, exclude_readonly: bool = False, @@ -1201,10 +1593,16 @@ def _get_element( # if prop is a model, then use the prop element directly, else generate a wrapper of model if wrapped_element is None: + # When serializing as an array item (parent_meta is set), check if the parent has an + # explicit itemsName. This ensures correct element names for unwrapped arrays (where + # the element tag is the property/items name, not the model type name). + _items_name = parent_meta.get("itemsName") if parent_meta is not None else None + element_name = _items_name if _items_name else (model_meta.get("name") or o.__class__.__name__) + _model_ns = _get_xml_ns(model_meta) wrapped_element = _create_xml_element( - model_meta.get("name", o.__class__.__name__), + element_name, model_meta.get("prefix"), - model_meta.get("ns"), + _model_ns, ) readonly_props = [] @@ -1226,7 +1624,9 @@ def _get_element( # additional properties will not have rest field, use the wire name as xml name prop_meta = {"name": k} - # if no ns for prop, use model's + # Propagate model namespace to properties only for old-style "ns"-keyed models. + # DPG-generated models use the "namespace" key and explicitly declare namespace on + # each property that needs it, so propagation is intentionally skipped for them. if prop_meta.get("ns") is None and model_meta.get("ns"): prop_meta["ns"] = model_meta.get("ns") prop_meta["prefix"] = model_meta.get("prefix") @@ -1238,12 +1638,7 @@ def _get_element( # text could only set on primitive type wrapped_element.text = _get_primitive_type_value(v) elif prop_meta.get("attribute", False): - xml_name = prop_meta.get("name", k) - if prop_meta.get("ns"): - ET.register_namespace(prop_meta.get("prefix"), prop_meta.get("ns")) # pyright: ignore - xml_name = "{" + prop_meta.get("ns") + "}" + xml_name # pyright: ignore - # attribute should be primitive type - wrapped_element.set(xml_name, _get_primitive_type_value(v)) + _set_xml_attribute(wrapped_element, k, v, prop_meta) else: # other wrapped prop element wrapped_element.append(_get_wrapped_element(v, exclude_readonly, prop_meta)) @@ -1252,6 +1647,7 @@ def _get_element( return [_get_element(x, exclude_readonly, parent_meta) for x in o] # type: ignore if isinstance(o, dict): result = [] + _dict_ns = _get_xml_ns(parent_meta) if parent_meta else None for k, v in o.items(): result.append( _get_wrapped_element( @@ -1259,7 +1655,7 @@ def _get_element( exclude_readonly, { "name": k, - "ns": parent_meta.get("ns") if parent_meta else None, + "ns": _dict_ns, "prefix": parent_meta.get("prefix") if parent_meta else None, }, ) @@ -1268,13 +1664,16 @@ def _get_element( # primitive case need to create element based on parent_meta if parent_meta: + _items_ns = parent_meta.get("itemsNs") + if _items_ns is None: + _items_ns = _get_xml_ns(parent_meta) return _get_wrapped_element( o, exclude_readonly, { "name": parent_meta.get("itemsName", parent_meta.get("name")), "prefix": parent_meta.get("itemsPrefix", parent_meta.get("prefix")), - "ns": parent_meta.get("itemsNs", parent_meta.get("ns")), + "ns": _items_ns, }, ) @@ -1286,8 +1685,9 @@ def _get_wrapped_element( exclude_readonly: bool, meta: typing.Optional[dict[str, typing.Any]], ) -> ET.Element: + _meta_ns = _get_xml_ns(meta) if meta else None wrapped_element = _create_xml_element( - meta.get("name") if meta else None, meta.get("prefix") if meta else None, meta.get("ns") if meta else None + meta.get("name") if meta else None, meta.get("prefix") if meta else None, _meta_ns ) if isinstance(v, (dict, list)): wrapped_element.extend(_get_element(v, exclude_readonly, meta)) @@ -1308,11 +1708,29 @@ def _get_primitive_type_value(v) -> str: return str(v) +def _safe_register_namespace(prefix: str, ns: str) -> None: + """Register an XML namespace prefix, handling reserved prefix patterns. + + Some prefixes (e.g. 'ns2') match Python's reserved 'ns\\d+' pattern used for + auto-generated prefixes, causing register_namespace to raise ValueError. + Falls back to directly registering in the internal namespace map. + + :param str prefix: The namespace prefix to register. + :param str ns: The namespace URI. + """ + try: + ET.register_namespace(prefix, ns) + except ValueError: + _ns_map = getattr(ET, "_namespace_map", None) + if _ns_map is not None: + _ns_map[ns] = prefix + + def _create_xml_element( tag: typing.Any, prefix: typing.Optional[str] = None, ns: typing.Optional[str] = None ) -> ET.Element: if prefix and ns: - ET.register_namespace(prefix, ns) + _safe_register_namespace(prefix, ns) if ns: return ET.Element("{" + ns + "}" + tag) return ET.Element(tag) @@ -1323,6 +1741,8 @@ def _deserialize_xml( value: str, ) -> typing.Any: element = ET.fromstring(value) # nosec + if _is_model(deserializer): + return deserializer._deserialize(element, []) return _deserialize(deserializer, element) diff --git a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_utils/serialization.py b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_utils/serialization.py index 81ec1de5922b..75906e2eb77f 100644 --- a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_utils/serialization.py +++ b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_utils/serialization.py @@ -39,11 +39,15 @@ import xml.etree.ElementTree as ET import isodate # type: ignore -from typing_extensions import Self from azure.core.exceptions import DeserializationError, SerializationError from azure.core.serialization import NULL as CoreNull +if sys.version_info >= (3, 11): + from typing import Self +else: + from typing_extensions import Self + _BOM = codecs.BOM_UTF8.decode(encoding="utf-8") JSON = MutableMapping[str, Any] @@ -516,6 +520,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, @@ -1105,6 +1113,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. @@ -1377,6 +1440,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, @@ -1389,6 +1456,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 {} @@ -1401,7 +1472,7 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: # Otherwise, result are unexpected self.additional_properties_detection = True - def __call__(self, target_obj, response_data, content_type=None): + def __call__(self, target_obj, response_data, content_type=None): # pylint: disable=too-many-return-statements """Call the deserializer to process a REST response. :param str target_obj: Target data type to deserialize to. @@ -1411,6 +1482,27 @@ def __call__(self, target_obj, response_data, content_type=None): :return: Deserialized object. :rtype: object """ + # Fast path for header deserialization: response_data is a plain str or None + # and target_obj is a simple scalar type. This avoids the expensive + # _unpack_content → _deserialize → _classify_target → deserialize_data chain. + if response_data is None: + return None + if target_obj == "str" and isinstance(response_data, str): + return response_data + if isinstance(response_data, str): + if target_obj == "int": + return int(response_data) + if target_obj == "bool": + if response_data in ("true", "1", "True"): + return True + if response_data in ("false", "0", "False"): + return False + return bool(response_data) + if target_obj == "rfc-1123": + return Deserializer.deserialize_rfc(response_data) + if target_obj == "bytearray": + return Deserializer.deserialize_bytearray(response_data) + data = self._unpack_content(response_data, content_type) return self._deserialize(target_obj, data) @@ -1929,6 +2021,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/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_version.py b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_version.py index 0e00a6283246..8f2350dd3b0c 100644 --- a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_version.py +++ b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "2.0.0b1" +VERSION = "2.0.0" diff --git a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/aio/_client.py b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/aio/_client.py index d7448fd196c2..c0b36566e517 100644 --- a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/aio/_client.py +++ b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/aio/_client.py @@ -7,8 +7,8 @@ # -------------------------------------------------------------------------- from copy import deepcopy +import sys from typing import Any, Awaitable, Optional, TYPE_CHECKING, cast -from typing_extensions import Self from azure.core.pipeline import policies from azure.core.rest import AsyncHttpResponse, HttpRequest @@ -34,6 +34,11 @@ RulesEnginesOperations, ) +if sys.version_info >= (3, 11): + from typing import Self +else: + from typing_extensions import Self # type: ignore + if TYPE_CHECKING: from azure.core import AzureClouds from azure.core.credentials_async import AsyncTokenCredential @@ -81,8 +86,8 @@ class FrontDoorManagementClient: # pylint: disable=too-many-instance-attributes None. :paramtype cloud_setting: ~azure.core.AzureClouds :keyword api_version: The API version to use for this operation. Known values are "2025-10-01" - and None. Default value is "2025-10-01". Note that overriding this default value may result in - unsupported behavior. + 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. diff --git a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/aio/_configuration.py b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/aio/_configuration.py index f0d8006bba20..cd39230ea495 100644 --- a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/aio/_configuration.py +++ b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/aio/_configuration.py @@ -34,8 +34,8 @@ class FrontDoorManagementClientConfiguration: # pylint: disable=too-many-instan None. :type cloud_setting: ~azure.core.AzureClouds :keyword api_version: The API version to use for this operation. Known values are "2025-10-01" - and None. Default value is "2025-10-01". Note that overriding this default value may result in - unsupported behavior. + 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 """ diff --git a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/aio/operations/_operations.py b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/aio/operations/_operations.py index 0423504f0c15..4519c017cf0e 100644 --- a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/aio/operations/_operations.py +++ b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/aio/operations/_operations.py @@ -594,7 +594,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -684,7 +687,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -1056,7 +1062,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -2019,7 +2028,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -2859,7 +2871,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -3649,7 +3664,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -3740,7 +3758,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -4785,7 +4806,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -4877,7 +4901,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -4997,7 +5024,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -5334,7 +5364,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( diff --git a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/operations/_operations.py b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/operations/_operations.py index 4fa80d1ff44c..4580648c0bc8 100644 --- a/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/operations/_operations.py +++ b/sdk/network/azure-mgmt-frontdoor/azure/mgmt/frontdoor/operations/_operations.py @@ -1631,7 +1631,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -1721,7 +1724,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -2093,7 +2099,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -3056,7 +3065,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -3896,7 +3908,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -4683,7 +4698,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -4773,7 +4791,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -5818,7 +5839,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -5910,7 +5934,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -6029,7 +6056,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( @@ -6365,7 +6395,10 @@ def prepare_request(next_link=None): ) _next_request_params["api-version"] = self._config.api_version _request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + "GET", + urllib.parse.urljoin(next_link, _parsed_next_link.path), + headers=_headers, + params=_next_request_params, ) path_format_arguments = { "endpoint": self._serialize.url( diff --git a/sdk/network/azure-mgmt-frontdoor/pyproject.toml b/sdk/network/azure-mgmt-frontdoor/pyproject.toml index 4d3a8f55fc55..bd004ab29cc5 100644 --- a/sdk/network/azure-mgmt-frontdoor/pyproject.toml +++ b/sdk/network/azure-mgmt-frontdoor/pyproject.toml @@ -13,17 +13,17 @@ authors = [ description = "Microsoft Azure Frontdoor 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", - "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", ] -requires-python = ">=3.9" +requires-python = ">=3.10" keywords = [ "azure", "azure sdk", @@ -78,7 +78,7 @@ verifytypes = false package_name = "azure-mgmt-frontdoor" package_pprint_name = "Front Door Service" package_doc_id = "" -is_stable = false +is_stable = true is_arm = true title = "FrontDoorManagementClient" package_nspkg = "azure-mgmt-nspkg" diff --git a/sdk/network/azure-mgmt-frontdoor/tsp-location.yaml b/sdk/network/azure-mgmt-frontdoor/tsp-location.yaml index 123e86a857a9..f66f59479c85 100644 --- a/sdk/network/azure-mgmt-frontdoor/tsp-location.yaml +++ b/sdk/network/azure-mgmt-frontdoor/tsp-location.yaml @@ -1,4 +1,4 @@ directory: specification/frontdoor/resource-manager/Microsoft.Network/FrontDoor -commit: 5809ccc0da6207fc5544876346664e5e4b8035b4 +commit: 12be16fab6dbfd11c55daefb35c28548f34c3f5c repo: Azure/azure-rest-api-specs additionalDirectories: