From 8458817ab0f68273a8f5edc299d5b2d94aa3c121 Mon Sep 17 00:00:00 2001 From: azure-sdk Date: Thu, 16 Jul 2026 19:16:50 +0000 Subject: [PATCH 1/3] Configurations: 'specification/search/resource-manager/Microsoft.Search/Search/tspconfig.yaml', SDK Release Type: beta, and CommitSHA: 'e75a07cd7ea1b2207190a362305db02b639715ec' in SpecRepo: 'https://github.com/Azure/azure-rest-api-specs' Pipeline run: https://dev.azure.com/azure-sdk/internal/_build/results?buildId=6573667 Refer to https://eng.ms/docs/products/azure-developer-experience/develop/sdk-release/sdk-release-prerequisites to prepare for SDK release. --- sdk/search/azure-mgmt-search/CHANGELOG.md | 14 + sdk/search/azure-mgmt-search/README.md | 6 +- sdk/search/azure-mgmt-search/_metadata.json | 9 +- sdk/search/azure-mgmt-search/api.md | 2331 +++++++++++++++++ sdk/search/azure-mgmt-search/api.metadata.yml | 3 + .../azure-mgmt-search/apiview-properties.json | 12 +- .../azure/mgmt/search/_client.py | 12 +- .../azure/mgmt/search/_configuration.py | 7 +- .../azure/mgmt/search/_utils/model_base.py | 585 ++++- .../azure/mgmt/search/_utils/serialization.py | 138 +- .../azure/mgmt/search/_version.py | 2 +- .../azure/mgmt/search/aio/_client.py | 12 +- .../azure/mgmt/search/aio/_configuration.py | 7 +- .../mgmt/search/aio/operations/_operations.py | 161 +- .../azure/mgmt/search/models/__init__.py | 6 +- .../azure/mgmt/search/models/_enums.py | 12 + .../azure/mgmt/search/models/_models.py | 39 +- .../mgmt/search/operations/_operations.py | 223 +- .../azure/mgmt/search/types.py | 877 +++++++ ..._or_update_shared_private_link_resource.py | 2 +- .../delete_private_endpoint_connection.py | 2 +- .../delete_shared_private_link_resource.py | 2 +- .../get_private_endpoint_connection.py | 2 +- .../generated_samples/get_quota_usage.py | 2 +- .../get_quota_usages_list.py | 2 +- .../get_shared_private_link_resource.py | 2 +- ...private_endpoint_connections_by_service.py | 2 +- ...hared_private_link_resources_by_service.py | 2 +- .../list_supported_private_link_resources.py | 2 +- ...k_security_perimeter_configurations_get.py | 2 +- ...erimeter_configurations_list_by_service.py | 2 +- ...rity_perimeter_configurations_reconcile.py | 2 +- .../search_check_name_availability.py | 2 +- .../search_create_or_update_service.py | 2 +- ...h_create_or_update_service_auth_options.py | 2 +- ...te_or_update_service_disable_local_auth.py | 2 +- ..._to_allow_access_from_private_endpoints.py | 2 +- ..._to_allow_access_from_public_custom_ips.py | 2 +- ...ccess_from_public_custom_ips_and_bypass.py | 2 +- ..._auto_generated_domain_name_label_scope.py | 54 + ..._or_update_service_with_cmk_enforcement.py | 2 +- ...r_update_service_with_data_exfiltration.py | 2 +- ..._create_or_update_service_with_identity.py | 2 +- ...reate_or_update_service_with_serverless.py | 2 +- ...vel_cmk_multi_tenant_federated_identity.py | 2 +- ...eate_or_update_with_knowledge_retrieval.py | 2 +- ...h_create_or_update_with_semantic_search.py | 2 +- .../search_create_query_key.py | 2 +- .../search_delete_query_key.py | 2 +- .../search_delete_service.py | 2 +- ...offerings.py => search_fetch_offerings.py} | 6 +- .../search_get_admin_keys.py | 2 +- .../generated_samples/search_get_service.py | 2 +- .../search_list_operations.py | 2 +- ...earch_list_query_keys_by_search_service.py | 2 +- .../search_list_services_by_resource_group.py | 2 +- .../search_list_services_by_subscription.py | 2 +- .../search_regenerate_admin_key.py | 2 +- .../search_update_service.py | 2 +- .../search_update_service_auth_options.py | 2 +- ...earch_update_service_disable_local_auth.py | 2 +- ..._to_allow_access_from_private_endpoints.py | 2 +- ..._to_allow_access_from_public_custom_ips.py | 2 +- ...ccess_from_public_custom_ips_and_bypass.py | 2 +- ...earch_update_service_to_remove_identity.py | 2 +- ...rch_update_service_with_cmk_enforcement.py | 2 +- ...h_update_service_with_data_exfiltration.py | 2 +- ...update_service_with_knowledge_retrieval.py | 2 +- ...rch_update_service_with_semantic_search.py | 2 +- .../search_update_service_with_sku.py | 2 +- .../update_private_endpoint_connection.py | 2 +- ...pgrade_search_service_to_latest_version.py | 2 +- ..._search_management_offerings_operations.py | 4 +- ...h_management_offerings_operations_async.py | 4 +- ...t_search_management_services_operations.py | 2 + ...ch_management_services_operations_async.py | 2 + sdk/search/azure-mgmt-search/pyproject.toml | 4 +- .../azure-mgmt-search/tsp-location.yaml | 2 +- 78 files changed, 4297 insertions(+), 339 deletions(-) create mode 100644 sdk/search/azure-mgmt-search/api.md create mode 100644 sdk/search/azure-mgmt-search/api.metadata.yml create mode 100644 sdk/search/azure-mgmt-search/azure/mgmt/search/types.py create mode 100644 sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_auto_generated_domain_name_label_scope.py rename sdk/search/azure-mgmt-search/generated_samples/{search_list_offerings.py => search_fetch_offerings.py} (89%) diff --git a/sdk/search/azure-mgmt-search/CHANGELOG.md b/sdk/search/azure-mgmt-search/CHANGELOG.md index b1e97868f059..420003d146bc 100644 --- a/sdk/search/azure-mgmt-search/CHANGELOG.md +++ b/sdk/search/azure-mgmt-search/CHANGELOG.md @@ -1,5 +1,19 @@ # Release History +## 10.0.0b2 (2026-07-16) + +### Features Added + + - Model `SearchServiceProperties` added property `auto_generated_domain_name_label_scope` + - Added enum `AutoGeneratedDomainNameLabelScope` + - Added model `OfferingsResult` + - Model `OfferingsOperations` added method `fetch` + +### Breaking Changes + + - Deleted or renamed model `OfferingsListResult` + - Deleted or renamed method `OfferingsOperations.list` + ## 10.0.0b1 (2026-03-27) ### Features Added diff --git a/sdk/search/azure-mgmt-search/README.md b/sdk/search/azure-mgmt-search/README.md index def7357bb27c..6ce544f61fb0 100644 --- a/sdk/search/azure-mgmt-search/README.md +++ b/sdk/search/azure-mgmt-search/README.md @@ -1,7 +1,7 @@ # Microsoft Azure SDK for Python This is the Microsoft Azure Search Management 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/search/azure-mgmt-search/_metadata.json b/sdk/search/azure-mgmt-search/_metadata.json index d8433d48a23d..a40d5477dba8 100644 --- a/sdk/search/azure-mgmt-search/_metadata.json +++ b/sdk/search/azure-mgmt-search/_metadata.json @@ -1,10 +1,11 @@ { - "apiVersion": "2026-03-01-preview", + "apiVersion": "2026-09-01-preview", "apiVersions": { - "Microsoft.Search": "2026-03-01-preview" + "Microsoft.Search": "2026-09-01-preview" }, - "commit": "f90ba8622a186403cc11d43b8977d6bfd8410742", + "commit": "e75a07cd7ea1b2207190a362305db02b639715ec", "repository_url": "https://github.com/Azure/azure-rest-api-specs", "typespec_src": "specification/search/resource-manager/Microsoft.Search/Search", - "emitterVersion": "0.61.2" + "emitterVersion": "0.63.3", + "httpClientPythonVersion": "^0.34.2" } \ No newline at end of file diff --git a/sdk/search/azure-mgmt-search/api.md b/sdk/search/azure-mgmt-search/api.md new file mode 100644 index 000000000000..b562379a9cf0 --- /dev/null +++ b/sdk/search/azure-mgmt-search/api.md @@ -0,0 +1,2331 @@ +```py +namespace azure.mgmt.search + + class azure.mgmt.search.SearchManagementClient(_SearchManagementClientOperationsMixin): implements ContextManager + admin_keys: AdminKeysOperations + network_security_perimeter_configurations: NetworkSecurityPerimeterConfigurationsOperations + offerings: OfferingsOperations + operations: Operations + private_endpoint_connections: PrivateEndpointConnectionsOperations + private_link_resources: PrivateLinkResourcesOperations + query_keys: QueryKeysOperations + services: ServicesOperations + shared_private_link_resources: SharedPrivateLinkResourcesOperations + usages: UsagesOperations + + 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: ... + + @distributed_trace + def usage_by_subscription_sku( + self, + location: str, + sku_name: str, + **kwargs: Any + ) -> QuotaUsageResult: ... + + +namespace azure.mgmt.search.aio + + class azure.mgmt.search.aio.SearchManagementClient(_SearchManagementClientOperationsMixin): implements AsyncContextManager + admin_keys: AdminKeysOperations + network_security_perimeter_configurations: NetworkSecurityPerimeterConfigurationsOperations + offerings: OfferingsOperations + operations: Operations + private_endpoint_connections: PrivateEndpointConnectionsOperations + private_link_resources: PrivateLinkResourcesOperations + query_keys: QueryKeysOperations + services: ServicesOperations + shared_private_link_resources: SharedPrivateLinkResourcesOperations + usages: UsagesOperations + + 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]: ... + + @distributed_trace_async + async def usage_by_subscription_sku( + self, + location: str, + sku_name: str, + **kwargs: Any + ) -> QuotaUsageResult: ... + + +namespace azure.mgmt.search.aio.operations + + class azure.mgmt.search.aio.operations.AdminKeysOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> AdminKeyResult: ... + + @distributed_trace_async + async def regenerate( + self, + resource_group_name: str, + search_service_name: str, + key_kind: Union[str, AdminKeyKind], + **kwargs: Any + ) -> AdminKeyResult: ... + + + class azure.mgmt.search.aio.operations.NetworkSecurityPerimeterConfigurationsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace_async + async def begin_reconcile( + self, + resource_group_name: str, + search_service_name: str, + nsp_config_name: str, + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + search_service_name: str, + nsp_config_name: str, + **kwargs: Any + ) -> NetworkSecurityPerimeterConfiguration: ... + + @distributed_trace + def list_by_service( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> AsyncItemPaged[NetworkSecurityPerimeterConfiguration]: ... + + + class azure.mgmt.search.aio.operations.OfferingsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace_async + @api_version_validation(method_added_on='2026-09-01-preview', params_added_on={'2026-09-01-preview': ['api_version', 'accept']}, api_versions_list=['2026-09-01-preview']) + async def fetch(self, **kwargs: Any) -> OfferingsResult: ... + + + class azure.mgmt.search.aio.operations.Operations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list(self, **kwargs: Any) -> AsyncItemPaged[Operation]: ... + + + class azure.mgmt.search.aio.operations.PrivateEndpointConnectionsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace_async + async def delete( + self, + resource_group_name: str, + search_service_name: str, + private_endpoint_connection_name: str, + **kwargs: Any + ) -> Optional[PrivateEndpointConnection]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + search_service_name: str, + private_endpoint_connection_name: str, + **kwargs: Any + ) -> PrivateEndpointConnection: ... + + @distributed_trace + def list_by_service( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> AsyncItemPaged[PrivateEndpointConnection]: ... + + @overload + async def update( + self, + resource_group_name: str, + search_service_name: str, + private_endpoint_connection_name: str, + private_endpoint_connection: PrivateEndpointConnection, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> PrivateEndpointConnection: ... + + @overload + async def update( + self, + resource_group_name: str, + search_service_name: str, + private_endpoint_connection_name: str, + private_endpoint_connection: PrivateEndpointConnection, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> PrivateEndpointConnection: ... + + @overload + async def update( + self, + resource_group_name: str, + search_service_name: str, + private_endpoint_connection_name: str, + private_endpoint_connection: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> PrivateEndpointConnection: ... + + + class azure.mgmt.search.aio.operations.PrivateLinkResourcesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list_supported( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> AsyncItemPaged[PrivateLinkResource]: ... + + + class azure.mgmt.search.aio.operations.QueryKeysOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace_async + async def create( + self, + resource_group_name: str, + search_service_name: str, + name: str, + **kwargs: Any + ) -> QueryKey: ... + + @distributed_trace_async + async def delete( + self, + resource_group_name: str, + search_service_name: str, + key: str, + **kwargs: Any + ) -> None: ... + + @distributed_trace + def list_by_search_service( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> AsyncItemPaged[QueryKey]: ... + + + class azure.mgmt.search.aio.operations.ServicesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + search_service_name: str, + service: SearchService, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[SearchService]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + search_service_name: str, + service: SearchService, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[SearchService]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + search_service_name: str, + service: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[SearchService]: ... + + @distributed_trace_async + async def begin_upgrade( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> AsyncLROPoller[SearchService]: ... + + @overload + async def check_name_availability( + self, + check_name_availability_input: CheckNameAvailabilityInput, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + @overload + async def check_name_availability( + self, + check_name_availability_input: CheckNameAvailabilityInput, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + @overload + async def check_name_availability( + self, + check_name_availability_input: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + @distributed_trace_async + async def delete( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> None: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> SearchService: ... + + @distributed_trace + def list_by_resource_group( + self, + resource_group_name: str, + **kwargs: Any + ) -> AsyncItemPaged[SearchService]: ... + + @distributed_trace + def list_by_subscription(self, **kwargs: Any) -> AsyncItemPaged[SearchService]: ... + + @overload + async def update( + self, + resource_group_name: str, + search_service_name: str, + service: SearchServiceUpdate, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SearchService: ... + + @overload + async def update( + self, + resource_group_name: str, + search_service_name: str, + service: SearchServiceUpdate, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SearchService: ... + + @overload + async def update( + self, + resource_group_name: str, + search_service_name: str, + service: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SearchService: ... + + + class azure.mgmt.search.aio.operations.SharedPrivateLinkResourcesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + search_service_name: str, + shared_private_link_resource_name: str, + shared_private_link_resource: SharedPrivateLinkResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[SharedPrivateLinkResource]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + search_service_name: str, + shared_private_link_resource_name: str, + shared_private_link_resource: SharedPrivateLinkResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[SharedPrivateLinkResource]: ... + + @overload + async def begin_create_or_update( + self, + resource_group_name: str, + search_service_name: str, + shared_private_link_resource_name: str, + shared_private_link_resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> AsyncLROPoller[SharedPrivateLinkResource]: ... + + @distributed_trace_async + async def begin_delete( + self, + resource_group_name: str, + search_service_name: str, + shared_private_link_resource_name: str, + **kwargs: Any + ) -> AsyncLROPoller[None]: ... + + @distributed_trace_async + async def get( + self, + resource_group_name: str, + search_service_name: str, + shared_private_link_resource_name: str, + **kwargs: Any + ) -> SharedPrivateLinkResource: ... + + @distributed_trace + def list_by_service( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> AsyncItemPaged[SharedPrivateLinkResource]: ... + + + class azure.mgmt.search.aio.operations.UsagesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list_by_subscription( + self, + location: str, + **kwargs: Any + ) -> AsyncItemPaged[QuotaUsageResult]: ... + + +namespace azure.mgmt.search.models + + class azure.mgmt.search.models.AadAuthFailureMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): + HTTP401_WITH_BEARER_CHALLENGE = "http401WithBearerChallenge" + HTTP403 = "http403" + + + class azure.mgmt.search.models.AccessRule(_Model): + name: Optional[str] + properties: Optional[AccessRuleProperties] + + @overload + def __init__( + self, + *, + name: Optional[str] = ..., + properties: Optional[AccessRuleProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.AccessRuleDirection(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INBOUND = "Inbound" + OUTBOUND = "Outbound" + + + class azure.mgmt.search.models.AccessRuleProperties(_Model): + address_prefixes: Optional[list[str]] + direction: Optional[Union[str, AccessRuleDirection]] + email_addresses: Optional[list[str]] + fully_qualified_domain_names: Optional[list[str]] + network_security_perimeters: Optional[list[NetworkSecurityPerimeter]] + phone_numbers: Optional[list[str]] + subscriptions: Optional[list[AccessRulePropertiesSubscriptionsItem]] + + @overload + def __init__( + self, + *, + address_prefixes: Optional[list[str]] = ..., + direction: Optional[Union[str, AccessRuleDirection]] = ..., + email_addresses: Optional[list[str]] = ..., + fully_qualified_domain_names: Optional[list[str]] = ..., + network_security_perimeters: Optional[list[NetworkSecurityPerimeter]] = ..., + phone_numbers: Optional[list[str]] = ..., + subscriptions: Optional[list[AccessRulePropertiesSubscriptionsItem]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.AccessRulePropertiesSubscriptionsItem(_Model): + id: Optional[str] + + @overload + def __init__( + self, + *, + id: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.ActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + INTERNAL = "Internal" + + + class azure.mgmt.search.models.AdminKeyKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): + PRIMARY = "primary" + SECONDARY = "secondary" + + + class azure.mgmt.search.models.AdminKeyResult(_Model): + primary_key: Optional[str] + secondary_key: Optional[str] + + + class azure.mgmt.search.models.AutoGeneratedDomainNameLabelScope(str, Enum, metaclass=CaseInsensitiveEnumMeta): + NO_REUSE = "NoReuse" + SUBSCRIPTION_REUSE = "SubscriptionReuse" + TENANT_REUSE = "TenantReuse" + + + class azure.mgmt.search.models.AzureActiveDirectoryApplicationCredentials(_Model): + application_id: Optional[str] + application_secret: Optional[str] + + @overload + def __init__( + self, + *, + application_id: Optional[str] = ..., + application_secret: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.CheckNameAvailabilityInput(_Model): + name: str + type: Literal["searchServices"] + + @overload + def __init__( + self, + *, + name: str + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.CheckNameAvailabilityOutput(_Model): + is_name_available: Optional[bool] + message: Optional[str] + reason: Optional[Union[str, UnavailableNameReason]] + + + class azure.mgmt.search.models.CloudError(_Model): + error: Optional[CloudErrorBody] + message: Optional[str] + + @overload + def __init__( + self, + *, + error: Optional[CloudErrorBody] = ..., + message: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.CloudErrorBody(_Model): + code: Optional[str] + details: Optional[list[CloudErrorBody]] + message: Optional[str] + target: Optional[str] + + @overload + def __init__( + self, + *, + code: Optional[str] = ..., + details: Optional[list[CloudErrorBody]] = ..., + message: Optional[str] = ..., + target: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.ComputeType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CONFIDENTIAL = "Confidential" + DEFAULT = "Default" + + + class azure.mgmt.search.models.CreatedByType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + APPLICATION = "Application" + KEY = "Key" + MANAGED_IDENTITY = "ManagedIdentity" + USER = "User" + + + class azure.mgmt.search.models.DataIdentity(_Model): + odata_type: str + + @overload + def __init__( + self, + *, + odata_type: str + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.DataNoneIdentity(DataIdentity, discriminator='#Microsoft.Azure.Search.DataNoneIdentity'): + odata_type: Literal["#DataNoneIdentity"] + + @overload + def __init__(self) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.DataPlaneAadOrApiKeyAuthOption(_Model): + aad_auth_failure_mode: Optional[Union[str, AadAuthFailureMode]] + + @overload + def __init__( + self, + *, + aad_auth_failure_mode: Optional[Union[str, AadAuthFailureMode]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.DataPlaneAuthOptions(_Model): + aad_or_api_key: Optional[DataPlaneAadOrApiKeyAuthOption] + api_key_only: Optional[Any] + + @overload + def __init__( + self, + *, + aad_or_api_key: Optional[DataPlaneAadOrApiKeyAuthOption] = ..., + api_key_only: Optional[Any] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.DataUserAssignedIdentity(DataIdentity, discriminator='#Microsoft.Azure.Search.DataUserAssignedIdentity'): + federated_identity_client_id: Optional[str] + odata_type: Literal["#DataUserAssignedIdentity"] + user_assigned_identity: str + + @overload + def __init__( + self, + *, + federated_identity_client_id: Optional[str] = ..., + user_assigned_identity: str + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.EncryptionWithCmk(_Model): + encryption_compliance_status: Optional[Union[str, SearchEncryptionComplianceStatus]] + enforcement: Optional[Union[str, SearchEncryptionWithCmk]] + service_level_encryption_key: Optional[SearchResourceEncryptionKey] + + @overload + def __init__( + self, + *, + enforcement: Optional[Union[str, SearchEncryptionWithCmk]] = ..., + service_level_encryption_key: Optional[SearchResourceEncryptionKey] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.FeatureOffering(_Model): + name: Optional[str] + + @overload + def __init__( + self, + *, + name: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.HostingMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DEFAULT = "Default" + HIGH_DENSITY = "HighDensity" + + + class azure.mgmt.search.models.Identity(_Model): + principal_id: Optional[str] + tenant_id: Optional[str] + type: Union[str, IdentityType] + user_assigned_identities: Optional[dict[str, UserAssignedIdentity]] + + @overload + def __init__( + self, + *, + type: Union[str, IdentityType], + user_assigned_identities: Optional[dict[str, UserAssignedIdentity]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.IdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + NONE = "None" + SYSTEM_ASSIGNED = "SystemAssigned" + SYSTEM_ASSIGNED_USER_ASSIGNED = "SystemAssigned, UserAssigned" + USER_ASSIGNED = "UserAssigned" + + + class azure.mgmt.search.models.IpRule(_Model): + value: Optional[str] + + @overload + def __init__( + self, + *, + value: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.IssueType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CONFIGURATION_PROPAGATION_FAILURE = "ConfigurationPropagationFailure" + MISSING_IDENTITY_CONFIGURATION = "MissingIdentityConfiguration" + MISSING_PERIMETER_CONFIGURATION = "MissingPerimeterConfiguration" + UNKNOWN = "Unknown" + + + class azure.mgmt.search.models.KnowledgeRetrieval(str, Enum, metaclass=CaseInsensitiveEnumMeta): + FREE = "free" + STANDARD = "standard" + + + class azure.mgmt.search.models.NetworkRuleSet(_Model): + bypass: Optional[Union[str, SearchBypass]] + ip_rules: Optional[list[IpRule]] + + @overload + def __init__( + self, + *, + bypass: Optional[Union[str, SearchBypass]] = ..., + ip_rules: Optional[list[IpRule]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.NetworkSecurityPerimeter(_Model): + id: Optional[str] + location: Optional[str] + perimeter_guid: Optional[str] + + @overload + def __init__( + self, + *, + id: Optional[str] = ..., + location: Optional[str] = ..., + perimeter_guid: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.NetworkSecurityPerimeterConfiguration(ProxyResource): + id: str + name: str + properties: Optional[NetworkSecurityPerimeterConfigurationProperties] + system_data: SystemData + type: str + + @overload + def __init__( + self, + *, + properties: Optional[NetworkSecurityPerimeterConfigurationProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.NetworkSecurityPerimeterConfigurationProperties(_Model): + network_security_perimeter: Optional[NetworkSecurityPerimeter] + profile: Optional[NetworkSecurityProfile] + provisioning_issues: Optional[list[ProvisioningIssue]] + provisioning_state: Optional[Union[str, NetworkSecurityPerimeterConfigurationProvisioningState]] + resource_association: Optional[ResourceAssociation] + + @overload + def __init__( + self, + *, + network_security_perimeter: Optional[NetworkSecurityPerimeter] = ..., + profile: Optional[NetworkSecurityProfile] = ..., + resource_association: Optional[ResourceAssociation] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.NetworkSecurityPerimeterConfigurationProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ACCEPTED = "Accepted" + CANCELED = "Canceled" + CREATING = "Creating" + DELETING = "Deleting" + FAILED = "Failed" + SUCCEEDED = "Succeeded" + UPDATING = "Updating" + + + class azure.mgmt.search.models.NetworkSecurityProfile(_Model): + access_rules: Optional[list[AccessRule]] + access_rules_version: Optional[int] + diagnostic_settings_version: Optional[int] + enabled_log_categories: Optional[list[str]] + name: Optional[str] + + @overload + def __init__( + self, + *, + access_rules: Optional[list[AccessRule]] = ..., + access_rules_version: Optional[int] = ..., + diagnostic_settings_version: Optional[int] = ..., + enabled_log_categories: Optional[list[str]] = ..., + name: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.OfferingsByRegion(_Model): + features: Optional[list[FeatureOffering]] + region_name: Optional[str] + skus: Optional[list[SkuOffering]] + + @overload + def __init__( + self, + *, + features: Optional[list[FeatureOffering]] = ..., + region_name: Optional[str] = ..., + skus: Optional[list[SkuOffering]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.OfferingsResult(_Model): + default_region: Optional[str] + regions: Optional[list[OfferingsByRegion]] + + + class azure.mgmt.search.models.Operation(_Model): + action_type: Optional[Union[str, ActionType]] + display: Optional[OperationDisplay] + is_data_action: Optional[bool] + name: Optional[str] + origin: Optional[Union[str, Origin]] + + @overload + def __init__( + self, + *, + display: Optional[OperationDisplay] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.OperationDisplay(_Model): + description: Optional[str] + operation: Optional[str] + provider: Optional[str] + resource: Optional[str] + + + class azure.mgmt.search.models.Origin(str, Enum, metaclass=CaseInsensitiveEnumMeta): + SYSTEM = "system" + USER = "user" + USER_SYSTEM = "user,system" + + + class azure.mgmt.search.models.PrivateEndpointConnection(ProxyResource): + id: str + name: str + properties: Optional[PrivateEndpointConnectionProperties] + system_data: SystemData + type: str + + @overload + def __init__( + self, + *, + properties: Optional[PrivateEndpointConnectionProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.PrivateEndpointConnectionProperties(_Model): + group_id: Optional[str] + private_endpoint: Optional[PrivateEndpointConnectionPropertiesPrivateEndpoint] + private_link_service_connection_state: Optional[PrivateEndpointConnectionPropertiesPrivateLinkServiceConnectionState] + provisioning_state: Optional[Union[str, PrivateLinkServiceConnectionProvisioningState]] + + @overload + def __init__( + self, + *, + group_id: Optional[str] = ..., + private_endpoint: Optional[PrivateEndpointConnectionPropertiesPrivateEndpoint] = ..., + private_link_service_connection_state: Optional[PrivateEndpointConnectionPropertiesPrivateLinkServiceConnectionState] = ..., + provisioning_state: Optional[Union[str, PrivateLinkServiceConnectionProvisioningState]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.PrivateEndpointConnectionPropertiesPrivateEndpoint(_Model): + id: Optional[str] + + @overload + def __init__( + self, + *, + id: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.PrivateEndpointConnectionPropertiesPrivateLinkServiceConnectionState(_Model): + actions_required: Optional[str] + description: Optional[str] + status: Optional[Union[str, PrivateLinkServiceConnectionStatus]] + + @overload + def __init__( + self, + *, + actions_required: Optional[str] = ..., + description: Optional[str] = ..., + status: Optional[Union[str, PrivateLinkServiceConnectionStatus]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.PrivateLinkResource(Resource): + id: str + name: str + properties: Optional[PrivateLinkResourceProperties] + system_data: SystemData + type: str + + + class azure.mgmt.search.models.PrivateLinkResourceProperties(_Model): + group_id: Optional[str] + required_members: Optional[list[str]] + required_zone_names: Optional[list[str]] + shareable_private_link_resource_types: Optional[list[ShareablePrivateLinkResourceType]] + + + class azure.mgmt.search.models.PrivateLinkServiceConnectionProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + CANCELED = "Canceled" + DELETING = "Deleting" + FAILED = "Failed" + INCOMPLETE = "Incomplete" + SUCCEEDED = "Succeeded" + UPDATING = "Updating" + + + class azure.mgmt.search.models.PrivateLinkServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + APPROVED = "Approved" + DISCONNECTED = "Disconnected" + PENDING = "Pending" + REJECTED = "Rejected" + + + class azure.mgmt.search.models.ProvisioningIssue(_Model): + name: Optional[str] + properties: Optional[ProvisioningIssueProperties] + + + class azure.mgmt.search.models.ProvisioningIssueProperties(_Model): + description: Optional[str] + issue_type: Optional[Union[str, IssueType]] + severity: Optional[Union[str, Severity]] + suggested_access_rules: Optional[list[AccessRule]] + suggested_resource_ids: Optional[list[str]] + + + class azure.mgmt.search.models.ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + FAILED = "failed" + PROVISIONING = "provisioning" + SUCCEEDED = "succeeded" + + + class azure.mgmt.search.models.ProxyResource(Resource): + id: str + name: str + system_data: SystemData + type: str + + + class azure.mgmt.search.models.PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + SECURED_BY_PERIMETER = "SecuredByPerimeter" + + + class azure.mgmt.search.models.QueryKey(_Model): + key: Optional[str] + name: Optional[str] + + + class azure.mgmt.search.models.QuotaUsageResult(_Model): + current_value: Optional[int] + id: Optional[str] + limit: Optional[int] + name: Optional[QuotaUsageResultName] + unit: Optional[str] + + @overload + def __init__( + self, + *, + current_value: Optional[int] = ..., + id: Optional[str] = ..., + limit: Optional[int] = ..., + unit: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.QuotaUsageResultName(_Model): + localized_value: Optional[str] + value: Optional[str] + + @overload + def __init__( + self, + *, + localized_value: Optional[str] = ..., + value: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.Resource(_Model): + id: Optional[str] + name: Optional[str] + system_data: Optional[SystemData] + type: Optional[str] + + + class azure.mgmt.search.models.ResourceAssociation(_Model): + access_mode: Optional[Union[str, ResourceAssociationAccessMode]] + name: Optional[str] + + @overload + def __init__( + self, + *, + access_mode: Optional[Union[str, ResourceAssociationAccessMode]] = ..., + name: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.ResourceAssociationAccessMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): + AUDIT = "Audit" + ENFORCED = "Enforced" + LEARNING = "Learning" + + + class azure.mgmt.search.models.SearchBypass(str, Enum, metaclass=CaseInsensitiveEnumMeta): + AZURE_PORTAL = "AzurePortal" + AZURE_SERVICES = "AzureServices" + NONE = "None" + + + class azure.mgmt.search.models.SearchDataExfiltrationProtection(str, Enum, metaclass=CaseInsensitiveEnumMeta): + BLOCK_ALL = "BlockAll" + + + class azure.mgmt.search.models.SearchEncryptionComplianceStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + COMPLIANT = "Compliant" + NON_COMPLIANT = "NonCompliant" + + + class azure.mgmt.search.models.SearchEncryptionWithCmk(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "Disabled" + ENABLED = "Enabled" + UNSPECIFIED = "Unspecified" + + + class azure.mgmt.search.models.SearchResourceEncryptionKey(_Model): + access_credentials: Optional[AzureActiveDirectoryApplicationCredentials] + identity: Optional[DataIdentity] + key_name: Optional[str] + key_version: Optional[str] + vault_uri: Optional[str] + + @overload + def __init__( + self, + *, + access_credentials: Optional[AzureActiveDirectoryApplicationCredentials] = ..., + identity: Optional[DataIdentity] = ..., + key_name: Optional[str] = ..., + key_version: Optional[str] = ..., + vault_uri: Optional[str] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.SearchSemanticSearch(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DISABLED = "disabled" + FREE = "free" + STANDARD = "standard" + + + class azure.mgmt.search.models.SearchService(TrackedResource): + id: str + identity: Optional[Identity] + location: str + name: str + properties: Optional[SearchServiceProperties] + sku: Optional[Sku] + system_data: SystemData + tags: dict[str, str] + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + identity: Optional[Identity] = ..., + location: str, + properties: Optional[SearchServiceProperties] = ..., + 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.search.models.SearchServiceProperties(_Model): + auth_options: Optional[DataPlaneAuthOptions] + auto_generated_domain_name_label_scope: Optional[Union[str, AutoGeneratedDomainNameLabelScope]] + compute_type: Optional[Union[str, ComputeType]] + data_exfiltration_protections: Optional[list[Union[str, SearchDataExfiltrationProtection]]] + disable_local_auth: Optional[bool] + e_tag: Optional[str] + encryption_with_cmk: Optional[EncryptionWithCmk] + endpoint: Optional[str] + hosting_mode: Optional[Union[str, HostingMode]] + knowledge_retrieval: Optional[Union[str, KnowledgeRetrieval]] + network_rule_set: Optional[NetworkRuleSet] + partition_count: Optional[int] + private_endpoint_connections: Optional[list[PrivateEndpointConnection]] + provisioning_state: Optional[Union[str, ProvisioningState]] + public_network_access: Optional[Union[str, PublicNetworkAccess]] + replica_count: Optional[int] + semantic_search: Optional[Union[str, SearchSemanticSearch]] + service_upgraded_at: Optional[datetime] + shared_private_link_resources: Optional[list[SharedPrivateLinkResource]] + status: Optional[Union[str, SearchServiceStatus]] + status_details: Optional[str] + upgrade_available: Optional[Union[str, UpgradeAvailable]] + + @overload + def __init__( + self, + *, + auth_options: Optional[DataPlaneAuthOptions] = ..., + auto_generated_domain_name_label_scope: Optional[Union[str, AutoGeneratedDomainNameLabelScope]] = ..., + compute_type: Optional[Union[str, ComputeType]] = ..., + data_exfiltration_protections: Optional[list[Union[str, SearchDataExfiltrationProtection]]] = ..., + disable_local_auth: Optional[bool] = ..., + encryption_with_cmk: Optional[EncryptionWithCmk] = ..., + endpoint: Optional[str] = ..., + hosting_mode: Optional[Union[str, HostingMode]] = ..., + knowledge_retrieval: Optional[Union[str, KnowledgeRetrieval]] = ..., + network_rule_set: Optional[NetworkRuleSet] = ..., + partition_count: Optional[int] = ..., + public_network_access: Optional[Union[str, PublicNetworkAccess]] = ..., + replica_count: Optional[int] = ..., + semantic_search: Optional[Union[str, SearchSemanticSearch]] = ..., + upgrade_available: Optional[Union[str, UpgradeAvailable]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.SearchServiceStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DEGRADED = "degraded" + DELETING = "deleting" + DISABLED = "disabled" + ERROR = "error" + PROVISIONING = "provisioning" + RUNNING = "running" + STOPPED = "stopped" + + + class azure.mgmt.search.models.SearchServiceUpdate(Resource): + id: str + identity: Optional[Identity] + location: Optional[str] + name: str + properties: Optional[SearchServiceProperties] + sku: Optional[Sku] + system_data: SystemData + tags: Optional[dict[str, str]] + type: str + + def __getattr__(self, name: str) -> Any: ... + + @overload + def __init__( + self, + *, + identity: Optional[Identity] = ..., + location: Optional[str] = ..., + properties: Optional[SearchServiceProperties] = ..., + 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.search.models.Severity(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ERROR = "Error" + WARNING = "Warning" + + + class azure.mgmt.search.models.ShareablePrivateLinkResourceProperties(_Model): + description: Optional[str] + group_id: Optional[str] + type: Optional[str] + + + class azure.mgmt.search.models.ShareablePrivateLinkResourceType(_Model): + name: Optional[str] + properties: Optional[ShareablePrivateLinkResourceProperties] + + + class azure.mgmt.search.models.SharedPrivateLinkResource(ProxyResource): + id: str + name: str + properties: Optional[SharedPrivateLinkResourceProperties] + system_data: SystemData + type: str + + @overload + def __init__( + self, + *, + properties: Optional[SharedPrivateLinkResourceProperties] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.SharedPrivateLinkResourceProperties(_Model): + group_id: Optional[str] + private_link_resource_id: Optional[str] + provisioning_state: Optional[Union[str, SharedPrivateLinkResourceProvisioningState]] + request_message: Optional[str] + resource_region: Optional[str] + status: Optional[Union[str, SharedPrivateLinkResourceStatus]] + + @overload + def __init__( + self, + *, + group_id: Optional[str] = ..., + private_link_resource_id: Optional[str] = ..., + provisioning_state: Optional[Union[str, SharedPrivateLinkResourceProvisioningState]] = ..., + request_message: Optional[str] = ..., + resource_region: Optional[str] = ..., + status: Optional[Union[str, SharedPrivateLinkResourceStatus]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.SharedPrivateLinkResourceProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta): + DELETING = "Deleting" + FAILED = "Failed" + INCOMPLETE = "Incomplete" + SUCCEEDED = "Succeeded" + UPDATING = "Updating" + + + class azure.mgmt.search.models.SharedPrivateLinkResourceStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + APPROVED = "Approved" + DISCONNECTED = "Disconnected" + PENDING = "Pending" + REJECTED = "Rejected" + + + class azure.mgmt.search.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.search.models.SkuLimits(_Model): + indexers: Optional[int] + indexes: Optional[int] + partition_storage_in_gigabytes: Optional[float] + partition_vector_storage_in_gigabytes: Optional[float] + partitions: Optional[int] + replicas: Optional[int] + search_units: Optional[int] + + @overload + def __init__( + self, + *, + indexers: Optional[int] = ..., + indexes: Optional[int] = ..., + partition_storage_in_gigabytes: Optional[float] = ..., + partition_vector_storage_in_gigabytes: Optional[float] = ..., + partitions: Optional[int] = ..., + replicas: Optional[int] = ..., + search_units: Optional[int] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.SkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta): + BASIC = "basic" + FREE = "free" + SERVERLESS = "serverless" + STANDARD = "standard" + STANDARD2 = "standard2" + STANDARD3 = "standard3" + STORAGE_OPTIMIZED_L1 = "storage_optimized_l1" + STORAGE_OPTIMIZED_L2 = "storage_optimized_l2" + + + class azure.mgmt.search.models.SkuOffering(_Model): + limits: Optional[SkuLimits] + sku: Optional[Sku] + + @overload + def __init__( + self, + *, + limits: Optional[SkuLimits] = ..., + sku: Optional[Sku] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.SystemData(_Model): + created_at: Optional[datetime] + created_by: Optional[str] + created_by_type: Optional[Union[str, CreatedByType]] + last_modified_at: Optional[datetime] + last_modified_by: Optional[str] + last_modified_by_type: Optional[Union[str, CreatedByType]] + + @overload + def __init__( + self, + *, + created_at: Optional[datetime] = ..., + created_by: Optional[str] = ..., + created_by_type: Optional[Union[str, CreatedByType]] = ..., + last_modified_at: Optional[datetime] = ..., + last_modified_by: Optional[str] = ..., + last_modified_by_type: Optional[Union[str, CreatedByType]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.TrackedResource(Resource): + id: str + location: str + name: str + system_data: SystemData + tags: Optional[dict[str, str]] + type: str + + @overload + def __init__( + self, + *, + location: str, + tags: Optional[dict[str, str]] = ... + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: ... + + + class azure.mgmt.search.models.UnavailableNameReason(str, Enum, metaclass=CaseInsensitiveEnumMeta): + ALREADY_EXISTS = "AlreadyExists" + INVALID = "Invalid" + + + class azure.mgmt.search.models.UpgradeAvailable(str, Enum, metaclass=CaseInsensitiveEnumMeta): + AVAILABLE = "available" + NOT_AVAILABLE = "notAvailable" + + + class azure.mgmt.search.models.UserAssignedIdentity(_Model): + client_id: Optional[str] + principal_id: Optional[str] + + +namespace azure.mgmt.search.operations + + class azure.mgmt.search.operations.AdminKeysOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> AdminKeyResult: ... + + @distributed_trace + def regenerate( + self, + resource_group_name: str, + search_service_name: str, + key_kind: Union[str, AdminKeyKind], + **kwargs: Any + ) -> AdminKeyResult: ... + + + class azure.mgmt.search.operations.NetworkSecurityPerimeterConfigurationsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def begin_reconcile( + self, + resource_group_name: str, + search_service_name: str, + nsp_config_name: str, + **kwargs: Any + ) -> LROPoller[None]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + search_service_name: str, + nsp_config_name: str, + **kwargs: Any + ) -> NetworkSecurityPerimeterConfiguration: ... + + @distributed_trace + def list_by_service( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> ItemPaged[NetworkSecurityPerimeterConfiguration]: ... + + + class azure.mgmt.search.operations.OfferingsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + @api_version_validation(method_added_on='2026-09-01-preview', params_added_on={'2026-09-01-preview': ['api_version', 'accept']}, api_versions_list=['2026-09-01-preview']) + def fetch(self, **kwargs: Any) -> OfferingsResult: ... + + + class azure.mgmt.search.operations.Operations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list(self, **kwargs: Any) -> ItemPaged[Operation]: ... + + + class azure.mgmt.search.operations.PrivateEndpointConnectionsOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def delete( + self, + resource_group_name: str, + search_service_name: str, + private_endpoint_connection_name: str, + **kwargs: Any + ) -> Optional[PrivateEndpointConnection]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + search_service_name: str, + private_endpoint_connection_name: str, + **kwargs: Any + ) -> PrivateEndpointConnection: ... + + @distributed_trace + def list_by_service( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> ItemPaged[PrivateEndpointConnection]: ... + + @overload + def update( + self, + resource_group_name: str, + search_service_name: str, + private_endpoint_connection_name: str, + private_endpoint_connection: PrivateEndpointConnection, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> PrivateEndpointConnection: ... + + @overload + def update( + self, + resource_group_name: str, + search_service_name: str, + private_endpoint_connection_name: str, + private_endpoint_connection: PrivateEndpointConnection, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> PrivateEndpointConnection: ... + + @overload + def update( + self, + resource_group_name: str, + search_service_name: str, + private_endpoint_connection_name: str, + private_endpoint_connection: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> PrivateEndpointConnection: ... + + + class azure.mgmt.search.operations.PrivateLinkResourcesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list_supported( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> ItemPaged[PrivateLinkResource]: ... + + + class azure.mgmt.search.operations.QueryKeysOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def create( + self, + resource_group_name: str, + search_service_name: str, + name: str, + **kwargs: Any + ) -> QueryKey: ... + + @distributed_trace + def delete( + self, + resource_group_name: str, + search_service_name: str, + key: str, + **kwargs: Any + ) -> None: ... + + @distributed_trace + def list_by_search_service( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> ItemPaged[QueryKey]: ... + + + class azure.mgmt.search.operations.ServicesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + search_service_name: str, + service: SearchService, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[SearchService]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + search_service_name: str, + service: SearchService, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[SearchService]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + search_service_name: str, + service: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[SearchService]: ... + + @distributed_trace + def begin_upgrade( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> LROPoller[SearchService]: ... + + @overload + def check_name_availability( + self, + check_name_availability_input: CheckNameAvailabilityInput, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + @overload + def check_name_availability( + self, + check_name_availability_input: CheckNameAvailabilityInput, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + @overload + def check_name_availability( + self, + check_name_availability_input: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> CheckNameAvailabilityOutput: ... + + @distributed_trace + def delete( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> None: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> SearchService: ... + + @distributed_trace + def list_by_resource_group( + self, + resource_group_name: str, + **kwargs: Any + ) -> ItemPaged[SearchService]: ... + + @distributed_trace + def list_by_subscription(self, **kwargs: Any) -> ItemPaged[SearchService]: ... + + @overload + def update( + self, + resource_group_name: str, + search_service_name: str, + service: SearchServiceUpdate, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SearchService: ... + + @overload + def update( + self, + resource_group_name: str, + search_service_name: str, + service: SearchServiceUpdate, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SearchService: ... + + @overload + def update( + self, + resource_group_name: str, + search_service_name: str, + service: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> SearchService: ... + + + class azure.mgmt.search.operations.SharedPrivateLinkResourcesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + search_service_name: str, + shared_private_link_resource_name: str, + shared_private_link_resource: SharedPrivateLinkResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[SharedPrivateLinkResource]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + search_service_name: str, + shared_private_link_resource_name: str, + shared_private_link_resource: SharedPrivateLinkResource, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[SharedPrivateLinkResource]: ... + + @overload + def begin_create_or_update( + self, + resource_group_name: str, + search_service_name: str, + shared_private_link_resource_name: str, + shared_private_link_resource: IO[bytes], + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[SharedPrivateLinkResource]: ... + + @distributed_trace + def begin_delete( + self, + resource_group_name: str, + search_service_name: str, + shared_private_link_resource_name: str, + **kwargs: Any + ) -> LROPoller[None]: ... + + @distributed_trace + def get( + self, + resource_group_name: str, + search_service_name: str, + shared_private_link_resource_name: str, + **kwargs: Any + ) -> SharedPrivateLinkResource: ... + + @distributed_trace + def list_by_service( + self, + resource_group_name: str, + search_service_name: str, + **kwargs: Any + ) -> ItemPaged[SharedPrivateLinkResource]: ... + + + class azure.mgmt.search.operations.UsagesOperations: + + def __init__( + self, + *args, + **kwargs + ) -> None: ... + + @distributed_trace + def list_by_subscription( + self, + location: str, + **kwargs: Any + ) -> ItemPaged[QuotaUsageResult]: ... + + +namespace azure.mgmt.search.types + + class azure.mgmt.search.types.AzureActiveDirectoryApplicationCredentials(TypedDict, total=False): + key "applicationId": str + key "applicationSecret": str + application_id: str + application_secret: str + + + class azure.mgmt.search.types.CheckNameAvailabilityInput(TypedDict, total=False): + key "name": Required[str] + key "type": Required[Literal["searchServices"]] + name: str + type: Literal[searchServices] + + + class azure.mgmt.search.types.DataNoneIdentity(TypedDict): + key "@odata.type": Required[Literal["#DataNoneIdentity"]] + odata_type: Literal[#DataNoneIdentity] + + + class azure.mgmt.search.types.DataPlaneAadOrApiKeyAuthOption(TypedDict, total=False): + key "aadAuthFailureMode": Union[str, AadAuthFailureMode] + aad_auth_failure_mode: Union[str, AadAuthFailureMode] + + + class azure.mgmt.search.types.DataPlaneAuthOptions(TypedDict, total=False): + key "aadOrApiKey": ForwardRef('DataPlaneAadOrApiKeyAuthOption', module='types') + key "apiKeyOnly": Any + aad_or_api_key: DataPlaneAadOrApiKeyAuthOption + api_key_only: Any + + + class azure.mgmt.search.types.DataUserAssignedIdentity(TypedDict): + key "@odata.type": Required[Literal["#DataUserAssignedIdentity"]] + key "federatedIdentityClientId": str + key "userAssignedIdentity": Required[str] + federated_identity_client_id: str + odata_type: Literal[#DataUserAssignedIdentity] + user_assigned_identity: str + + + class azure.mgmt.search.types.EncryptionWithCmk(TypedDict, total=False): + key "encryptionComplianceStatus": Union[str, SearchEncryptionComplianceStatus] + key "enforcement": Union[str, SearchEncryptionWithCmk] + key "serviceLevelEncryptionKey": ForwardRef('SearchResourceEncryptionKey', module='types') + encryption_compliance_status: Union[str, SearchEncryptionComplianceStatus] + enforcement: Union[str, SearchEncryptionWithCmk] + service_level_encryption_key: SearchResourceEncryptionKey + + + class azure.mgmt.search.types.Identity(TypedDict, total=False): + key "principalId": str + key "tenantId": str + key "type": Required[Union[str, IdentityType]] + principal_id: str + tenant_id: str + type: Union[str, IdentityType] + userAssignedIdentities: dict[str, UserAssignedIdentity] + user_assigned_identities: dict[str, UserAssignedIdentity] + + + class azure.mgmt.search.types.IpRule(TypedDict, total=False): + key "value": str + value: str + + + class azure.mgmt.search.types.NetworkRuleSet(TypedDict, total=False): + key "bypass": Union[str, SearchBypass] + bypass: Union[str, SearchBypass] + ipRules: list[IpRule] + ip_rules: list[IpRule] + + + class azure.mgmt.search.types.PrivateEndpointConnection(ProxyResource): + key "id": str + key "name": str + key "properties": ForwardRef('PrivateEndpointConnectionProperties', module='types') + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + name: str + properties: PrivateEndpointConnectionProperties + system_data: SystemData + type: str + + + class azure.mgmt.search.types.PrivateEndpointConnectionProperties(TypedDict, total=False): + key "groupId": str + key "privateEndpoint": ForwardRef('PrivateEndpointConnectionPropertiesPrivateEndpoint', module='types') + key "privateLinkServiceConnectionState": ForwardRef('PrivateEndpointConnectionPropertiesPrivateLinkServiceConnectionState', module='types') + key "provisioningState": Union[str, PrivateLinkServiceConnectionProvisioningState] + group_id: str + private_endpoint: PrivateEndpointConnectionPropertiesPrivateEndpoint + private_link_service_connection_state: PrivateEndpointConnectionPropertiesPrivateLinkServiceConnectionState + provisioning_state: Union[str, PrivateLinkServiceConnectionProvisioningState] + + + class azure.mgmt.search.types.PrivateEndpointConnectionPropertiesPrivateEndpoint(TypedDict, total=False): + key "id": str + id: str + + + class azure.mgmt.search.types.PrivateEndpointConnectionPropertiesPrivateLinkServiceConnectionState(TypedDict, total=False): + key "actionsRequired": str + key "description": str + key "status": Union[str, PrivateLinkServiceConnectionStatus] + actions_required: str + description: str + status: Union[str, PrivateLinkServiceConnectionStatus] + + + class azure.mgmt.search.types.ProxyResource(Resource): + key "id": str + key "name": str + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + name: str + system_data: SystemData + type: str + + + class azure.mgmt.search.types.Resource(TypedDict, total=False): + key "id": str + key "name": str + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + name: str + system_data: SystemData + type: str + + + class azure.mgmt.search.types.SearchResourceEncryptionKey(TypedDict, total=False): + key "accessCredentials": ForwardRef('AzureActiveDirectoryApplicationCredentials', module='types') + key "identity": Optional[DataIdentity] + key "keyVaultKeyName": str + key "keyVaultKeyVersion": str + key "keyVaultUri": str + access_credentials: AzureActiveDirectoryApplicationCredentials + identity: DataIdentity + key_name: str + key_version: str + vault_uri: str + + + class azure.mgmt.search.types.SearchService(TrackedResource): + key "id": str + key "identity": ForwardRef('Identity', module='types') + key "location": Required[str] + key "name": str + key "properties": ForwardRef('SearchServiceProperties', module='types') + key "sku": ForwardRef('Sku', module='types') + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + identity: Identity + location: str + name: str + properties: SearchServiceProperties + sku: Sku + system_data: SystemData + tags: dict[str, str] + type: str + + + class azure.mgmt.search.types.SearchServiceProperties(TypedDict, total=False): + key "authOptions": ForwardRef('DataPlaneAuthOptions', module='types') + key "autoGeneratedDomainNameLabelScope": Optional[Union[str, AutoGeneratedDomainNameLabelScope]] + key "computeType": Union[str, ComputeType] + key "disableLocalAuth": Optional[bool] + key "eTag": str + key "encryptionWithCmk": ForwardRef('EncryptionWithCmk', module='types') + key "endpoint": str + key "hostingMode": Union[str, HostingMode] + key "knowledgeRetrieval": Optional[Union[str, KnowledgeRetrieval]] + key "networkRuleSet": ForwardRef('NetworkRuleSet', module='types') + key "partitionCount": int + key "provisioningState": Union[str, ProvisioningState] + key "publicNetworkAccess": Union[str, PublicNetworkAccess] + key "replicaCount": int + key "semanticSearch": Optional[Union[str, SearchSemanticSearch]] + key "serviceUpgradedAt": str + key "status": Union[str, SearchServiceStatus] + key "statusDetails": str + key "upgradeAvailable": Union[str, UpgradeAvailable] + auth_options: DataPlaneAuthOptions + auto_generated_domain_name_label_scope: Union[str, AutoGeneratedDomainNameLabelScope] + compute_type: Union[str, ComputeType] + dataExfiltrationProtections: list[Union[str, SearchDataExfiltrationProtection]] + data_exfiltration_protections: list[Union[str, SearchDataExfiltrationProtection]] + disable_local_auth: bool + e_tag: str + encryption_with_cmk: EncryptionWithCmk + endpoint: str + hosting_mode: Union[str, HostingMode] + knowledge_retrieval: Union[str, KnowledgeRetrieval] + network_rule_set: NetworkRuleSet + partition_count: int + privateEndpointConnections: list[PrivateEndpointConnection] + private_endpoint_connections: list[PrivateEndpointConnection] + provisioning_state: Union[str, ProvisioningState] + public_network_access: Union[str, PublicNetworkAccess] + replica_count: int + semantic_search: Union[str, SearchSemanticSearch] + service_upgraded_at: str + sharedPrivateLinkResources: list[SharedPrivateLinkResource] + shared_private_link_resources: list[SharedPrivateLinkResource] + status: Union[str, SearchServiceStatus] + status_details: str + upgrade_available: Union[str, UpgradeAvailable] + + + class azure.mgmt.search.types.SearchServiceUpdate(Resource): + key "id": str + key "identity": ForwardRef('Identity', module='types') + key "location": str + key "name": str + key "properties": ForwardRef('SearchServiceProperties', module='types') + key "sku": ForwardRef('Sku', module='types') + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + identity: Identity + location: str + name: str + properties: SearchServiceProperties + sku: Sku + system_data: SystemData + tags: dict[str, str] + type: str + + + class azure.mgmt.search.types.SharedPrivateLinkResource(ProxyResource): + key "id": str + key "name": str + key "properties": ForwardRef('SharedPrivateLinkResourceProperties', module='types') + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + name: str + properties: SharedPrivateLinkResourceProperties + system_data: SystemData + type: str + + + class azure.mgmt.search.types.SharedPrivateLinkResourceProperties(TypedDict, total=False): + key "groupId": str + key "privateLinkResourceId": str + key "provisioningState": Union[str, SharedPrivateLinkResourceProvisioningState] + key "requestMessage": str + key "resourceRegion": str + key "status": Union[str, SharedPrivateLinkResourceStatus] + group_id: str + private_link_resource_id: str + provisioning_state: Union[str, SharedPrivateLinkResourceProvisioningState] + request_message: str + resource_region: str + status: Union[str, SharedPrivateLinkResourceStatus] + + + class azure.mgmt.search.types.Sku(TypedDict, total=False): + key "name": Union[str, SkuName] + name: Union[str, SkuName] + + + class azure.mgmt.search.types.SystemData(TypedDict, total=False): + key "createdAt": str + key "createdBy": str + key "createdByType": Union[str, CreatedByType] + key "lastModifiedAt": str + key "lastModifiedBy": str + key "lastModifiedByType": Union[str, CreatedByType] + created_at: str + created_by: str + created_by_type: Union[str, CreatedByType] + last_modified_at: str + last_modified_by: str + last_modified_by_type: Union[str, CreatedByType] + + + class azure.mgmt.search.types.TrackedResource(Resource): + key "id": str + key "location": Required[str] + key "name": str + key "systemData": ForwardRef('SystemData', module='types') + key "type": str + id: str + location: str + name: str + system_data: SystemData + tags: dict[str, str] + type: str + + + class azure.mgmt.search.types.UserAssignedIdentity(TypedDict, total=False): + key "clientId": str + key "principalId": str + client_id: str + principal_id: str + + +``` \ No newline at end of file diff --git a/sdk/search/azure-mgmt-search/api.metadata.yml b/sdk/search/azure-mgmt-search/api.metadata.yml new file mode 100644 index 000000000000..f87469d53917 --- /dev/null +++ b/sdk/search/azure-mgmt-search/api.metadata.yml @@ -0,0 +1,3 @@ +apiMdSha256: 676a7b3554a0ef1991efa7d729f28800331d55699ca59fbb70170b71f158b475 +parserVersion: 0.3.28 +pythonVersion: 3.13.14 diff --git a/sdk/search/azure-mgmt-search/apiview-properties.json b/sdk/search/azure-mgmt-search/apiview-properties.json index f8dd5be34006..4a6e143730ea 100644 --- a/sdk/search/azure-mgmt-search/apiview-properties.json +++ b/sdk/search/azure-mgmt-search/apiview-properties.json @@ -3,7 +3,7 @@ "CrossLanguageDefinitionId": { "azure.mgmt.search.models.AccessRule": "Azure.ResourceManager.CommonTypes.AccessRule", "azure.mgmt.search.models.AccessRuleProperties": "Azure.ResourceManager.CommonTypes.AccessRuleProperties", - "azure.mgmt.search.models.AccessRulePropertiesSubscriptionsItem": "Microsoft.Search.AccessRulePropertiesSubscriptionsItem", + "azure.mgmt.search.models.AccessRulePropertiesSubscriptionsItem": "Customizations.AccessRulePropertiesSubscriptionsItem", "azure.mgmt.search.models.AdminKeyResult": "Microsoft.Search.AdminKeyResult", "azure.mgmt.search.models.AzureActiveDirectoryApplicationCredentials": "Microsoft.Search.AzureActiveDirectoryApplicationCredentials", "azure.mgmt.search.models.CheckNameAvailabilityInput": "Microsoft.Search.CheckNameAvailabilityInput", @@ -27,7 +27,7 @@ "azure.mgmt.search.models.NetworkSecurityPerimeterConfigurationProperties": "Azure.ResourceManager.CommonTypes.NetworkSecurityPerimeterConfigurationProperties", "azure.mgmt.search.models.NetworkSecurityProfile": "Azure.ResourceManager.CommonTypes.NetworkSecurityProfile", "azure.mgmt.search.models.OfferingsByRegion": "Microsoft.Search.OfferingsByRegion", - "azure.mgmt.search.models.OfferingsListResult": "Microsoft.Search.OfferingsListResult", + "azure.mgmt.search.models.OfferingsResult": "Microsoft.Search.OfferingsResult", "azure.mgmt.search.models.Operation": "Azure.ResourceManager.CommonTypes.Operation", "azure.mgmt.search.models.OperationDisplay": "Azure.ResourceManager.CommonTypes.OperationDisplay", "azure.mgmt.search.models.PrivateEndpointConnection": "Microsoft.Search.PrivateEndpointConnection", @@ -82,11 +82,12 @@ "azure.mgmt.search.models.AadAuthFailureMode": "Microsoft.Search.AadAuthFailureMode", "azure.mgmt.search.models.SearchSemanticSearch": "Microsoft.Search.SearchSemanticSearch", "azure.mgmt.search.models.KnowledgeRetrieval": "Microsoft.Search.KnowledgeRetrieval", + "azure.mgmt.search.models.AutoGeneratedDomainNameLabelScope": "Microsoft.Search.AutoGeneratedDomainNameLabelScope", "azure.mgmt.search.models.UpgradeAvailable": "Microsoft.Search.UpgradeAvailable", "azure.mgmt.search.models.IdentityType": "Microsoft.Search.IdentityType", "azure.mgmt.search.models.AdminKeyKind": "Microsoft.Search.AdminKeyKind", - "azure.mgmt.search.operations.OfferingsOperations.list": "Microsoft.Search.Offerings.list", - "azure.mgmt.search.aio.operations.OfferingsOperations.list": "Microsoft.Search.Offerings.list", + "azure.mgmt.search.operations.OfferingsOperations.fetch": "Microsoft.Search.Offerings.fetch", + "azure.mgmt.search.aio.operations.OfferingsOperations.fetch": "Microsoft.Search.Offerings.fetch", "azure.mgmt.search.operations.Operations.list": "Azure.ResourceManager.Legacy.Operations.list", "azure.mgmt.search.aio.operations.Operations.list": "Azure.ResourceManager.Legacy.Operations.list", "azure.mgmt.search.operations.PrivateEndpointConnectionsOperations.get": "Microsoft.Search.PrivateEndpointConnections.get", @@ -143,5 +144,6 @@ "azure.mgmt.search.aio.operations.PrivateLinkResourcesOperations.list_supported": "Microsoft.Search.SearchServices.listSupported", "azure.mgmt.search.SearchManagementClient.usage_by_subscription_sku": "Microsoft.Search.usageBySubscriptionSku", "azure.mgmt.search.aio.SearchManagementClient.usage_by_subscription_sku": "Microsoft.Search.usageBySubscriptionSku" - } + }, + "CrossLanguageVersion": "33c123d2de29" } \ No newline at end of file diff --git a/sdk/search/azure-mgmt-search/azure/mgmt/search/_client.py b/sdk/search/azure-mgmt-search/azure/mgmt/search/_client.py index 01e8c283676a..2921434e50a8 100644 --- a/sdk/search/azure-mgmt-search/azure/mgmt/search/_client.py +++ b/sdk/search/azure-mgmt-search/azure/mgmt/search/_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 @@ -33,6 +33,11 @@ _SearchManagementClientOperationsMixin, ) +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 @@ -75,8 +80,9 @@ class SearchManagementClient(_SearchManagementClientOperationsMixin): # pylint: None. :paramtype cloud_setting: ~azure.core.AzureClouds :keyword api_version: The API version to use for this operation. Known values are - "2026-03-01-preview". Default value is "2026-03-01-preview". Note that overriding this default - value may result in unsupported behavior. + "2026-09-01-preview" and None. Default value is None. If not set, the operation's default API + version will be used. Note that overriding this default value may result in unsupported + behavior. :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/search/azure-mgmt-search/azure/mgmt/search/_configuration.py b/sdk/search/azure-mgmt-search/azure/mgmt/search/_configuration.py index 9d4e0c662453..dc1418349204 100644 --- a/sdk/search/azure-mgmt-search/azure/mgmt/search/_configuration.py +++ b/sdk/search/azure-mgmt-search/azure/mgmt/search/_configuration.py @@ -34,8 +34,9 @@ class SearchManagementClientConfiguration: # pylint: disable=too-many-instance- None. :type cloud_setting: ~azure.core.AzureClouds :keyword api_version: The API version to use for this operation. Known values are - "2026-03-01-preview". Default value is "2026-03-01-preview". Note that overriding this default - value may result in unsupported behavior. + "2026-09-01-preview" and None. Default value is None. If not set, the operation's default API + version will be used. Note that overriding this default value may result in unsupported + behavior. :paramtype api_version: str """ @@ -47,7 +48,7 @@ def __init__( cloud_setting: Optional["AzureClouds"] = None, **kwargs: Any ) -> None: - api_version: str = kwargs.pop("api_version", "2026-03-01-preview") + api_version: str = kwargs.pop("api_version", "2026-09-01-preview") if credential is None: raise ValueError("Parameter 'credential' must not be None.") diff --git a/sdk/search/azure-mgmt-search/azure/mgmt/search/_utils/model_base.py b/sdk/search/azure-mgmt-search/azure/mgmt/search/_utils/model_base.py index 7b7f8ba67b53..0f2c5bdfe70f 100644 --- a/sdk/search/azure-mgmt-search/azure/mgmt/search/_utils/model_base.py +++ b/sdk/search/azure-mgmt-search/azure/mgmt/search/_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"), } @@ -420,21 +458,21 @@ def __ne__(self, other: typing.Any) -> bool: def keys(self) -> typing.KeysView[str]: """ - :returns: a set-like object providing a view on D's keys + :returns: a set-like object providing a view on the mapping's keys :rtype: ~typing.KeysView """ return self._data.keys() def values(self) -> typing.ValuesView[typing.Any]: """ - :returns: an object providing a view on D's values + :returns: an object providing a view on the mapping's values :rtype: ~typing.ValuesView """ return self._data.values() def items(self) -> typing.ItemsView[str, typing.Any]: """ - :returns: set-like object providing a view on D's items + :returns: a set-like object providing a view on the mapping's items :rtype: ~typing.ItemsView """ return self._data.items() @@ -444,7 +482,7 @@ def get(self, key: str, default: typing.Any = None) -> typing.Any: Get the value for key if key is in the dictionary, else default. :param str key: The key to look up. :param any default: The value to return if key is not in the dictionary. Defaults to None - :returns: D[k] if k in D, else d. + :returns: The value for key if key is in the dictionary, else default. :rtype: any """ try: @@ -479,19 +517,19 @@ def popitem(self) -> tuple[str, typing.Any]: Removes and returns some (key, value) pair :returns: The (key, value) pair. :rtype: tuple - :raises KeyError: if D is empty. + :raises KeyError: if the dictionary is empty. """ return self._data.popitem() def clear(self) -> None: """ - Remove all items from D. + Remove all items from the dictionary. """ self._data.clear() def update(self, *args: typing.Any, **kwargs: typing.Any) -> None: # pylint: disable=arguments-differ """ - Updates D from mapping/iterable E and F. + Update the dictionary from a mapping or an iterable of key-value pairs. :param any args: Either a mapping object or an iterable of key-value pairs. """ self._data.update(*args, **kwargs) @@ -504,10 +542,11 @@ def setdefault(self, key: str, default: typing.Any) -> typing.Any: ... # pylint def setdefault(self, key: str, default: typing.Any = _UNSET) -> typing.Any: """ - Same as calling D.get(k, d), and setting D[k]=d if k not found + Return the value for key if key is in the dictionary; otherwise set the key to + default and return default. :param str key: The key to look up. :param any default: The value to set if key is not in the dictionary - :returns: D[k] if k in D, else d. + :returns: The value for key if key is in the dictionary, else default. :rtype: any """ if default is _UNSET: @@ -559,7 +598,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 +624,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 +867,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 +887,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 +1022,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 +1053,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 +1399,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 +1412,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 +1432,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 +1448,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 +1498,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 +1508,7 @@ def rest_field( format=format, is_multipart_file_input=is_multipart_file_input, xml=xml, + deserializer=deserializer, ) @@ -1190,6 +1533,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 +1594,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 +1625,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 +1639,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 +1648,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 +1656,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 +1665,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 +1686,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 +1709,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 +1742,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/search/azure-mgmt-search/azure/mgmt/search/_utils/serialization.py b/sdk/search/azure-mgmt-search/azure/mgmt/search/_utils/serialization.py index 81ec1de5922b..75906e2eb77f 100644 --- a/sdk/search/azure-mgmt-search/azure/mgmt/search/_utils/serialization.py +++ b/sdk/search/azure-mgmt-search/azure/mgmt/search/_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/search/azure-mgmt-search/azure/mgmt/search/_version.py b/sdk/search/azure-mgmt-search/azure/mgmt/search/_version.py index c36aac0dab1b..ddc0df91695f 100644 --- a/sdk/search/azure-mgmt-search/azure/mgmt/search/_version.py +++ b/sdk/search/azure-mgmt-search/azure/mgmt/search/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "10.0.0b1" +VERSION = "10.0.0b2" diff --git a/sdk/search/azure-mgmt-search/azure/mgmt/search/aio/_client.py b/sdk/search/azure-mgmt-search/azure/mgmt/search/aio/_client.py index b0fd108882b4..0d70b0ba3e31 100644 --- a/sdk/search/azure-mgmt-search/azure/mgmt/search/aio/_client.py +++ b/sdk/search/azure-mgmt-search/azure/mgmt/search/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 @@ -33,6 +33,11 @@ _SearchManagementClientOperationsMixin, ) +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 @@ -76,8 +81,9 @@ class SearchManagementClient(_SearchManagementClientOperationsMixin): # pylint: None. :paramtype cloud_setting: ~azure.core.AzureClouds :keyword api_version: The API version to use for this operation. Known values are - "2026-03-01-preview". Default value is "2026-03-01-preview". Note that overriding this default - value may result in unsupported behavior. + "2026-09-01-preview" and None. Default value is None. If not set, the operation's default API + version will be used. Note that overriding this default value may result in unsupported + behavior. :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/search/azure-mgmt-search/azure/mgmt/search/aio/_configuration.py b/sdk/search/azure-mgmt-search/azure/mgmt/search/aio/_configuration.py index f4dd4d3f5987..74595f165363 100644 --- a/sdk/search/azure-mgmt-search/azure/mgmt/search/aio/_configuration.py +++ b/sdk/search/azure-mgmt-search/azure/mgmt/search/aio/_configuration.py @@ -34,8 +34,9 @@ class SearchManagementClientConfiguration: # pylint: disable=too-many-instance- None. :type cloud_setting: ~azure.core.AzureClouds :keyword api_version: The API version to use for this operation. Known values are - "2026-03-01-preview". Default value is "2026-03-01-preview". Note that overriding this default - value may result in unsupported behavior. + "2026-09-01-preview" and None. Default value is None. If not set, the operation's default API + version will be used. Note that overriding this default value may result in unsupported + behavior. :paramtype api_version: str """ @@ -47,7 +48,7 @@ def __init__( cloud_setting: Optional["AzureClouds"] = None, **kwargs: Any ) -> None: - api_version: str = kwargs.pop("api_version", "2026-03-01-preview") + api_version: str = kwargs.pop("api_version", "2026-09-01-preview") if credential is None: raise ValueError("Parameter 'credential' must not be None.") diff --git a/sdk/search/azure-mgmt-search/azure/mgmt/search/aio/operations/_operations.py b/sdk/search/azure-mgmt-search/azure/mgmt/search/aio/operations/_operations.py index 61543ee8e5ce..bc7ad4a33e24 100644 --- a/sdk/search/azure-mgmt-search/azure/mgmt/search/aio/operations/_operations.py +++ b/sdk/search/azure-mgmt-search/azure/mgmt/search/aio/operations/_operations.py @@ -33,7 +33,7 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling -from ... import models as _models +from ... import models as _models, types as _types from ..._utils.model_base import SdkJSONEncoder, _deserialize, _failsafe_deserialize from ..._utils.serialization import Deserializer, Serializer from ..._utils.utils import ClientMixinABC @@ -44,7 +44,7 @@ build_network_security_perimeter_configurations_get_request, build_network_security_perimeter_configurations_list_by_service_request, build_network_security_perimeter_configurations_reconcile_request, - build_offerings_list_request, + build_offerings_fetch_request, build_operations_list_request, build_private_endpoint_connections_delete_request, build_private_endpoint_connections_get_request, @@ -73,7 +73,6 @@ T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, dict[str, Any]], Any]] -JSON = MutableMapping[str, Any] List = list @@ -96,18 +95,16 @@ def __init__(self, *args, **kwargs) -> None: @distributed_trace_async @api_version_validation( - method_added_on="2026-03-01-preview", - params_added_on={"2026-03-01-preview": ["api_version", "accept"]}, - api_versions_list=["2026-03-01-preview"], + method_added_on="2026-09-01-preview", + params_added_on={"2026-09-01-preview": ["api_version", "accept"]}, + api_versions_list=["2026-09-01-preview"], ) - async def list(self, **kwargs: Any) -> _models.OfferingsListResult: - """Lists all of the features and SKUs offered by the Azure AI Search service in each region. Note: - This API returns a non-ARM resource collection and is not RPC-compliant. It will be replaced - with an action-style API in the next preview as a breaking change. Customers should avoid - taking new dependencies on the current shape. - - :return: OfferingsListResult. The OfferingsListResult is compatible with MutableMapping - :rtype: ~azure.mgmt.search.models.OfferingsListResult + async def fetch(self, **kwargs: Any) -> _models.OfferingsResult: + """Fetches the features and SKUs offered by the Azure AI Search service in each region, along with + the recommended default region for creating new services. + + :return: OfferingsResult. The OfferingsResult is compatible with MutableMapping + :rtype: ~azure.mgmt.search.models.OfferingsResult :raises ~azure.core.exceptions.HttpResponseError: """ error_map: MutableMapping = { @@ -121,9 +118,9 @@ async def list(self, **kwargs: Any) -> _models.OfferingsListResult: _headers = kwargs.pop("headers", {}) or {} _params = kwargs.pop("params", {}) or {} - cls: ClsType[_models.OfferingsListResult] = kwargs.pop("cls", None) + cls: ClsType[_models.OfferingsResult] = kwargs.pop("cls", None) - _request = build_offerings_list_request( + _request = build_offerings_fetch_request( api_version=self._config.api_version, headers=_headers, params=_params, @@ -157,7 +154,7 @@ async def list(self, **kwargs: Any) -> _models.OfferingsListResult: if _stream: deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: - deserialized = _deserialize(_models.OfferingsListResult, response.json()) + deserialized = _deserialize(_models.OfferingsResult, response.json()) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -229,7 +226,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( @@ -408,7 +408,7 @@ async def update( resource_group_name: str, search_service_name: str, private_endpoint_connection_name: str, - private_endpoint_connection: JSON, + private_endpoint_connection: _types.PrivateEndpointConnection, *, content_type: str = "application/json", **kwargs: Any @@ -426,7 +426,7 @@ async def update( :type private_endpoint_connection_name: str :param private_endpoint_connection: The definition of the private endpoint connection to update. Required. - :type private_endpoint_connection: JSON + :type private_endpoint_connection: ~azure.mgmt.search.types.PrivateEndpointConnection :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -476,7 +476,9 @@ async def update( resource_group_name: str, search_service_name: str, private_endpoint_connection_name: str, - private_endpoint_connection: Union[_models.PrivateEndpointConnection, JSON, IO[bytes]], + private_endpoint_connection: Union[ + _models.PrivateEndpointConnection, _types.PrivateEndpointConnection, IO[bytes] + ], **kwargs: Any ) -> _models.PrivateEndpointConnection: """Updates a private endpoint connection to the search service in the given resource group. @@ -491,9 +493,9 @@ async def update( Azure AI Search service with the specified resource group. Required. :type private_endpoint_connection_name: str :param private_endpoint_connection: The definition of the private endpoint connection to - update. Is one of the following types: PrivateEndpointConnection, JSON, IO[bytes] Required. - :type private_endpoint_connection: ~azure.mgmt.search.models.PrivateEndpointConnection or JSON - or IO[bytes] + update. Is either a PrivateEndpointConnection type or a IO[bytes] type. Required. + :type private_endpoint_connection: ~azure.mgmt.search.models.PrivateEndpointConnection or + ~azure.mgmt.search.types.PrivateEndpointConnection or IO[bytes] :return: PrivateEndpointConnection. The PrivateEndpointConnection is compatible with MutableMapping :rtype: ~azure.mgmt.search.models.PrivateEndpointConnection @@ -710,7 +712,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( @@ -854,7 +859,9 @@ async def _create_or_update_initial( resource_group_name: str, search_service_name: str, shared_private_link_resource_name: str, - shared_private_link_resource: Union[_models.SharedPrivateLinkResource, JSON, IO[bytes]], + shared_private_link_resource: Union[ + _models.SharedPrivateLinkResource, _types.SharedPrivateLinkResource, IO[bytes] + ], **kwargs: Any ) -> AsyncIterator[bytes]: error_map: MutableMapping = { @@ -968,7 +975,7 @@ async def begin_create_or_update( resource_group_name: str, search_service_name: str, shared_private_link_resource_name: str, - shared_private_link_resource: JSON, + shared_private_link_resource: _types.SharedPrivateLinkResource, *, content_type: str = "application/json", **kwargs: Any @@ -987,7 +994,7 @@ async def begin_create_or_update( :type shared_private_link_resource_name: str :param shared_private_link_resource: The definition of the shared private link resource to create or update. Required. - :type shared_private_link_resource: JSON + :type shared_private_link_resource: ~azure.mgmt.search.types.SharedPrivateLinkResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -1038,7 +1045,9 @@ async def begin_create_or_update( resource_group_name: str, search_service_name: str, shared_private_link_resource_name: str, - shared_private_link_resource: Union[_models.SharedPrivateLinkResource, JSON, IO[bytes]], + shared_private_link_resource: Union[ + _models.SharedPrivateLinkResource, _types.SharedPrivateLinkResource, IO[bytes] + ], **kwargs: Any ) -> AsyncLROPoller[_models.SharedPrivateLinkResource]: """Initiates the creation or update of a shared private link resource managed by the search @@ -1054,10 +1063,9 @@ async def begin_create_or_update( by the Azure AI Search service within the specified resource group. Required. :type shared_private_link_resource_name: str :param shared_private_link_resource: The definition of the shared private link resource to - create or update. Is one of the following types: SharedPrivateLinkResource, JSON, IO[bytes] - Required. - :type shared_private_link_resource: ~azure.mgmt.search.models.SharedPrivateLinkResource or JSON - or IO[bytes] + create or update. Is either a SharedPrivateLinkResource type or a IO[bytes] type. Required. + :type shared_private_link_resource: ~azure.mgmt.search.models.SharedPrivateLinkResource or + ~azure.mgmt.search.types.SharedPrivateLinkResource or IO[bytes] :return: An instance of AsyncLROPoller that returns SharedPrivateLinkResource. The SharedPrivateLinkResource is compatible with MutableMapping :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.search.models.SharedPrivateLinkResource] @@ -1307,7 +1315,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( @@ -1503,7 +1514,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( @@ -1713,14 +1727,18 @@ async def check_name_availability( @overload async def check_name_availability( - self, check_name_availability_input: JSON, *, content_type: str = "application/json", **kwargs: Any + self, + check_name_availability_input: _types.CheckNameAvailabilityInput, + *, + content_type: str = "application/json", + **kwargs: Any ) -> _models.CheckNameAvailabilityOutput: """Checks whether or not the given search service name is available for use. Search service names must be globally unique since they are part of the service URI (https://.search.windows.net). :param check_name_availability_input: The request body. Required. - :type check_name_availability_input: JSON + :type check_name_availability_input: ~azure.mgmt.search.types.CheckNameAvailabilityInput :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -1751,16 +1769,20 @@ async def check_name_availability( @distributed_trace_async async def check_name_availability( - self, check_name_availability_input: Union[_models.CheckNameAvailabilityInput, JSON, IO[bytes]], **kwargs: Any + self, + check_name_availability_input: Union[ + _models.CheckNameAvailabilityInput, _types.CheckNameAvailabilityInput, IO[bytes] + ], + **kwargs: Any ) -> _models.CheckNameAvailabilityOutput: """Checks whether or not the given search service name is available for use. Search service names must be globally unique since they are part of the service URI (https://.search.windows.net). - :param check_name_availability_input: The request body. Is one of the following types: - CheckNameAvailabilityInput, JSON, IO[bytes] Required. + :param check_name_availability_input: The request body. Is either a CheckNameAvailabilityInput + type or a IO[bytes] type. Required. :type check_name_availability_input: ~azure.mgmt.search.models.CheckNameAvailabilityInput or - JSON or IO[bytes] + ~azure.mgmt.search.types.CheckNameAvailabilityInput or IO[bytes] :return: CheckNameAvailabilityOutput. The CheckNameAvailabilityOutput is compatible with MutableMapping :rtype: ~azure.mgmt.search.models.CheckNameAvailabilityOutput @@ -1906,7 +1928,7 @@ async def _create_or_update_initial( self, resource_group_name: str, search_service_name: str, - service: Union[_models.SearchService, JSON, IO[bytes]], + service: Union[_models.SearchService, _types.SearchService, IO[bytes]], **kwargs: Any ) -> AsyncIterator[bytes]: error_map: MutableMapping = { @@ -2014,7 +2036,7 @@ async def begin_create_or_update( self, resource_group_name: str, search_service_name: str, - service: JSON, + service: _types.SearchService, *, content_type: str = "application/json", **kwargs: Any @@ -2031,7 +2053,7 @@ async def begin_create_or_update( :param service: The definition of the search service to create or update. Create applies to both serverless and dedicated search services; update applies only to dedicated search services. Required. - :type service: JSON + :type service: ~azure.mgmt.search.types.SearchService :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -2078,7 +2100,7 @@ async def begin_create_or_update( self, resource_group_name: str, search_service_name: str, - service: Union[_models.SearchService, JSON, IO[bytes]], + service: Union[_models.SearchService, _types.SearchService, IO[bytes]], **kwargs: Any ) -> AsyncLROPoller[_models.SearchService]: """Creates or updates a search service in the given resource group. If the search service already @@ -2092,8 +2114,9 @@ async def begin_create_or_update( :type search_service_name: str :param service: The definition of the search service to create or update. Create applies to both serverless and dedicated search services; update applies only to dedicated search - services. Is one of the following types: SearchService, JSON, IO[bytes] Required. - :type service: ~azure.mgmt.search.models.SearchService or JSON or IO[bytes] + services. Is either a SearchService type or a IO[bytes] type. Required. + :type service: ~azure.mgmt.search.models.SearchService or + ~azure.mgmt.search.types.SearchService or IO[bytes] :return: An instance of AsyncLROPoller that returns SearchService. The SearchService is compatible with MutableMapping :rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.search.models.SearchService] @@ -2184,7 +2207,7 @@ async def update( self, resource_group_name: str, search_service_name: str, - service: JSON, + service: _types.SearchServiceUpdate, *, content_type: str = "application/json", **kwargs: Any @@ -2198,7 +2221,7 @@ async def update( specified resource group. Required. :type search_service_name: str :param service: The definition of the search service to update. Required. - :type service: JSON + :type service: ~azure.mgmt.search.types.SearchServiceUpdate :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -2240,7 +2263,7 @@ async def update( self, resource_group_name: str, search_service_name: str, - service: Union[_models.SearchServiceUpdate, JSON, IO[bytes]], + service: Union[_models.SearchServiceUpdate, _types.SearchServiceUpdate, IO[bytes]], **kwargs: Any ) -> _models.SearchService: """Updates an existing search service in the given resource group. @@ -2251,9 +2274,10 @@ async def update( :param search_service_name: The name of the Azure AI Search service associated with the specified resource group. Required. :type search_service_name: str - :param service: The definition of the search service to update. Is one of the following types: - SearchServiceUpdate, JSON, IO[bytes] Required. - :type service: ~azure.mgmt.search.models.SearchServiceUpdate or JSON or IO[bytes] + :param service: The definition of the search service to update. Is either a SearchServiceUpdate + type or a IO[bytes] type. Required. + :type service: ~azure.mgmt.search.models.SearchServiceUpdate or + ~azure.mgmt.search.types.SearchServiceUpdate or IO[bytes] :return: SearchService. The SearchService is compatible with MutableMapping :rtype: ~azure.mgmt.search.models.SearchService :raises ~azure.core.exceptions.HttpResponseError: @@ -2438,7 +2462,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( @@ -2528,7 +2555,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( @@ -2668,14 +2698,10 @@ async def begin_upgrade( kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - response_headers = {} response = pipeline_response.http_response - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = _deserialize(_models.SearchService, response.json()) if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore + return cls(pipeline_response, deserialized, {}) # type: ignore return deserialized path_format_arguments = { @@ -2770,7 +2796,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( @@ -3136,7 +3165,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( @@ -3321,7 +3353,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/search/azure-mgmt-search/azure/mgmt/search/models/__init__.py b/sdk/search/azure-mgmt-search/azure/mgmt/search/models/__init__.py index 68fd69620d66..9e6cd375f8ea 100644 --- a/sdk/search/azure-mgmt-search/azure/mgmt/search/models/__init__.py +++ b/sdk/search/azure-mgmt-search/azure/mgmt/search/models/__init__.py @@ -38,7 +38,7 @@ NetworkSecurityPerimeterConfigurationProperties, NetworkSecurityProfile, OfferingsByRegion, - OfferingsListResult, + OfferingsResult, Operation, OperationDisplay, PrivateEndpointConnection, @@ -76,6 +76,7 @@ AccessRuleDirection, ActionType, AdminKeyKind, + AutoGeneratedDomainNameLabelScope, ComputeType, CreatedByType, HostingMode, @@ -131,7 +132,7 @@ "NetworkSecurityPerimeterConfigurationProperties", "NetworkSecurityProfile", "OfferingsByRegion", - "OfferingsListResult", + "OfferingsResult", "Operation", "OperationDisplay", "PrivateEndpointConnection", @@ -166,6 +167,7 @@ "AccessRuleDirection", "ActionType", "AdminKeyKind", + "AutoGeneratedDomainNameLabelScope", "ComputeType", "CreatedByType", "HostingMode", diff --git a/sdk/search/azure-mgmt-search/azure/mgmt/search/models/_enums.py b/sdk/search/azure-mgmt-search/azure/mgmt/search/models/_enums.py index 7ae5372c1561..4caa7c85c8b9 100644 --- a/sdk/search/azure-mgmt-search/azure/mgmt/search/models/_enums.py +++ b/sdk/search/azure-mgmt-search/azure/mgmt/search/models/_enums.py @@ -50,6 +50,18 @@ class AdminKeyKind(str, Enum, metaclass=CaseInsensitiveEnumMeta): """The secondary API key for the search service.""" +class AutoGeneratedDomainNameLabelScope(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Defines the level of reuse for the auto-generated domain name label for the search service.""" + + TENANT_REUSE = "TenantReuse" + """Service name will always have the same auto-generated hash within the same tenant.""" + SUBSCRIPTION_REUSE = "SubscriptionReuse" + """Service name will always have the same auto-generated hash within the same subscription.""" + NO_REUSE = "NoReuse" + """Service name will always have a unique auto-generated hash (regardless of tenant or + subscription).""" + + class ComputeType(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Configure this property to support the search service using either the Default Compute or Azure Confidential Compute. diff --git a/sdk/search/azure-mgmt-search/azure/mgmt/search/models/_models.py b/sdk/search/azure-mgmt-search/azure/mgmt/search/models/_models.py index b7617cbf7bfc..a86d9d3127c3 100644 --- a/sdk/search/azure-mgmt-search/azure/mgmt/search/models/_models.py +++ b/sdk/search/azure-mgmt-search/azure/mgmt/search/models/_models.py @@ -1039,19 +1039,20 @@ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) -class OfferingsListResult(_Model): - """Response containing the list of offerings available in Azure AI Search, organized by region. - - :ivar value: The list of Azure AI Search offerings by region. - :vartype value: list[~azure.mgmt.search.models.OfferingsByRegion] - :ivar next_link: The URL to get the next set of offerings, if any. - :vartype next_link: str +class OfferingsResult(_Model): + """Response containing the available Azure AI Search offerings, organized by region, along with + the recommended default region for creating new services. + + :ivar default_region: The recommended default region for creating new Azure AI Search services. + :vartype default_region: str + :ivar regions: The list of Azure AI Search offerings by region. + :vartype regions: list[~azure.mgmt.search.models.OfferingsByRegion] """ - value: Optional[list["_models.OfferingsByRegion"]] = rest_field(visibility=["read"]) + default_region: Optional[str] = rest_field(name="defaultRegion", visibility=["read"]) + """The recommended default region for creating new Azure AI Search services.""" + regions: Optional[list["_models.OfferingsByRegion"]] = rest_field(visibility=["read"]) """The list of Azure AI Search offerings by region.""" - next_link: Optional[str] = rest_field(name="nextLink", visibility=["read"]) - """The URL to get the next set of offerings, if any.""" class Operation(_Model): @@ -1732,6 +1733,7 @@ class SearchService(TrackedResource): "semantic_search", "knowledge_retrieval", "private_endpoint_connections", + "auto_generated_domain_name_label_scope", "shared_private_link_resources", "e_tag", "upgrade_available", @@ -1861,6 +1863,12 @@ class SearchServiceProperties(_Model): Search service. :vartype private_endpoint_connections: list[~azure.mgmt.search.models.PrivateEndpointConnection] + :ivar auto_generated_domain_name_label_scope: Defines the level of reuse for the auto-generated + domain name label for the search service (e.g. myservice-.search.windows.net). If not + specified, no auto-generated domain name label is created for the search service. Known values + are: "TenantReuse", "SubscriptionReuse", and "NoReuse". + :vartype auto_generated_domain_name_label_scope: str or + ~azure.mgmt.search.models.AutoGeneratedDomainNameLabelScope :ivar shared_private_link_resources: The list of shared private link resources managed by the Azure AI Search service. :vartype shared_private_link_resources: @@ -1976,6 +1984,13 @@ class SearchServiceProperties(_Model): name="privateEndpointConnections", visibility=["read"] ) """The list of private endpoint connections to the Azure AI Search service.""" + auto_generated_domain_name_label_scope: Optional[Union[str, "_models.AutoGeneratedDomainNameLabelScope"]] = ( + rest_field(name="autoGeneratedDomainNameLabelScope", visibility=["read", "create"]) + ) + """Defines the level of reuse for the auto-generated domain name label for the search service + (e.g. myservice-.search.windows.net). If not specified, no auto-generated domain name + label is created for the search service. Known values are: \"TenantReuse\", + \"SubscriptionReuse\", and \"NoReuse\".""" shared_private_link_resources: Optional[list["_models.SharedPrivateLinkResource"]] = rest_field( name="sharedPrivateLinkResources", visibility=["read"] ) @@ -2011,6 +2026,9 @@ def __init__( auth_options: Optional["_models.DataPlaneAuthOptions"] = None, semantic_search: Optional[Union[str, "_models.SearchSemanticSearch"]] = None, knowledge_retrieval: Optional[Union[str, "_models.KnowledgeRetrieval"]] = None, + auto_generated_domain_name_label_scope: Optional[ + Union[str, "_models.AutoGeneratedDomainNameLabelScope"] + ] = None, upgrade_available: Optional[Union[str, "_models.UpgradeAvailable"]] = None, ) -> None: ... @@ -2090,6 +2108,7 @@ class SearchServiceUpdate(Resource): "semantic_search", "knowledge_retrieval", "private_endpoint_connections", + "auto_generated_domain_name_label_scope", "shared_private_link_resources", "e_tag", "upgrade_available", diff --git a/sdk/search/azure-mgmt-search/azure/mgmt/search/operations/_operations.py b/sdk/search/azure-mgmt-search/azure/mgmt/search/operations/_operations.py index 94eb0efa70f5..6fc11920d96d 100644 --- a/sdk/search/azure-mgmt-search/azure/mgmt/search/operations/_operations.py +++ b/sdk/search/azure-mgmt-search/azure/mgmt/search/operations/_operations.py @@ -32,7 +32,7 @@ from azure.mgmt.core.exceptions import ARMErrorFormat from azure.mgmt.core.polling.arm_polling import ARMPolling -from .. import models as _models +from .. import models as _models, types as _types from .._configuration import SearchManagementClientConfiguration from .._utils.model_base import SdkJSONEncoder, _deserialize, _failsafe_deserialize from .._utils.serialization import Deserializer, Serializer @@ -41,22 +41,21 @@ T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, dict[str, Any]], Any]] -JSON = MutableMapping[str, Any] List = list _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False -def build_offerings_list_request(**kwargs: Any) -> HttpRequest: +def build_offerings_fetch_request(**kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL - _url = "/providers/Microsoft.Search/offerings" + _url = "/providers/Microsoft.Search/fetchOfferings" # Construct parameters _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") @@ -64,14 +63,14 @@ def build_offerings_list_request(**kwargs: Any) -> HttpRequest: # Construct headers _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) def build_operations_list_request(**kwargs: Any) -> HttpRequest: _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -96,7 +95,7 @@ def build_private_endpoint_connections_get_request( # pylint: disable=name-too- _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -132,7 +131,7 @@ def build_private_endpoint_connections_update_request( # pylint: disable=name-t _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -169,7 +168,7 @@ def build_private_endpoint_connections_delete_request( # pylint: disable=name-t _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -200,7 +199,7 @@ def build_private_endpoint_connections_list_by_service_request( # pylint: disab _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -232,7 +231,7 @@ def build_shared_private_link_resources_get_request( # pylint: disable=name-too _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -268,7 +267,7 @@ def build_shared_private_link_resources_create_or_update_request( # pylint: dis _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -305,7 +304,7 @@ def build_shared_private_link_resources_delete_request( # pylint: disable=name- _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) # Construct URL _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Search/searchServices/{searchServiceName}/sharedPrivateLinkResources/{sharedPrivateLinkResourceName}" path_format_arguments = { @@ -333,7 +332,7 @@ def build_shared_private_link_resources_list_by_service_request( # pylint: disa _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -361,7 +360,7 @@ def build_network_security_perimeter_configurations_get_request( # pylint: disa _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -390,7 +389,7 @@ def build_network_security_perimeter_configurations_list_by_service_request( # _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -417,7 +416,7 @@ def build_network_security_perimeter_configurations_reconcile_request( # pylint ) -> HttpRequest: _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) # Construct URL _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Search/searchServices/{searchServiceName}/networkSecurityPerimeterConfigurations/{nspConfigName}/reconcile" path_format_arguments = { @@ -442,7 +441,7 @@ def build_services_check_name_availability_request( # pylint: disable=name-too- _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -470,7 +469,7 @@ def build_services_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -499,7 +498,7 @@ def build_services_create_or_update_request( _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -530,7 +529,7 @@ def build_services_update_request( _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -560,7 +559,7 @@ def build_services_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) # Construct URL _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Search/searchServices/{searchServiceName}" path_format_arguments = { @@ -585,7 +584,7 @@ def build_services_list_by_resource_group_request( # pylint: disable=name-too-l _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -614,7 +613,7 @@ def build_services_list_by_subscription_request( # pylint: disable=name-too-lon _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -640,7 +639,7 @@ def build_services_upgrade_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -668,7 +667,7 @@ def build_usages_list_by_subscription_request( # pylint: disable=name-too-long _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -695,7 +694,7 @@ def build_admin_keys_get_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -727,7 +726,7 @@ def build_admin_keys_regenerate_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -756,7 +755,7 @@ def build_query_keys_create_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -785,7 +784,7 @@ def build_query_keys_list_by_search_service_request( # pylint: disable=name-too _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -813,7 +812,7 @@ def build_query_keys_delete_request( _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) # Construct URL _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Search/searchServices/{searchServiceName}/deleteQueryKey/{key}" path_format_arguments = { @@ -839,7 +838,7 @@ def build_private_link_resources_list_supported_request( # pylint: disable=name _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -867,7 +866,7 @@ def build_search_management_usage_by_subscription_sku_request( # pylint: disabl _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-03-01-preview")) + api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2026-09-01-preview")) accept = _headers.pop("Accept", "application/json") # Construct URL @@ -908,18 +907,16 @@ def __init__(self, *args, **kwargs) -> None: @distributed_trace @api_version_validation( - method_added_on="2026-03-01-preview", - params_added_on={"2026-03-01-preview": ["api_version", "accept"]}, - api_versions_list=["2026-03-01-preview"], + method_added_on="2026-09-01-preview", + params_added_on={"2026-09-01-preview": ["api_version", "accept"]}, + api_versions_list=["2026-09-01-preview"], ) - def list(self, **kwargs: Any) -> _models.OfferingsListResult: - """Lists all of the features and SKUs offered by the Azure AI Search service in each region. Note: - This API returns a non-ARM resource collection and is not RPC-compliant. It will be replaced - with an action-style API in the next preview as a breaking change. Customers should avoid - taking new dependencies on the current shape. - - :return: OfferingsListResult. The OfferingsListResult is compatible with MutableMapping - :rtype: ~azure.mgmt.search.models.OfferingsListResult + def fetch(self, **kwargs: Any) -> _models.OfferingsResult: + """Fetches the features and SKUs offered by the Azure AI Search service in each region, along with + the recommended default region for creating new services. + + :return: OfferingsResult. The OfferingsResult is compatible with MutableMapping + :rtype: ~azure.mgmt.search.models.OfferingsResult :raises ~azure.core.exceptions.HttpResponseError: """ error_map: MutableMapping = { @@ -933,9 +930,9 @@ def list(self, **kwargs: Any) -> _models.OfferingsListResult: _headers = kwargs.pop("headers", {}) or {} _params = kwargs.pop("params", {}) or {} - cls: ClsType[_models.OfferingsListResult] = kwargs.pop("cls", None) + cls: ClsType[_models.OfferingsResult] = kwargs.pop("cls", None) - _request = build_offerings_list_request( + _request = build_offerings_fetch_request( api_version=self._config.api_version, headers=_headers, params=_params, @@ -969,7 +966,7 @@ def list(self, **kwargs: Any) -> _models.OfferingsListResult: if _stream: deserialized = response.iter_bytes() if _decompress else response.iter_raw() else: - deserialized = _deserialize(_models.OfferingsListResult, response.json()) + deserialized = _deserialize(_models.OfferingsResult, response.json()) if cls: return cls(pipeline_response, deserialized, {}) # type: ignore @@ -1041,7 +1038,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( @@ -1220,7 +1220,7 @@ def update( resource_group_name: str, search_service_name: str, private_endpoint_connection_name: str, - private_endpoint_connection: JSON, + private_endpoint_connection: _types.PrivateEndpointConnection, *, content_type: str = "application/json", **kwargs: Any @@ -1238,7 +1238,7 @@ def update( :type private_endpoint_connection_name: str :param private_endpoint_connection: The definition of the private endpoint connection to update. Required. - :type private_endpoint_connection: JSON + :type private_endpoint_connection: ~azure.mgmt.search.types.PrivateEndpointConnection :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -1288,7 +1288,9 @@ def update( resource_group_name: str, search_service_name: str, private_endpoint_connection_name: str, - private_endpoint_connection: Union[_models.PrivateEndpointConnection, JSON, IO[bytes]], + private_endpoint_connection: Union[ + _models.PrivateEndpointConnection, _types.PrivateEndpointConnection, IO[bytes] + ], **kwargs: Any ) -> _models.PrivateEndpointConnection: """Updates a private endpoint connection to the search service in the given resource group. @@ -1303,9 +1305,9 @@ def update( Azure AI Search service with the specified resource group. Required. :type private_endpoint_connection_name: str :param private_endpoint_connection: The definition of the private endpoint connection to - update. Is one of the following types: PrivateEndpointConnection, JSON, IO[bytes] Required. - :type private_endpoint_connection: ~azure.mgmt.search.models.PrivateEndpointConnection or JSON - or IO[bytes] + update. Is either a PrivateEndpointConnection type or a IO[bytes] type. Required. + :type private_endpoint_connection: ~azure.mgmt.search.models.PrivateEndpointConnection or + ~azure.mgmt.search.types.PrivateEndpointConnection or IO[bytes] :return: PrivateEndpointConnection. The PrivateEndpointConnection is compatible with MutableMapping :rtype: ~azure.mgmt.search.models.PrivateEndpointConnection @@ -1521,7 +1523,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( @@ -1665,7 +1670,9 @@ def _create_or_update_initial( resource_group_name: str, search_service_name: str, shared_private_link_resource_name: str, - shared_private_link_resource: Union[_models.SharedPrivateLinkResource, JSON, IO[bytes]], + shared_private_link_resource: Union[ + _models.SharedPrivateLinkResource, _types.SharedPrivateLinkResource, IO[bytes] + ], **kwargs: Any ) -> Iterator[bytes]: error_map: MutableMapping = { @@ -1779,7 +1786,7 @@ def begin_create_or_update( resource_group_name: str, search_service_name: str, shared_private_link_resource_name: str, - shared_private_link_resource: JSON, + shared_private_link_resource: _types.SharedPrivateLinkResource, *, content_type: str = "application/json", **kwargs: Any @@ -1798,7 +1805,7 @@ def begin_create_or_update( :type shared_private_link_resource_name: str :param shared_private_link_resource: The definition of the shared private link resource to create or update. Required. - :type shared_private_link_resource: JSON + :type shared_private_link_resource: ~azure.mgmt.search.types.SharedPrivateLinkResource :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -1849,7 +1856,9 @@ def begin_create_or_update( resource_group_name: str, search_service_name: str, shared_private_link_resource_name: str, - shared_private_link_resource: Union[_models.SharedPrivateLinkResource, JSON, IO[bytes]], + shared_private_link_resource: Union[ + _models.SharedPrivateLinkResource, _types.SharedPrivateLinkResource, IO[bytes] + ], **kwargs: Any ) -> LROPoller[_models.SharedPrivateLinkResource]: """Initiates the creation or update of a shared private link resource managed by the search @@ -1865,10 +1874,9 @@ def begin_create_or_update( by the Azure AI Search service within the specified resource group. Required. :type shared_private_link_resource_name: str :param shared_private_link_resource: The definition of the shared private link resource to - create or update. Is one of the following types: SharedPrivateLinkResource, JSON, IO[bytes] - Required. - :type shared_private_link_resource: ~azure.mgmt.search.models.SharedPrivateLinkResource or JSON - or IO[bytes] + create or update. Is either a SharedPrivateLinkResource type or a IO[bytes] type. Required. + :type shared_private_link_resource: ~azure.mgmt.search.models.SharedPrivateLinkResource or + ~azure.mgmt.search.types.SharedPrivateLinkResource or IO[bytes] :return: An instance of LROPoller that returns SharedPrivateLinkResource. The SharedPrivateLinkResource is compatible with MutableMapping :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.search.models.SharedPrivateLinkResource] @@ -2117,7 +2125,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( @@ -2313,7 +2324,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( @@ -2523,14 +2537,18 @@ def check_name_availability( @overload def check_name_availability( - self, check_name_availability_input: JSON, *, content_type: str = "application/json", **kwargs: Any + self, + check_name_availability_input: _types.CheckNameAvailabilityInput, + *, + content_type: str = "application/json", + **kwargs: Any ) -> _models.CheckNameAvailabilityOutput: """Checks whether or not the given search service name is available for use. Search service names must be globally unique since they are part of the service URI (https://.search.windows.net). :param check_name_availability_input: The request body. Required. - :type check_name_availability_input: JSON + :type check_name_availability_input: ~azure.mgmt.search.types.CheckNameAvailabilityInput :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -2561,16 +2579,20 @@ def check_name_availability( @distributed_trace def check_name_availability( - self, check_name_availability_input: Union[_models.CheckNameAvailabilityInput, JSON, IO[bytes]], **kwargs: Any + self, + check_name_availability_input: Union[ + _models.CheckNameAvailabilityInput, _types.CheckNameAvailabilityInput, IO[bytes] + ], + **kwargs: Any ) -> _models.CheckNameAvailabilityOutput: """Checks whether or not the given search service name is available for use. Search service names must be globally unique since they are part of the service URI (https://.search.windows.net). - :param check_name_availability_input: The request body. Is one of the following types: - CheckNameAvailabilityInput, JSON, IO[bytes] Required. + :param check_name_availability_input: The request body. Is either a CheckNameAvailabilityInput + type or a IO[bytes] type. Required. :type check_name_availability_input: ~azure.mgmt.search.models.CheckNameAvailabilityInput or - JSON or IO[bytes] + ~azure.mgmt.search.types.CheckNameAvailabilityInput or IO[bytes] :return: CheckNameAvailabilityOutput. The CheckNameAvailabilityOutput is compatible with MutableMapping :rtype: ~azure.mgmt.search.models.CheckNameAvailabilityOutput @@ -2716,7 +2738,7 @@ def _create_or_update_initial( self, resource_group_name: str, search_service_name: str, - service: Union[_models.SearchService, JSON, IO[bytes]], + service: Union[_models.SearchService, _types.SearchService, IO[bytes]], **kwargs: Any ) -> Iterator[bytes]: error_map: MutableMapping = { @@ -2824,7 +2846,7 @@ def begin_create_or_update( self, resource_group_name: str, search_service_name: str, - service: JSON, + service: _types.SearchService, *, content_type: str = "application/json", **kwargs: Any @@ -2841,7 +2863,7 @@ def begin_create_or_update( :param service: The definition of the search service to create or update. Create applies to both serverless and dedicated search services; update applies only to dedicated search services. Required. - :type service: JSON + :type service: ~azure.mgmt.search.types.SearchService :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -2888,7 +2910,7 @@ def begin_create_or_update( self, resource_group_name: str, search_service_name: str, - service: Union[_models.SearchService, JSON, IO[bytes]], + service: Union[_models.SearchService, _types.SearchService, IO[bytes]], **kwargs: Any ) -> LROPoller[_models.SearchService]: """Creates or updates a search service in the given resource group. If the search service already @@ -2902,8 +2924,9 @@ def begin_create_or_update( :type search_service_name: str :param service: The definition of the search service to create or update. Create applies to both serverless and dedicated search services; update applies only to dedicated search - services. Is one of the following types: SearchService, JSON, IO[bytes] Required. - :type service: ~azure.mgmt.search.models.SearchService or JSON or IO[bytes] + services. Is either a SearchService type or a IO[bytes] type. Required. + :type service: ~azure.mgmt.search.models.SearchService or + ~azure.mgmt.search.types.SearchService or IO[bytes] :return: An instance of LROPoller that returns SearchService. The SearchService is compatible with MutableMapping :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.search.models.SearchService] @@ -2994,7 +3017,7 @@ def update( self, resource_group_name: str, search_service_name: str, - service: JSON, + service: _types.SearchServiceUpdate, *, content_type: str = "application/json", **kwargs: Any @@ -3008,7 +3031,7 @@ def update( specified resource group. Required. :type search_service_name: str :param service: The definition of the search service to update. Required. - :type service: JSON + :type service: ~azure.mgmt.search.types.SearchServiceUpdate :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. Default value is "application/json". :paramtype content_type: str @@ -3050,7 +3073,7 @@ def update( self, resource_group_name: str, search_service_name: str, - service: Union[_models.SearchServiceUpdate, JSON, IO[bytes]], + service: Union[_models.SearchServiceUpdate, _types.SearchServiceUpdate, IO[bytes]], **kwargs: Any ) -> _models.SearchService: """Updates an existing search service in the given resource group. @@ -3061,9 +3084,10 @@ def update( :param search_service_name: The name of the Azure AI Search service associated with the specified resource group. Required. :type search_service_name: str - :param service: The definition of the search service to update. Is one of the following types: - SearchServiceUpdate, JSON, IO[bytes] Required. - :type service: ~azure.mgmt.search.models.SearchServiceUpdate or JSON or IO[bytes] + :param service: The definition of the search service to update. Is either a SearchServiceUpdate + type or a IO[bytes] type. Required. + :type service: ~azure.mgmt.search.models.SearchServiceUpdate or + ~azure.mgmt.search.types.SearchServiceUpdate or IO[bytes] :return: SearchService. The SearchService is compatible with MutableMapping :rtype: ~azure.mgmt.search.models.SearchService :raises ~azure.core.exceptions.HttpResponseError: @@ -3248,7 +3272,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( @@ -3338,7 +3365,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( @@ -3476,14 +3506,10 @@ def begin_upgrade( kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): - response_headers = {} response = pipeline_response.http_response - response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After")) - deserialized = _deserialize(_models.SearchService, response.json()) if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore + return cls(pipeline_response, deserialized, {}) # type: ignore return deserialized path_format_arguments = { @@ -3578,7 +3604,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( @@ -3942,7 +3971,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( @@ -4129,7 +4161,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/search/azure-mgmt-search/azure/mgmt/search/types.py b/sdk/search/azure-mgmt-search/azure/mgmt/search/types.py new file mode 100644 index 000000000000..79a3c880fca2 --- /dev/null +++ b/sdk/search/azure-mgmt-search/azure/mgmt/search/types.py @@ -0,0 +1,877 @@ +# pylint: disable=line-too-long,useless-suppression +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from typing import Any, Literal, Optional, TYPE_CHECKING, Union +from typing_extensions import Required, TypedDict + +if TYPE_CHECKING: + from .models import ( + AadAuthFailureMode, + AutoGeneratedDomainNameLabelScope, + ComputeType, + CreatedByType, + HostingMode, + IdentityType, + KnowledgeRetrieval, + PrivateLinkServiceConnectionProvisioningState, + PrivateLinkServiceConnectionStatus, + ProvisioningState, + PublicNetworkAccess, + SearchBypass, + SearchDataExfiltrationProtection, + SearchEncryptionComplianceStatus, + SearchEncryptionWithCmk, + SearchSemanticSearch, + SearchServiceStatus, + SharedPrivateLinkResourceProvisioningState, + SharedPrivateLinkResourceStatus, + SkuName, + UpgradeAvailable, + ) + + +class AzureActiveDirectoryApplicationCredentials(TypedDict, total=False): # pylint: disable=name-too-long + """Describes the Azure Active Directory application credentials required to access an Azure Key + Vault. + + :ivar application_id: The application (client) ID of an App Registration in the tenant. + :vartype application_id: str + :ivar application_secret: An AAD client secret that was generated for the App Registration used + to authenticate with Azure Key Vault. + :vartype application_secret: str + """ + + applicationId: str + """The application (client) ID of an App Registration in the tenant.""" + applicationSecret: str + """An AAD client secret that was generated for the App Registration used to authenticate with + Azure Key Vault.""" + + +class CheckNameAvailabilityInput(TypedDict, total=False): + """Input of check name availability API. + + :ivar name: The search service name to validate. Search service names must only contain + lowercase letters, digits or dashes, cannot use dash as the first two or last one characters, + cannot contain consecutive dashes, and must be between 2 and 60 characters in length. Required. + :vartype name: str + :ivar type: The type of the resource whose name is to be validated. This value must always be + 'searchServices'. Required. Default value is "searchServices". + :vartype type: Literal["searchServices"] + """ + + name: Required[str] + """The search service name to validate. Search service names must only contain lowercase letters, + digits or dashes, cannot use dash as the first two or last one characters, cannot contain + consecutive dashes, and must be between 2 and 60 characters in length. Required.""" + type: Required[Literal["searchServices"]] + """The type of the resource whose name is to be validated. This value must always be + 'searchServices'. Required. Default value is \"searchServices\".""" + + +DataNoneIdentity = TypedDict( + "DataNoneIdentity", + { + "@odata.type": Required[Literal["#Microsoft.Azure.Search.DataNoneIdentity"]], + }, + total=False, +) +DataNoneIdentity.__doc__ = """Clears the identity property. + +:ivar odata_type: Required. Default value is "#Microsoft.Azure.Search.DataNoneIdentity". +:vartype odata_type: Literal["#Microsoft.Azure.Search.DataNoneIdentity"] +""" + + +class DataPlaneAadOrApiKeyAuthOption(TypedDict, total=False): + """Indicates that either the API key or an access token from a Microsoft Entra ID tenant can be + used for authentication. + + :ivar aad_auth_failure_mode: Describes what response the data plane API of a search service + would send for requests that failed authentication. Known values are: "http403" and + "http401WithBearerChallenge". + :vartype aad_auth_failure_mode: Union[str, "AadAuthFailureMode"] + """ + + aadAuthFailureMode: Union[str, "AadAuthFailureMode"] + """Describes what response the data plane API of a search service would send for requests that + failed authentication. Known values are: \"http403\" and \"http401WithBearerChallenge\".""" + + +class DataPlaneAuthOptions(TypedDict, total=False): + """Defines the options for how the search service authenticates a data plane request. This cannot + be set if 'disableLocalAuth' is set to true. + + :ivar api_key_only: Indicates that only the API key can be used for authentication. + :vartype api_key_only: Any + :ivar aad_or_api_key: Indicates that either the API key or an access token from a Microsoft + Entra ID tenant can be used for authentication. + :vartype aad_or_api_key: "DataPlaneAadOrApiKeyAuthOption" + """ + + apiKeyOnly: Any + """Indicates that only the API key can be used for authentication.""" + aadOrApiKey: "DataPlaneAadOrApiKeyAuthOption" + """Indicates that either the API key or an access token from a Microsoft Entra ID tenant can be + used for authentication.""" + + +DataUserAssignedIdentity = TypedDict( + "DataUserAssignedIdentity", + { + "@odata.type": Required[Literal["#Microsoft.Azure.Search.DataUserAssignedIdentity"]], + "userAssignedIdentity": Required[str], + "federatedIdentityClientId": str, + }, + total=False, +) +DataUserAssignedIdentity.__doc__ = """Specifies the user assigned identity to use. + +:ivar odata_type: Required. Default value is + "#Microsoft.Azure.Search.DataUserAssignedIdentity". +:vartype odata_type: Literal["#Microsoft.Azure.Search.DataUserAssignedIdentity"] +:ivar user_assigned_identity: The fully qualified Azure resource Id of a user assigned managed + identity typically in the form + "/subscriptions/12345678-1234-1234-1234-1234567890ab/resourceGroups/rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myId" + that should have been assigned to the search service. Required. +:vartype user_assigned_identity: str +:ivar federated_identity_client_id: Optional for Multi-tenant User-Assigned Managed Identity + CMK Support: The client id (as a UUID) of the multi-tenant App Registration that has been + configured to federate with the userAssignedIdentity. +:vartype federated_identity_client_id: str +""" + + +class EncryptionWithCmk(TypedDict, total=False): + """Describes a policy that determines how resources within the search service are to be encrypted + with customer managed keys. + + :ivar enforcement: Describes how a search service should enforce compliance if it finds objects + that aren't encrypted with the customer-managed key. Known values are: "Disabled", "Enabled", + and "Unspecified". + :vartype enforcement: Union[str, "SearchEncryptionWithCmk"] + :ivar encryption_compliance_status: Returns the status of search service compliance with + respect to non-CMK-encrypted objects. If a service has more than one unencrypted object, and + enforcement is enabled, the service is marked as noncompliant. Known values are: "Compliant" + and "NonCompliant". + :vartype encryption_compliance_status: Union[str, "SearchEncryptionComplianceStatus"] + :ivar service_level_encryption_key: Describes the customer-managed key configuration for + encrypting the search service. + :vartype service_level_encryption_key: "SearchResourceEncryptionKey" + """ + + enforcement: Union[str, "SearchEncryptionWithCmk"] + """Describes how a search service should enforce compliance if it finds objects that aren't + encrypted with the customer-managed key. Known values are: \"Disabled\", \"Enabled\", and + \"Unspecified\".""" + encryptionComplianceStatus: Union[str, "SearchEncryptionComplianceStatus"] + """Returns the status of search service compliance with respect to non-CMK-encrypted objects. If a + service has more than one unencrypted object, and enforcement is enabled, the service is marked + as noncompliant. Known values are: \"Compliant\" and \"NonCompliant\".""" + serviceLevelEncryptionKey: "SearchResourceEncryptionKey" + """Describes the customer-managed key configuration for encrypting the search service.""" + + +class Identity(TypedDict, total=False): + """Details about the search service identity. A null value indicates that the search service has + no identity assigned. + + :ivar principal_id: The principal ID of the system-assigned identity of the search service. + :vartype principal_id: str + :ivar tenant_id: The tenant ID of the system-assigned identity of the search service. + :vartype tenant_id: str + :ivar type: The type of identity used for the resource. The type 'SystemAssigned, UserAssigned' + includes both an identity created by the system and a set of user assigned identities. The type + 'None' will remove all identities from the service. Required. Known values are: "None", + "SystemAssigned", "UserAssigned", and "SystemAssigned, UserAssigned". + :vartype type: Union[str, "IdentityType"] + :ivar user_assigned_identities: The list of user identities associated with the resource. The + user identity dictionary key references will be ARM resource IDs in the form: + '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'. + :vartype user_assigned_identities: dict[str, "UserAssignedIdentity"] + """ + + principalId: str + """The principal ID of the system-assigned identity of the search service.""" + tenantId: str + """The tenant ID of the system-assigned identity of the search service.""" + type: Required[Union[str, "IdentityType"]] + """The type of identity used for the resource. The type 'SystemAssigned, UserAssigned' includes + both an identity created by the system and a set of user assigned identities. The type 'None' + will remove all identities from the service. Required. Known values are: \"None\", + \"SystemAssigned\", \"UserAssigned\", and \"SystemAssigned, UserAssigned\".""" + userAssignedIdentities: dict[str, "UserAssignedIdentity"] + """The list of user identities associated with the resource. The user identity dictionary key + references will be ARM resource IDs in the form: + '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.""" + + +class IpRule(TypedDict, total=False): + """The IP restriction rule of the Azure AI Search service. + + :ivar value: Value corresponding to a single IPv4 address (eg., 123.1.2.3) or an IP range in + CIDR format (eg., 123.1.2.3/24) to be allowed. + :vartype value: str + """ + + value: str + """Value corresponding to a single IPv4 address (eg., 123.1.2.3) or an IP range in CIDR format + (eg., 123.1.2.3/24) to be allowed.""" + + +class NetworkRuleSet(TypedDict, total=False): + """Network specific rules that determine how the Azure AI Search service may be reached. + + :ivar ip_rules: A list of IP restriction rules that defines the inbound network(s) with + allowing access to the search service endpoint. At the meantime, all other public IP networks + are blocked by the firewall. These restriction rules are applied only when the + 'publicNetworkAccess' of the search service is 'enabled'; otherwise, traffic over public + interface is not allowed even with any public IP rules, and private endpoint connections would + be the exclusive access method. + :vartype ip_rules: list["IpRule"] + :ivar bypass: Possible origins of inbound traffic that can bypass the rules defined in the + 'ipRules' section. Known values are: "None", "AzurePortal", and "AzureServices". + :vartype bypass: Union[str, "SearchBypass"] + """ + + ipRules: list["IpRule"] + """A list of IP restriction rules that defines the inbound network(s) with allowing access to the + search service endpoint. At the meantime, all other public IP networks are blocked by the + firewall. These restriction rules are applied only when the 'publicNetworkAccess' of the search + service is 'enabled'; otherwise, traffic over public interface is not allowed even with any + public IP rules, and private endpoint connections would be the exclusive access method.""" + bypass: Union[str, "SearchBypass"] + """Possible origins of inbound traffic that can bypass the rules defined in the 'ipRules' section. + Known values are: \"None\", \"AzurePortal\", and \"AzureServices\".""" + + +class Resource(TypedDict, total=False): + """Resource. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: "SystemData" + """ + + id: str + """Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.""" + name: str + """The name of the resource.""" + type: str + """The type of the resource. E.g. \"Microsoft.Compute/virtualMachines\" or + \"Microsoft.Storage/storageAccounts\".""" + systemData: "SystemData" + """Azure Resource Manager metadata containing createdBy and modifiedBy information.""" + + +class ProxyResource(Resource): + """Proxy Resource. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: "SystemData" + """ + + +class PrivateEndpointConnection(ProxyResource): + """Describes an existing private endpoint connection to the Azure AI Search service. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: "SystemData" + :ivar properties: Describes the properties of an existing private endpoint connection to the + Azure AI Search service. + :vartype properties: "PrivateEndpointConnectionProperties" + """ + + properties: "PrivateEndpointConnectionProperties" + """Describes the properties of an existing private endpoint connection to the Azure AI Search + service.""" + + +class PrivateEndpointConnectionProperties(TypedDict, total=False): + """Describes the properties of an existing private endpoint connection to the search service. + + :ivar private_endpoint: The private endpoint resource from Microsoft.Network provider. + :vartype private_endpoint: "PrivateEndpointConnectionPropertiesPrivateEndpoint" + :ivar private_link_service_connection_state: Describes the current state of an existing Azure + Private Link service connection to the private endpoint. + :vartype private_link_service_connection_state: + "PrivateEndpointConnectionPropertiesPrivateLinkServiceConnectionState" + :ivar group_id: The group ID of the Azure resource for which the private link service is for. + :vartype group_id: str + :ivar provisioning_state: The provisioning state of the private link service connection. Valid + values are Updating, Deleting, Failed, Succeeded, Incomplete, or Canceled. Known values are: + "Updating", "Deleting", "Failed", "Succeeded", "Incomplete", and "Canceled". + :vartype provisioning_state: Union[str, "PrivateLinkServiceConnectionProvisioningState"] + """ + + privateEndpoint: "PrivateEndpointConnectionPropertiesPrivateEndpoint" + """The private endpoint resource from Microsoft.Network provider.""" + privateLinkServiceConnectionState: "PrivateEndpointConnectionPropertiesPrivateLinkServiceConnectionState" + """Describes the current state of an existing Azure Private Link service connection to the private + endpoint.""" + groupId: str + """The group ID of the Azure resource for which the private link service is for.""" + provisioningState: Union[str, "PrivateLinkServiceConnectionProvisioningState"] + """The provisioning state of the private link service connection. Valid values are Updating, + Deleting, Failed, Succeeded, Incomplete, or Canceled. Known values are: \"Updating\", + \"Deleting\", \"Failed\", \"Succeeded\", \"Incomplete\", and \"Canceled\".""" + + +class PrivateEndpointConnectionPropertiesPrivateEndpoint(TypedDict, total=False): # pylint: disable=name-too-long + """The private endpoint resource from Microsoft.Network provider. + + :ivar id: The resource ID of the private endpoint resource from Microsoft.Network provider. + :vartype id: str + """ + + id: str + """The resource ID of the private endpoint resource from Microsoft.Network provider.""" + + +class PrivateEndpointConnectionPropertiesPrivateLinkServiceConnectionState( + TypedDict, total=False +): # pylint: disable=name-too-long + """Describes the current state of an existing Azure Private Link service connection to the private + endpoint. + + :ivar status: Status of the the private link service connection. Valid values are Pending, + Approved, Rejected, or Disconnected. Known values are: "Pending", "Approved", "Rejected", and + "Disconnected". + :vartype status: Union[str, "PrivateLinkServiceConnectionStatus"] + :ivar description: The description for the private link service connection state. + :vartype description: str + :ivar actions_required: A description of any extra actions that may be required. + :vartype actions_required: str + """ + + status: Union[str, "PrivateLinkServiceConnectionStatus"] + """Status of the the private link service connection. Valid values are Pending, Approved, + Rejected, or Disconnected. Known values are: \"Pending\", \"Approved\", \"Rejected\", and + \"Disconnected\".""" + description: str + """The description for the private link service connection state.""" + actionsRequired: str + """A description of any extra actions that may be required.""" + + +class SearchResourceEncryptionKey(TypedDict, total=False): + """A customer-managed encryption key in Azure Key Vault. Keys that you create and manage can be + used to encrypt or decrypt data-at-rest, such as indexes and synonym maps. + + :ivar key_name: The name of your Azure Key Vault key to be used to encrypt your data at rest. + :vartype key_name: str + :ivar key_version: The version of your Azure Key Vault key to be used to encrypt your data at + rest. + :vartype key_version: str + :ivar vault_uri: The URI of your Azure Key Vault, also referred to as DNS name, that contains + the key to be used to encrypt your data at rest. An example URI might be + ``https://my-keyvault-name.vault.azure.net``. + :vartype vault_uri: str + :ivar identity: An explicit managed identity to use for this encryption key. If not specified + and the access credentials property is null, the system-assigned managed identity is used. On + update to the resource, if the explicit identity is unspecified, it remains unchanged. If + "none" is specified, the value of this property is cleared. + :vartype identity: "DataIdentity" + :ivar access_credentials: Optional Azure Active Directory credentials used for accessing your + Azure Key Vault. Not required if using managed identity instead. + :vartype access_credentials: "AzureActiveDirectoryApplicationCredentials" + """ + + keyVaultKeyName: str + """The name of your Azure Key Vault key to be used to encrypt your data at rest.""" + keyVaultKeyVersion: str + """The version of your Azure Key Vault key to be used to encrypt your data at rest.""" + keyVaultUri: str + """The URI of your Azure Key Vault, also referred to as DNS name, that contains the key to be used + to encrypt your data at rest. An example URI might be + ``https://my-keyvault-name.vault.azure.net``.""" + identity: Optional["DataIdentity"] + """An explicit managed identity to use for this encryption key. If not specified and the access + credentials property is null, the system-assigned managed identity is used. On update to the + resource, if the explicit identity is unspecified, it remains unchanged. If \"none\" is + specified, the value of this property is cleared.""" + accessCredentials: "AzureActiveDirectoryApplicationCredentials" + """Optional Azure Active Directory credentials used for accessing your Azure Key Vault. Not + required if using managed identity instead.""" + + +class TrackedResource(Resource): + """Tracked Resource. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: "SystemData" + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + :ivar location: The geo-location where the resource lives. Required. + :vartype location: str + """ + + tags: dict[str, str] + """Resource tags.""" + location: Required[str] + """The geo-location where the resource lives. Required.""" + + +class SearchService(TrackedResource): + """Describes an Azure AI Search service and its current state. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: "SystemData" + :ivar tags: Resource tags. + :vartype tags: dict[str, str] + :ivar location: The geo-location where the resource lives. Required. + :vartype location: str + :ivar properties: Properties of the search service. + :vartype properties: "SearchServiceProperties" + :ivar sku: The SKU of the search service, which determines price tier and capacity limits. This + property is required when creating a new search service. + :vartype sku: "Sku" + :ivar identity: The identity of the resource. + :vartype identity: "Identity" + """ + + properties: "SearchServiceProperties" + """Properties of the search service.""" + sku: "Sku" + """The SKU of the search service, which determines price tier and capacity limits. This property + is required when creating a new search service.""" + identity: "Identity" + """The identity of the resource.""" + + +class SearchServiceProperties(TypedDict, total=False): + """Properties of the search service. + + :ivar replica_count: The number of replicas in the dedicated search service. If specified, it + must be a value between 1 and 12 inclusive for standard SKUs or between 1 and 3 inclusive for + basic SKU. + :vartype replica_count: int + :ivar partition_count: The number of partitions in the dedicated search service; if specified, + it can be 1, 2, 3, 4, 6, or 12. Values greater than 1 are only valid for standard SKUs. For + 'standard3' services with hostingMode set to 'highDensity', the allowed values are between 1 + and 3. + :vartype partition_count: int + :ivar endpoint: The endpoint of the Azure AI Search service. + :vartype endpoint: str + :ivar hosting_mode: Applicable only for the standard3 SKU. You can set this property to enable + up to 3 high density partitions that allow up to 1000 indexes, which is much higher than the + maximum indexes allowed for any other SKU. For the standard3 SKU, the value is either 'Default' + or 'HighDensity'. For all other SKUs, this value must be 'Default'. Known values are: "Default" + and "HighDensity". + :vartype hosting_mode: Union[str, "HostingMode"] + :ivar compute_type: Configure this property to support the search service using either the + Default Compute or Azure Confidential Compute. Known values are: "Default" and "Confidential". + :vartype compute_type: Union[str, "ComputeType"] + :ivar public_network_access: This value can be set to 'Enabled' to avoid breaking changes on + existing customer resources and templates. If set to 'Disabled', traffic over public interface + is not allowed, and private endpoint connections would be the exclusive access method. Known + values are: "Enabled", "Disabled", and "SecuredByPerimeter". + :vartype public_network_access: Union[str, "PublicNetworkAccess"] + :ivar status: The status of the search service. Possible values include: 'running': The search + service is running and no provisioning operations are underway. 'provisioning': The search + service is being provisioned or scaled up or down. 'deleting': The search service is being + deleted. 'degraded': The search service is degraded. This can occur when the underlying search + units are not healthy. The search service is most likely operational, but performance might be + slow and some requests might be dropped. 'disabled': The search service is disabled. In this + state, the service will reject all API requests. 'error': The search service is in an error + state. 'stopped': The search service is in a subscription that's disabled. If your service is + in the degraded, disabled, or error states, it means the Azure AI Search team is actively + investigating the underlying issue. Dedicated services in these states are still chargeable + based on the number of search units provisioned. Known values are: "running", "provisioning", + "deleting", "degraded", "disabled", "error", and "stopped". + :vartype status: Union[str, "SearchServiceStatus"] + :ivar status_details: The details of the search service status. + :vartype status_details: str + :ivar provisioning_state: The state of the last provisioning operation performed on the search + service. Provisioning is an intermediate state that occurs while service capacity is being + established. After capacity is set up, provisioningState changes to either 'Succeeded' or + 'Failed'. Client applications can poll provisioning status (the recommended polling interval is + from 30 seconds to one minute) by using the Get Search Service operation to see when an + operation is completed. If you are using the free service, this value tends to come back as + 'Succeeded' directly in the call to Create search service. This is because the free service + uses capacity that is already set up. Known values are: "succeeded", "provisioning", and + "failed". + :vartype provisioning_state: Union[str, "ProvisioningState"] + :ivar network_rule_set: Network specific rules that determine how the Azure AI Search service + may be reached. + :vartype network_rule_set: "NetworkRuleSet" + :ivar data_exfiltration_protections: A list of data exfiltration scenarios that are explicitly + disallowed for the search service. Currently, the only supported value is 'All' to disable all + possible data export scenarios with more fine grained controls planned for the future. + :vartype data_exfiltration_protections: list[Union[str, "SearchDataExfiltrationProtection"]] + :ivar encryption_with_cmk: Specifies any policy regarding encryption of resources (such as + indexes) using customer manager keys within a search service. + :vartype encryption_with_cmk: "EncryptionWithCmk" + :ivar disable_local_auth: When set to true, calls to the search service will not be permitted + to utilize API keys for authentication. This cannot be set to true if 'dataPlaneAuthOptions' + are defined. + :vartype disable_local_auth: bool + :ivar auth_options: Defines the options for how the data plane API of a search service + authenticates requests. This cannot be set if 'disableLocalAuth' is set to true. + :vartype auth_options: "DataPlaneAuthOptions" + :ivar semantic_search: Specifies the availability and billing plan for semantic search on the + Azure AI Search service. This configuration is only available for certain pricing tiers in + certain regions. Known values are: "disabled", "free", and "standard". + :vartype semantic_search: Union[str, "SearchSemanticSearch"] + :ivar knowledge_retrieval: Specifies the billing plan for agentic retrieval on the Azure AI + Search service. This configuration is only available for certain pricing tiers in certain + regions. Known values are: "free" and "standard". + :vartype knowledge_retrieval: Union[str, "KnowledgeRetrieval"] + :ivar private_endpoint_connections: The list of private endpoint connections to the Azure AI + Search service. + :vartype private_endpoint_connections: list["PrivateEndpointConnection"] + :ivar auto_generated_domain_name_label_scope: Defines the level of reuse for the auto-generated + domain name label for the search service (e.g. myservice-.search.windows.net). If not + specified, no auto-generated domain name label is created for the search service. Known values + are: "TenantReuse", "SubscriptionReuse", and "NoReuse". + :vartype auto_generated_domain_name_label_scope: Union[str, + "AutoGeneratedDomainNameLabelScope"] + :ivar shared_private_link_resources: The list of shared private link resources managed by the + Azure AI Search service. + :vartype shared_private_link_resources: list["SharedPrivateLinkResource"] + :ivar e_tag: A system generated property representing the service's etag that can be for + optimistic concurrency control during updates. + :vartype e_tag: str + :ivar upgrade_available: Indicates if the search service has an upgrade available. Known values + are: "notAvailable" and "available". + :vartype upgrade_available: Union[str, "UpgradeAvailable"] + :ivar service_upgraded_at: The date and time the search service was last upgraded. This field + will be null until the service gets upgraded for the first time. + :vartype service_upgraded_at: str + """ + + replicaCount: int + """The number of replicas in the dedicated search service. If specified, it must be a value + between 1 and 12 inclusive for standard SKUs or between 1 and 3 inclusive for basic SKU.""" + partitionCount: int + """The number of partitions in the dedicated search service; if specified, it can be 1, 2, 3, 4, + 6, or 12. Values greater than 1 are only valid for standard SKUs. For 'standard3' services with + hostingMode set to 'highDensity', the allowed values are between 1 and 3.""" + endpoint: str + """The endpoint of the Azure AI Search service.""" + hostingMode: Union[str, "HostingMode"] + """Applicable only for the standard3 SKU. You can set this property to enable up to 3 high density + partitions that allow up to 1000 indexes, which is much higher than the maximum indexes allowed + for any other SKU. For the standard3 SKU, the value is either 'Default' or 'HighDensity'. For + all other SKUs, this value must be 'Default'. Known values are: \"Default\" and + \"HighDensity\".""" + computeType: Union[str, "ComputeType"] + """Configure this property to support the search service using either the Default Compute or Azure + Confidential Compute. Known values are: \"Default\" and \"Confidential\".""" + publicNetworkAccess: Union[str, "PublicNetworkAccess"] + """This value can be set to 'Enabled' to avoid breaking changes on existing customer resources and + templates. If set to 'Disabled', traffic over public interface is not allowed, and private + endpoint connections would be the exclusive access method. Known values are: \"Enabled\", + \"Disabled\", and \"SecuredByPerimeter\".""" + status: Union[str, "SearchServiceStatus"] + """The status of the search service. Possible values include: 'running': The search service is + running and no provisioning operations are underway. 'provisioning': The search service is + being provisioned or scaled up or down. 'deleting': The search service is being deleted. + 'degraded': The search service is degraded. This can occur when the underlying search units are + not healthy. The search service is most likely operational, but performance might be slow and + some requests might be dropped. 'disabled': The search service is disabled. In this state, the + service will reject all API requests. 'error': The search service is in an error state. + 'stopped': The search service is in a subscription that's disabled. If your service is in the + degraded, disabled, or error states, it means the Azure AI Search team is actively + investigating the underlying issue. Dedicated services in these states are still chargeable + based on the number of search units provisioned. Known values are: \"running\", + \"provisioning\", \"deleting\", \"degraded\", \"disabled\", \"error\", and \"stopped\".""" + statusDetails: str + """The details of the search service status.""" + provisioningState: Union[str, "ProvisioningState"] + """The state of the last provisioning operation performed on the search service. Provisioning is + an intermediate state that occurs while service capacity is being established. After capacity + is set up, provisioningState changes to either 'Succeeded' or 'Failed'. Client applications can + poll provisioning status (the recommended polling interval is from 30 seconds to one minute) by + using the Get Search Service operation to see when an operation is completed. If you are using + the free service, this value tends to come back as 'Succeeded' directly in the call to Create + search service. This is because the free service uses capacity that is already set up. Known + values are: \"succeeded\", \"provisioning\", and \"failed\".""" + networkRuleSet: "NetworkRuleSet" + """Network specific rules that determine how the Azure AI Search service may be reached.""" + dataExfiltrationProtections: list[Union[str, "SearchDataExfiltrationProtection"]] + """A list of data exfiltration scenarios that are explicitly disallowed for the search service. + Currently, the only supported value is 'All' to disable all possible data export scenarios with + more fine grained controls planned for the future.""" + encryptionWithCmk: "EncryptionWithCmk" + """Specifies any policy regarding encryption of resources (such as indexes) using customer manager + keys within a search service.""" + disableLocalAuth: Optional[bool] + """When set to true, calls to the search service will not be permitted to utilize API keys for + authentication. This cannot be set to true if 'dataPlaneAuthOptions' are defined.""" + authOptions: "DataPlaneAuthOptions" + """Defines the options for how the data plane API of a search service authenticates requests. This + cannot be set if 'disableLocalAuth' is set to true.""" + semanticSearch: Optional[Union[str, "SearchSemanticSearch"]] + """Specifies the availability and billing plan for semantic search on the Azure AI Search service. + This configuration is only available for certain pricing tiers in certain regions. Known values + are: \"disabled\", \"free\", and \"standard\".""" + knowledgeRetrieval: Optional[Union[str, "KnowledgeRetrieval"]] + """Specifies the billing plan for agentic retrieval on the Azure AI Search service. This + configuration is only available for certain pricing tiers in certain regions. Known values are: + \"free\" and \"standard\".""" + privateEndpointConnections: list["PrivateEndpointConnection"] + """The list of private endpoint connections to the Azure AI Search service.""" + autoGeneratedDomainNameLabelScope: Optional[Union[str, "AutoGeneratedDomainNameLabelScope"]] + """Defines the level of reuse for the auto-generated domain name label for the search service + (e.g. myservice-.search.windows.net). If not specified, no auto-generated domain name + label is created for the search service. Known values are: \"TenantReuse\", + \"SubscriptionReuse\", and \"NoReuse\".""" + sharedPrivateLinkResources: list["SharedPrivateLinkResource"] + """The list of shared private link resources managed by the Azure AI Search service.""" + eTag: str + """A system generated property representing the service's etag that can be for optimistic + concurrency control during updates.""" + upgradeAvailable: Union[str, "UpgradeAvailable"] + """Indicates if the search service has an upgrade available. Known values are: \"notAvailable\" + and \"available\".""" + serviceUpgradedAt: str + """The date and time the search service was last upgraded. This field will be null until the + service gets upgraded for the first time.""" + + +class SearchServiceUpdate(Resource): + """The parameters used to update an Azure AI Search service. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: "SystemData" + :ivar properties: Properties of the search service. + :vartype properties: "SearchServiceProperties" + :ivar sku: The SKU of the search service, which determines price tier and capacity limits. This + property is required when creating a new search service. + :vartype sku: "Sku" + :ivar location: The geographic location of the resource. This must be one of the supported and + registered Azure geo regions (for example, West US, East US, Southeast Asia, and so forth). + This property is required when creating a new resource. + :vartype location: str + :ivar tags: Tags to help categorize the resource in the Azure portal. + :vartype tags: dict[str, str] + :ivar identity: Details about the search service identity. A null value indicates that the + search service has no identity assigned. + :vartype identity: "Identity" + """ + + properties: "SearchServiceProperties" + """Properties of the search service.""" + sku: "Sku" + """The SKU of the search service, which determines price tier and capacity limits. This property + is required when creating a new search service.""" + location: str + """The geographic location of the resource. This must be one of the supported and registered Azure + geo regions (for example, West US, East US, Southeast Asia, and so forth). This property is + required when creating a new resource.""" + tags: dict[str, str] + """Tags to help categorize the resource in the Azure portal.""" + identity: "Identity" + """Details about the search service identity. A null value indicates that the search service has + no identity assigned.""" + + +class SharedPrivateLinkResource(ProxyResource): + """Describes a shared private link resource managed by the Azure AI Search service. + + :ivar id: Fully qualified resource ID for the resource. Ex - + /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}. + :vartype id: str + :ivar name: The name of the resource. + :vartype name: str + :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or + "Microsoft.Storage/storageAccounts". + :vartype type: str + :ivar system_data: Azure Resource Manager metadata containing createdBy and modifiedBy + information. + :vartype system_data: "SystemData" + :ivar properties: Describes the properties of a shared private link resource managed by the + Azure AI Search service. + :vartype properties: "SharedPrivateLinkResourceProperties" + """ + + properties: "SharedPrivateLinkResourceProperties" + """Describes the properties of a shared private link resource managed by the Azure AI Search + service.""" + + +class SharedPrivateLinkResourceProperties(TypedDict, total=False): + """Describes the properties of an existing shared private link resource managed by the Azure AI + Search service. + + :ivar private_link_resource_id: The resource ID of the resource the shared private link + resource is for. + :vartype private_link_resource_id: str + :ivar group_id: The group ID from the provider of resource the shared private link resource is + for. + :vartype group_id: str + :ivar request_message: The message for requesting approval of the shared private link resource. + :vartype request_message: str + :ivar resource_region: Optional. Can be used to specify the Azure Resource Manager location of + the resource for which a shared private link is being created. This is only required for those + resources whose DNS configuration are regional (such as Azure Kubernetes Service). + :vartype resource_region: str + :ivar status: Status of the shared private link resource. Valid values are Pending, Approved, + Rejected or Disconnected. Known values are: "Pending", "Approved", "Rejected", and + "Disconnected". + :vartype status: Union[str, "SharedPrivateLinkResourceStatus"] + :ivar provisioning_state: The provisioning state of the shared private link resource. Valid + values are Updating, Deleting, Failed, Succeeded or Incomplete. Known values are: "Updating", + "Deleting", "Failed", "Succeeded", and "Incomplete". + :vartype provisioning_state: Union[str, "SharedPrivateLinkResourceProvisioningState"] + """ + + privateLinkResourceId: str + """The resource ID of the resource the shared private link resource is for.""" + groupId: str + """The group ID from the provider of resource the shared private link resource is for.""" + requestMessage: str + """The message for requesting approval of the shared private link resource.""" + resourceRegion: str + """Optional. Can be used to specify the Azure Resource Manager location of the resource for which + a shared private link is being created. This is only required for those resources whose DNS + configuration are regional (such as Azure Kubernetes Service).""" + status: Union[str, "SharedPrivateLinkResourceStatus"] + """Status of the shared private link resource. Valid values are Pending, Approved, Rejected or + Disconnected. Known values are: \"Pending\", \"Approved\", \"Rejected\", and \"Disconnected\".""" + provisioningState: Union[str, "SharedPrivateLinkResourceProvisioningState"] + """The provisioning state of the shared private link resource. Valid values are Updating, + Deleting, Failed, Succeeded or Incomplete. Known values are: \"Updating\", \"Deleting\", + \"Failed\", \"Succeeded\", and \"Incomplete\".""" + + +class Sku(TypedDict, total=False): + """Defines the SKU of a search service, which determines billing rate and capacity limits. + + :ivar name: The SKU of the search service. Valid values include: 'free': Shared service. + 'basic': Dedicated service with up to 3 replicas. 'standard': Dedicated service with up to 12 + partitions and 12 replicas. 'standard2': Similar to standard, but with more capacity per search + unit. 'standard3': The largest Standard offering with up to 12 partitions and 12 replicas (or + up to 3 partitions with more indexes if you also set the hostingMode property to + 'highDensity'). 'storage_optimized_l1': Supports 1TB per partition, up to 12 partitions. + 'storage_optimized_l2': Supports 2TB per partition, up to 12 partitions. 'serverless': + Serverless tier with auto-scaling capabilities. Known values are: "free", "basic", "standard", + "standard2", "standard3", "storage_optimized_l1", "storage_optimized_l2", and "serverless". + :vartype name: Union[str, "SkuName"] + """ + + name: Union[str, "SkuName"] + """The SKU of the search service. Valid values include: 'free': Shared service. 'basic': Dedicated + service with up to 3 replicas. 'standard': Dedicated service with up to 12 partitions and 12 + replicas. 'standard2': Similar to standard, but with more capacity per search unit. + 'standard3': The largest Standard offering with up to 12 partitions and 12 replicas (or up to 3 + partitions with more indexes if you also set the hostingMode property to 'highDensity'). + 'storage_optimized_l1': Supports 1TB per partition, up to 12 partitions. + 'storage_optimized_l2': Supports 2TB per partition, up to 12 partitions. 'serverless': + Serverless tier with auto-scaling capabilities. Known values are: \"free\", \"basic\", + \"standard\", \"standard2\", \"standard3\", \"storage_optimized_l1\", \"storage_optimized_l2\", + and \"serverless\".""" + + +class SystemData(TypedDict, total=False): + """Metadata pertaining to creation and last modification of the resource. + + :ivar created_by: The identity that created the resource. + :vartype created_by: str + :ivar created_by_type: The type of identity that created the resource. Known values are: + "User", "Application", "ManagedIdentity", and "Key". + :vartype created_by_type: Union[str, "CreatedByType"] + :ivar created_at: The timestamp of resource creation (UTC). + :vartype created_at: str + :ivar last_modified_by: The identity that last modified the resource. + :vartype last_modified_by: str + :ivar last_modified_by_type: The type of identity that last modified the resource. Known values + are: "User", "Application", "ManagedIdentity", and "Key". + :vartype last_modified_by_type: Union[str, "CreatedByType"] + :ivar last_modified_at: The timestamp of resource last modification (UTC). + :vartype last_modified_at: str + """ + + createdBy: str + """The identity that created the resource.""" + createdByType: Union[str, "CreatedByType"] + """The type of identity that created the resource. Known values are: \"User\", \"Application\", + \"ManagedIdentity\", and \"Key\".""" + createdAt: str + """The timestamp of resource creation (UTC).""" + lastModifiedBy: str + """The identity that last modified the resource.""" + lastModifiedByType: Union[str, "CreatedByType"] + """The type of identity that last modified the resource. Known values are: \"User\", + \"Application\", \"ManagedIdentity\", and \"Key\".""" + lastModifiedAt: str + """The timestamp of resource last modification (UTC).""" + + +class UserAssignedIdentity(TypedDict, total=False): + """User assigned identity properties. + + :ivar principal_id: The principal ID of the assigned identity. + :vartype principal_id: str + :ivar client_id: The client ID of the assigned identity. + :vartype client_id: str + """ + + principalId: str + """The principal ID of the assigned identity.""" + clientId: str + """The client ID of the assigned identity.""" + + +DataIdentity = Union[DataNoneIdentity, DataUserAssignedIdentity] diff --git a/sdk/search/azure-mgmt-search/generated_samples/create_or_update_shared_private_link_resource.py b/sdk/search/azure-mgmt-search/generated_samples/create_or_update_shared_private_link_resource.py index 9d677d1cd10f..eff886421307 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/create_or_update_shared_private_link_resource.py +++ b/sdk/search/azure-mgmt-search/generated_samples/create_or_update_shared_private_link_resource.py @@ -47,6 +47,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/CreateOrUpdateSharedPrivateLinkResource.json +# x-ms-original-file: 2026-09-01-preview/CreateOrUpdateSharedPrivateLinkResource.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/delete_private_endpoint_connection.py b/sdk/search/azure-mgmt-search/generated_samples/delete_private_endpoint_connection.py index 63539180369d..81f476770b27 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/delete_private_endpoint_connection.py +++ b/sdk/search/azure-mgmt-search/generated_samples/delete_private_endpoint_connection.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/DeletePrivateEndpointConnection.json +# x-ms-original-file: 2026-09-01-preview/DeletePrivateEndpointConnection.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/delete_shared_private_link_resource.py b/sdk/search/azure-mgmt-search/generated_samples/delete_shared_private_link_resource.py index 25fd2bd9057a..bce975fea29f 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/delete_shared_private_link_resource.py +++ b/sdk/search/azure-mgmt-search/generated_samples/delete_shared_private_link_resource.py @@ -37,6 +37,6 @@ def main(): ).result() -# x-ms-original-file: 2026-03-01-preview/DeleteSharedPrivateLinkResource.json +# x-ms-original-file: 2026-09-01-preview/DeleteSharedPrivateLinkResource.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/get_private_endpoint_connection.py b/sdk/search/azure-mgmt-search/generated_samples/get_private_endpoint_connection.py index 3845fd1c19c1..8977967b54bc 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/get_private_endpoint_connection.py +++ b/sdk/search/azure-mgmt-search/generated_samples/get_private_endpoint_connection.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/GetPrivateEndpointConnection.json +# x-ms-original-file: 2026-09-01-preview/GetPrivateEndpointConnection.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/get_quota_usage.py b/sdk/search/azure-mgmt-search/generated_samples/get_quota_usage.py index f17cc86f9af7..c9f2d22d6052 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/get_quota_usage.py +++ b/sdk/search/azure-mgmt-search/generated_samples/get_quota_usage.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/GetQuotaUsage.json +# x-ms-original-file: 2026-09-01-preview/GetQuotaUsage.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/get_quota_usages_list.py b/sdk/search/azure-mgmt-search/generated_samples/get_quota_usages_list.py index 6c6ab8a573d1..0ca55c479520 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/get_quota_usages_list.py +++ b/sdk/search/azure-mgmt-search/generated_samples/get_quota_usages_list.py @@ -37,6 +37,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-01-preview/GetQuotaUsagesList.json +# x-ms-original-file: 2026-09-01-preview/GetQuotaUsagesList.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/get_shared_private_link_resource.py b/sdk/search/azure-mgmt-search/generated_samples/get_shared_private_link_resource.py index ae342c7a975f..b1a88a5dd1da 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/get_shared_private_link_resource.py +++ b/sdk/search/azure-mgmt-search/generated_samples/get_shared_private_link_resource.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/GetSharedPrivateLinkResource.json +# x-ms-original-file: 2026-09-01-preview/GetSharedPrivateLinkResource.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/list_private_endpoint_connections_by_service.py b/sdk/search/azure-mgmt-search/generated_samples/list_private_endpoint_connections_by_service.py index 4720ac6207bd..7fb15bd9d941 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/list_private_endpoint_connections_by_service.py +++ b/sdk/search/azure-mgmt-search/generated_samples/list_private_endpoint_connections_by_service.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-01-preview/ListPrivateEndpointConnectionsByService.json +# x-ms-original-file: 2026-09-01-preview/ListPrivateEndpointConnectionsByService.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/list_shared_private_link_resources_by_service.py b/sdk/search/azure-mgmt-search/generated_samples/list_shared_private_link_resources_by_service.py index 361cd9d9cd49..81c0f10c48e2 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/list_shared_private_link_resources_by_service.py +++ b/sdk/search/azure-mgmt-search/generated_samples/list_shared_private_link_resources_by_service.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-01-preview/ListSharedPrivateLinkResourcesByService.json +# x-ms-original-file: 2026-09-01-preview/ListSharedPrivateLinkResourcesByService.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/list_supported_private_link_resources.py b/sdk/search/azure-mgmt-search/generated_samples/list_supported_private_link_resources.py index 619497a868f1..ead3a1070405 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/list_supported_private_link_resources.py +++ b/sdk/search/azure-mgmt-search/generated_samples/list_supported_private_link_resources.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-01-preview/ListSupportedPrivateLinkResources.json +# x-ms-original-file: 2026-09-01-preview/ListSupportedPrivateLinkResources.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/network_security_perimeter_configurations_get.py b/sdk/search/azure-mgmt-search/generated_samples/network_security_perimeter_configurations_get.py index a1c38b122970..aafa061cd3db 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/network_security_perimeter_configurations_get.py +++ b/sdk/search/azure-mgmt-search/generated_samples/network_security_perimeter_configurations_get.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/NetworkSecurityPerimeterConfigurationsGet.json +# x-ms-original-file: 2026-09-01-preview/NetworkSecurityPerimeterConfigurationsGet.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/network_security_perimeter_configurations_list_by_service.py b/sdk/search/azure-mgmt-search/generated_samples/network_security_perimeter_configurations_list_by_service.py index 6a4a0c617eac..7cc649b76fdf 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/network_security_perimeter_configurations_list_by_service.py +++ b/sdk/search/azure-mgmt-search/generated_samples/network_security_perimeter_configurations_list_by_service.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-01-preview/NetworkSecurityPerimeterConfigurationsListByService.json +# x-ms-original-file: 2026-09-01-preview/NetworkSecurityPerimeterConfigurationsListByService.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/network_security_perimeter_configurations_reconcile.py b/sdk/search/azure-mgmt-search/generated_samples/network_security_perimeter_configurations_reconcile.py index a139a65a3bc7..012267d0b590 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/network_security_perimeter_configurations_reconcile.py +++ b/sdk/search/azure-mgmt-search/generated_samples/network_security_perimeter_configurations_reconcile.py @@ -37,6 +37,6 @@ def main(): ).result() -# x-ms-original-file: 2026-03-01-preview/NetworkSecurityPerimeterConfigurationsReconcile.json +# x-ms-original-file: 2026-09-01-preview/NetworkSecurityPerimeterConfigurationsReconcile.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_check_name_availability.py b/sdk/search/azure-mgmt-search/generated_samples/search_check_name_availability.py index 89be461a93e6..6f473fd7faed 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_check_name_availability.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_check_name_availability.py @@ -36,6 +36,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCheckNameAvailability.json +# x-ms-original-file: 2026-09-01-preview/SearchCheckNameAvailability.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service.py index c1922eb06a78..c13de8b0e6df 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service.py @@ -43,6 +43,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCreateOrUpdateService.json +# x-ms-original-file: 2026-09-01-preview/SearchCreateOrUpdateService.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_auth_options.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_auth_options.py index 59d52b761b64..c28816f3d97e 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_auth_options.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_auth_options.py @@ -49,6 +49,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCreateOrUpdateServiceAuthOptions.json +# x-ms-original-file: 2026-09-01-preview/SearchCreateOrUpdateServiceAuthOptions.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_disable_local_auth.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_disable_local_auth.py index 21cc5875188f..fd85c0a3bb85 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_disable_local_auth.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_disable_local_auth.py @@ -49,6 +49,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCreateOrUpdateServiceDisableLocalAuth.json +# x-ms-original-file: 2026-09-01-preview/SearchCreateOrUpdateServiceDisableLocalAuth.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_to_allow_access_from_private_endpoints.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_to_allow_access_from_private_endpoints.py index 2cce969d947e..55a9c9336478 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_to_allow_access_from_private_endpoints.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_to_allow_access_from_private_endpoints.py @@ -49,6 +49,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCreateOrUpdateServiceToAllowAccessFromPrivateEndpoints.json +# x-ms-original-file: 2026-09-01-preview/SearchCreateOrUpdateServiceToAllowAccessFromPrivateEndpoints.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_to_allow_access_from_public_custom_ips.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_to_allow_access_from_public_custom_ips.py index 7d964336ebe2..839439368470 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_to_allow_access_from_public_custom_ips.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_to_allow_access_from_public_custom_ips.py @@ -49,6 +49,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCreateOrUpdateServiceToAllowAccessFromPublicCustomIPs.json +# x-ms-original-file: 2026-09-01-preview/SearchCreateOrUpdateServiceToAllowAccessFromPublicCustomIPs.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_to_allow_access_from_public_custom_ips_and_bypass.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_to_allow_access_from_public_custom_ips_and_bypass.py index 26361d119c8e..173c4ef02457 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_to_allow_access_from_public_custom_ips_and_bypass.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_to_allow_access_from_public_custom_ips_and_bypass.py @@ -52,6 +52,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCreateOrUpdateServiceToAllowAccessFromPublicCustomIPsAndBypass.json +# x-ms-original-file: 2026-09-01-preview/SearchCreateOrUpdateServiceToAllowAccessFromPublicCustomIPsAndBypass.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_auto_generated_domain_name_label_scope.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_auto_generated_domain_name_label_scope.py new file mode 100644 index 000000000000..d1d382acd082 --- /dev/null +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_auto_generated_domain_name_label_scope.py @@ -0,0 +1,54 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +from azure.identity import DefaultAzureCredential + +from azure.mgmt.search import SearchManagementClient + +""" +# PREREQUISITES + pip install azure-identity + pip install azure-mgmt-search +# USAGE + python search_create_or_update_service_with_auto_generated_domain_name_label_scope.py + + Before run the sample, please set the values of the client ID, tenant ID and client secret + of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, + AZURE_CLIENT_SECRET. For more info about how to get the value, please see: + https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal +""" + + +def main(): + client = SearchManagementClient( + credential=DefaultAzureCredential(), + subscription_id="SUBSCRIPTION_ID", + ) + + response = client.services.begin_create_or_update( + resource_group_name="rg1", + search_service_name="mysearchservice", + service={ + "location": "westus", + "properties": { + "autoGeneratedDomainNameLabelScope": "TenantReuse", + "computeType": "Default", + "hostingMode": "Default", + "partitionCount": 1, + "replicaCount": 3, + }, + "sku": {"name": "standard"}, + "tags": {"app-name": "My e-commerce app"}, + }, + ).result() + print(response) + + +# x-ms-original-file: 2026-09-01-preview/SearchCreateOrUpdateServiceWithAutoGeneratedDomainNameLabelScope.json +if __name__ == "__main__": + main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_cmk_enforcement.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_cmk_enforcement.py index cb3065055158..ad9947b2cb2c 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_cmk_enforcement.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_cmk_enforcement.py @@ -49,6 +49,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCreateOrUpdateServiceWithCmkEnforcement.json +# x-ms-original-file: 2026-09-01-preview/SearchCreateOrUpdateServiceWithCmkEnforcement.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_data_exfiltration.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_data_exfiltration.py index 3bfc7d2297da..afacd6ddcafd 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_data_exfiltration.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_data_exfiltration.py @@ -49,6 +49,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCreateOrUpdateServiceWithDataExfiltration.json +# x-ms-original-file: 2026-09-01-preview/SearchCreateOrUpdateServiceWithDataExfiltration.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_identity.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_identity.py index 3329114ec0c7..0fd11e50f3b2 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_identity.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_identity.py @@ -50,6 +50,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCreateOrUpdateServiceWithIdentity.json +# x-ms-original-file: 2026-09-01-preview/SearchCreateOrUpdateServiceWithIdentity.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_serverless.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_serverless.py index 5aad428ee840..b995aebf6c3a 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_serverless.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_serverless.py @@ -43,6 +43,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCreateOrUpdateServiceWithServerless.json +# x-ms-original-file: 2026-09-01-preview/SearchCreateOrUpdateServiceWithServerless.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_service_level_cmk_multi_tenant_federated_identity.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_service_level_cmk_multi_tenant_federated_identity.py index 6ea0ef0a34ce..ce5b6cd22947 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_service_level_cmk_multi_tenant_federated_identity.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_service_with_service_level_cmk_multi_tenant_federated_identity.py @@ -69,6 +69,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCreateOrUpdateServiceWithServiceLevelCmkMultiTenantFederatedIdentity.json +# x-ms-original-file: 2026-09-01-preview/SearchCreateOrUpdateServiceWithServiceLevelCmkMultiTenantFederatedIdentity.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_with_knowledge_retrieval.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_with_knowledge_retrieval.py index 5cdb1e662b70..4960586a2ba8 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_with_knowledge_retrieval.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_with_knowledge_retrieval.py @@ -49,6 +49,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCreateOrUpdateWithKnowledgeRetrieval.json +# x-ms-original-file: 2026-09-01-preview/SearchCreateOrUpdateWithKnowledgeRetrieval.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_with_semantic_search.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_with_semantic_search.py index 1259fef7731c..a42c35e3b769 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_with_semantic_search.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_or_update_with_semantic_search.py @@ -49,6 +49,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCreateOrUpdateWithSemanticSearch.json +# x-ms-original-file: 2026-09-01-preview/SearchCreateOrUpdateWithSemanticSearch.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_create_query_key.py b/sdk/search/azure-mgmt-search/generated_samples/search_create_query_key.py index 2842c91d0b70..359e8ecc86bc 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_create_query_key.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_create_query_key.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchCreateQueryKey.json +# x-ms-original-file: 2026-09-01-preview/SearchCreateQueryKey.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_delete_query_key.py b/sdk/search/azure-mgmt-search/generated_samples/search_delete_query_key.py index c113b1769b3f..74e15f9190de 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_delete_query_key.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_delete_query_key.py @@ -37,6 +37,6 @@ def main(): ) -# x-ms-original-file: 2026-03-01-preview/SearchDeleteQueryKey.json +# x-ms-original-file: 2026-09-01-preview/SearchDeleteQueryKey.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_delete_service.py b/sdk/search/azure-mgmt-search/generated_samples/search_delete_service.py index e34425d30e8a..0862718d6c83 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_delete_service.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_delete_service.py @@ -36,6 +36,6 @@ def main(): ) -# x-ms-original-file: 2026-03-01-preview/SearchDeleteService.json +# x-ms-original-file: 2026-09-01-preview/SearchDeleteService.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_list_offerings.py b/sdk/search/azure-mgmt-search/generated_samples/search_fetch_offerings.py similarity index 89% rename from sdk/search/azure-mgmt-search/generated_samples/search_list_offerings.py rename to sdk/search/azure-mgmt-search/generated_samples/search_fetch_offerings.py index abcba6047c2b..0b0bfeab7ef1 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_list_offerings.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_fetch_offerings.py @@ -15,7 +15,7 @@ pip install azure-identity pip install azure-mgmt-search # USAGE - python search_list_offerings.py + python search_fetch_offerings.py Before run the sample, please set the values of the client ID, tenant ID and client secret of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, @@ -30,10 +30,10 @@ def main(): subscription_id="SUBSCRIPTION_ID", ) - response = client.offerings.list() + response = client.offerings.fetch() print(response) -# x-ms-original-file: 2026-03-01-preview/SearchListOfferings.json +# x-ms-original-file: 2026-09-01-preview/SearchFetchOfferings.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_get_admin_keys.py b/sdk/search/azure-mgmt-search/generated_samples/search_get_admin_keys.py index 171ff3ec78aa..0e5d3896f235 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_get_admin_keys.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_get_admin_keys.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchGetAdminKeys.json +# x-ms-original-file: 2026-09-01-preview/SearchGetAdminKeys.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_get_service.py b/sdk/search/azure-mgmt-search/generated_samples/search_get_service.py index d93304e6acaa..19fd5a4215fc 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_get_service.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_get_service.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchGetService.json +# x-ms-original-file: 2026-09-01-preview/SearchGetService.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_list_operations.py b/sdk/search/azure-mgmt-search/generated_samples/search_list_operations.py index 7eaa4b396930..5febb91b2bfe 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_list_operations.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_list_operations.py @@ -35,6 +35,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-01-preview/SearchListOperations.json +# x-ms-original-file: 2026-09-01-preview/SearchListOperations.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_list_query_keys_by_search_service.py b/sdk/search/azure-mgmt-search/generated_samples/search_list_query_keys_by_search_service.py index 41fcfac6ee1c..44bf1e32a961 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_list_query_keys_by_search_service.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_list_query_keys_by_search_service.py @@ -38,6 +38,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-01-preview/SearchListQueryKeysBySearchService.json +# x-ms-original-file: 2026-09-01-preview/SearchListQueryKeysBySearchService.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_list_services_by_resource_group.py b/sdk/search/azure-mgmt-search/generated_samples/search_list_services_by_resource_group.py index 75ef99d0b0d1..a865dab86463 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_list_services_by_resource_group.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_list_services_by_resource_group.py @@ -37,6 +37,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-01-preview/SearchListServicesByResourceGroup.json +# x-ms-original-file: 2026-09-01-preview/SearchListServicesByResourceGroup.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_list_services_by_subscription.py b/sdk/search/azure-mgmt-search/generated_samples/search_list_services_by_subscription.py index 4561cd9f48e2..33b6bdbdd6c9 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_list_services_by_subscription.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_list_services_by_subscription.py @@ -35,6 +35,6 @@ def main(): print(item) -# x-ms-original-file: 2026-03-01-preview/SearchListServicesBySubscription.json +# x-ms-original-file: 2026-09-01-preview/SearchListServicesBySubscription.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_regenerate_admin_key.py b/sdk/search/azure-mgmt-search/generated_samples/search_regenerate_admin_key.py index 1acddfaba179..f1ab76a067f2 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_regenerate_admin_key.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_regenerate_admin_key.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchRegenerateAdminKey.json +# x-ms-original-file: 2026-09-01-preview/SearchRegenerateAdminKey.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_update_service.py b/sdk/search/azure-mgmt-search/generated_samples/search_update_service.py index eaaa77d247e5..792239e42108 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_update_service.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_update_service.py @@ -41,6 +41,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchUpdateService.json +# x-ms-original-file: 2026-09-01-preview/SearchUpdateService.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_auth_options.py b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_auth_options.py index 2e0303503a34..ff25e75e1574 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_auth_options.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_auth_options.py @@ -44,6 +44,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchUpdateServiceAuthOptions.json +# x-ms-original-file: 2026-09-01-preview/SearchUpdateServiceAuthOptions.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_disable_local_auth.py b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_disable_local_auth.py index c3d6be607763..bff5e6aba91c 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_disable_local_auth.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_disable_local_auth.py @@ -41,6 +41,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchUpdateServiceDisableLocalAuth.json +# x-ms-original-file: 2026-09-01-preview/SearchUpdateServiceDisableLocalAuth.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_allow_access_from_private_endpoints.py b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_allow_access_from_private_endpoints.py index 1e41fcde57cd..8171c50d7603 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_allow_access_from_private_endpoints.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_allow_access_from_private_endpoints.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchUpdateServiceToAllowAccessFromPrivateEndpoints.json +# x-ms-original-file: 2026-09-01-preview/SearchUpdateServiceToAllowAccessFromPrivateEndpoints.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_allow_access_from_public_custom_ips.py b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_allow_access_from_public_custom_ips.py index c0ac512bf432..2f3845597e08 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_allow_access_from_public_custom_ips.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_allow_access_from_public_custom_ips.py @@ -45,6 +45,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchUpdateServiceToAllowAccessFromPublicCustomIPs.json +# x-ms-original-file: 2026-09-01-preview/SearchUpdateServiceToAllowAccessFromPublicCustomIPs.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_allow_access_from_public_custom_ips_and_bypass.py b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_allow_access_from_public_custom_ips_and_bypass.py index 0a1ee9496f35..bd1aef0f4893 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_allow_access_from_public_custom_ips_and_bypass.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_allow_access_from_public_custom_ips_and_bypass.py @@ -48,6 +48,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchUpdateServiceToAllowAccessFromPublicCustomIPsAndBypass.json +# x-ms-original-file: 2026-09-01-preview/SearchUpdateServiceToAllowAccessFromPublicCustomIPsAndBypass.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_remove_identity.py b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_remove_identity.py index 605eddf82c72..d9596e73507b 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_remove_identity.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_to_remove_identity.py @@ -38,6 +38,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchUpdateServiceToRemoveIdentity.json +# x-ms-original-file: 2026-09-01-preview/SearchUpdateServiceToRemoveIdentity.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_cmk_enforcement.py b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_cmk_enforcement.py index 96ce46a07056..12492b522f3b 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_cmk_enforcement.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_cmk_enforcement.py @@ -41,6 +41,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchUpdateServiceWithCmkEnforcement.json +# x-ms-original-file: 2026-09-01-preview/SearchUpdateServiceWithCmkEnforcement.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_data_exfiltration.py b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_data_exfiltration.py index d9db637af1ad..8bc5babc0472 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_data_exfiltration.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_data_exfiltration.py @@ -41,6 +41,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchUpdateServiceWithDataExfiltration.json +# x-ms-original-file: 2026-09-01-preview/SearchUpdateServiceWithDataExfiltration.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_knowledge_retrieval.py b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_knowledge_retrieval.py index 4695bcb54c38..6484e3387496 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_knowledge_retrieval.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_knowledge_retrieval.py @@ -41,6 +41,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchUpdateServiceWithKnowledgeRetrieval.json +# x-ms-original-file: 2026-09-01-preview/SearchUpdateServiceWithKnowledgeRetrieval.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_semantic_search.py b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_semantic_search.py index a859bdea5cb0..65c085b1c65a 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_semantic_search.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_semantic_search.py @@ -41,6 +41,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchUpdateServiceWithSemanticSearch.json +# x-ms-original-file: 2026-09-01-preview/SearchUpdateServiceWithSemanticSearch.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_sku.py b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_sku.py index 57f3f8945ec4..9bc2736c373f 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_sku.py +++ b/sdk/search/azure-mgmt-search/generated_samples/search_update_service_with_sku.py @@ -41,6 +41,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/SearchUpdateServiceWithSku.json +# x-ms-original-file: 2026-09-01-preview/SearchUpdateServiceWithSku.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/update_private_endpoint_connection.py b/sdk/search/azure-mgmt-search/generated_samples/update_private_endpoint_connection.py index bdb90ac0ca07..65263cb3ba93 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/update_private_endpoint_connection.py +++ b/sdk/search/azure-mgmt-search/generated_samples/update_private_endpoint_connection.py @@ -47,6 +47,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/UpdatePrivateEndpointConnection.json +# x-ms-original-file: 2026-09-01-preview/UpdatePrivateEndpointConnection.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_samples/upgrade_search_service_to_latest_version.py b/sdk/search/azure-mgmt-search/generated_samples/upgrade_search_service_to_latest_version.py index 39ec91859459..dbe485aa77ce 100644 --- a/sdk/search/azure-mgmt-search/generated_samples/upgrade_search_service_to_latest_version.py +++ b/sdk/search/azure-mgmt-search/generated_samples/upgrade_search_service_to_latest_version.py @@ -37,6 +37,6 @@ def main(): print(response) -# x-ms-original-file: 2026-03-01-preview/UpgradeSearchServiceToLatestVersion.json +# x-ms-original-file: 2026-09-01-preview/UpgradeSearchServiceToLatestVersion.json if __name__ == "__main__": main() diff --git a/sdk/search/azure-mgmt-search/generated_tests/test_search_management_offerings_operations.py b/sdk/search/azure-mgmt-search/generated_tests/test_search_management_offerings_operations.py index 6c9f014f8dd1..5cd6b7604d88 100644 --- a/sdk/search/azure-mgmt-search/generated_tests/test_search_management_offerings_operations.py +++ b/sdk/search/azure-mgmt-search/generated_tests/test_search_management_offerings_operations.py @@ -20,8 +20,8 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy - def test_offerings_list(self, resource_group): - response = self.client.offerings.list() + def test_offerings_fetch(self, resource_group): + response = self.client.offerings.fetch() # please add some check logic here by yourself # ... diff --git a/sdk/search/azure-mgmt-search/generated_tests/test_search_management_offerings_operations_async.py b/sdk/search/azure-mgmt-search/generated_tests/test_search_management_offerings_operations_async.py index cc7cdd45be5e..2889206bdf66 100644 --- a/sdk/search/azure-mgmt-search/generated_tests/test_search_management_offerings_operations_async.py +++ b/sdk/search/azure-mgmt-search/generated_tests/test_search_management_offerings_operations_async.py @@ -21,8 +21,8 @@ def setup_method(self, method): @RandomNameResourceGroupPreparer(location=AZURE_LOCATION) @recorded_by_proxy_async - async def test_offerings_list(self, resource_group): - response = await self.client.offerings.list() + async def test_offerings_fetch(self, resource_group): + response = await self.client.offerings.fetch() # please add some check logic here by yourself # ... diff --git a/sdk/search/azure-mgmt-search/generated_tests/test_search_management_services_operations.py b/sdk/search/azure-mgmt-search/generated_tests/test_search_management_services_operations.py index a66a330fde7f..3ae42bbb037f 100644 --- a/sdk/search/azure-mgmt-search/generated_tests/test_search_management_services_operations.py +++ b/sdk/search/azure-mgmt-search/generated_tests/test_search_management_services_operations.py @@ -57,6 +57,7 @@ def test_services_begin_create_or_update(self, resource_group): "name": "str", "properties": { "authOptions": {"aadOrApiKey": {"aadAuthFailureMode": "str"}, "apiKeyOnly": {}}, + "autoGeneratedDomainNameLabelScope": "str", "computeType": "str", "dataExfiltrationProtections": ["str"], "disableLocalAuth": bool, @@ -169,6 +170,7 @@ def test_services_update(self, resource_group): "name": "str", "properties": { "authOptions": {"aadOrApiKey": {"aadAuthFailureMode": "str"}, "apiKeyOnly": {}}, + "autoGeneratedDomainNameLabelScope": "str", "computeType": "str", "dataExfiltrationProtections": ["str"], "disableLocalAuth": bool, diff --git a/sdk/search/azure-mgmt-search/generated_tests/test_search_management_services_operations_async.py b/sdk/search/azure-mgmt-search/generated_tests/test_search_management_services_operations_async.py index b3e165e9ad3f..73601b2f657c 100644 --- a/sdk/search/azure-mgmt-search/generated_tests/test_search_management_services_operations_async.py +++ b/sdk/search/azure-mgmt-search/generated_tests/test_search_management_services_operations_async.py @@ -59,6 +59,7 @@ async def test_services_begin_create_or_update(self, resource_group): "name": "str", "properties": { "authOptions": {"aadOrApiKey": {"aadAuthFailureMode": "str"}, "apiKeyOnly": {}}, + "autoGeneratedDomainNameLabelScope": "str", "computeType": "str", "dataExfiltrationProtections": ["str"], "disableLocalAuth": bool, @@ -172,6 +173,7 @@ async def test_services_update(self, resource_group): "name": "str", "properties": { "authOptions": {"aadOrApiKey": {"aadAuthFailureMode": "str"}, "apiKeyOnly": {}}, + "autoGeneratedDomainNameLabelScope": "str", "computeType": "str", "dataExfiltrationProtections": ["str"], "disableLocalAuth": bool, diff --git a/sdk/search/azure-mgmt-search/pyproject.toml b/sdk/search/azure-mgmt-search/pyproject.toml index f193258d6f3c..25c81e3d8f2b 100644 --- a/sdk/search/azure-mgmt-search/pyproject.toml +++ b/sdk/search/azure-mgmt-search/pyproject.toml @@ -17,13 +17,13 @@ classifiers = [ "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", diff --git a/sdk/search/azure-mgmt-search/tsp-location.yaml b/sdk/search/azure-mgmt-search/tsp-location.yaml index 22f612221bde..ffa1dc230bfd 100644 --- a/sdk/search/azure-mgmt-search/tsp-location.yaml +++ b/sdk/search/azure-mgmt-search/tsp-location.yaml @@ -1,4 +1,4 @@ directory: specification/search/resource-manager/Microsoft.Search/Search -commit: f90ba8622a186403cc11d43b8977d6bfd8410742 +commit: e75a07cd7ea1b2207190a362305db02b639715ec repo: Azure/azure-rest-api-specs additionalDirectories: From 879bde9c98f56b38caa9568a8c630d577f4faa36 Mon Sep 17 00:00:00 2001 From: "Chenxi Jiang (WICRESOFT NORTH AMERICA LTD)" Date: Fri, 17 Jul 2026 10:49:48 +0800 Subject: [PATCH 2/3] update Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 0aa8b94f-cac1-4ffa-be8e-3f89f3a686d0 --- sdk/search/azure-mgmt-search/CHANGELOG.md | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/sdk/search/azure-mgmt-search/CHANGELOG.md b/sdk/search/azure-mgmt-search/CHANGELOG.md index 420003d146bc..d4e353600531 100644 --- a/sdk/search/azure-mgmt-search/CHANGELOG.md +++ b/sdk/search/azure-mgmt-search/CHANGELOG.md @@ -7,13 +7,16 @@ - Model `SearchServiceProperties` added property `auto_generated_domain_name_label_scope` - Added enum `AutoGeneratedDomainNameLabelScope` - Added model `OfferingsResult` - - Model `OfferingsOperations` added method `fetch` + - Operation group `OfferingsOperations` added method `fetch` ### Breaking Changes - - Deleted or renamed model `OfferingsListResult` - Deleted or renamed method `OfferingsOperations.list` +### Other Changes + + - Deleted model `OfferingsListResult` which actually was not used by SDK users + ## 10.0.0b1 (2026-03-27) ### Features Added From d2ac077455e34df4c66e1ba6a157c6d38de2fa07 Mon Sep 17 00:00:00 2001 From: ChenxiJiang333 <119990644+ChenxiJiang333@users.noreply.github.com> Date: Fri, 17 Jul 2026 11:09:48 +0800 Subject: [PATCH 3/3] Update CHANGELOG.md --- sdk/search/azure-mgmt-search/CHANGELOG.md | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/sdk/search/azure-mgmt-search/CHANGELOG.md b/sdk/search/azure-mgmt-search/CHANGELOG.md index d4e353600531..4986bcf41b67 100644 --- a/sdk/search/azure-mgmt-search/CHANGELOG.md +++ b/sdk/search/azure-mgmt-search/CHANGELOG.md @@ -11,12 +11,9 @@ ### Breaking Changes + - Deleted or renamed model `OfferingsListResult` - Deleted or renamed method `OfferingsOperations.list` -### Other Changes - - - Deleted model `OfferingsListResult` which actually was not used by SDK users - ## 10.0.0b1 (2026-03-27) ### Features Added