@azure/arm-search 4.0.0-beta.1 → 4.0.0-beta.2

package/dist/react-native/models/models.js

@@ -0,0 +1,1311 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { areAllPropsUndefined } from "../static-helpers/serialization/check-prop-undefined.js";
+export function searchManagementRequestOptionsSerializer(_item) {
+    return {};
+}
+export function quotaUsageResultDeserializer(item) {
+    return {
+        id: item["id"],
+        unit: item["unit"],
+        currentValue: item["currentValue"],
+        limit: item["limit"],
+        name: !item["name"] ? item["name"] : quotaUsageResultNameDeserializer(item["name"]),
+    };
+}
+export function quotaUsageResultNameDeserializer(item) {
+    return {
+        value: item["value"],
+        localizedValue: item["localizedValue"],
+    };
+}
+export function cloudErrorDeserializer(item) {
+    return {
+        error: !item["error"] ? item["error"] : cloudErrorBodyDeserializer(item["error"]),
+        message: item["message"],
+    };
+}
+export function cloudErrorBodyDeserializer(item) {
+    return {
+        code: item["code"],
+        message: item["message"],
+        target: item["target"],
+        details: !item["details"] ? item["details"] : cloudErrorBodyArrayDeserializer(item["details"]),
+    };
+}
+export function cloudErrorBodyArrayDeserializer(result) {
+    return result.map((item) => {
+        return cloudErrorBodyDeserializer(item);
+    });
+}
+export function offeringsListResultDeserializer(item) {
+    return {
+        value: !item["value"] ? item["value"] : offeringsByRegionArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function offeringsByRegionArrayDeserializer(result) {
+    return result.map((item) => {
+        return offeringsByRegionDeserializer(item);
+    });
+}
+export function offeringsByRegionDeserializer(item) {
+    return {
+        regionName: item["regionName"],
+        features: !item["features"]
+            ? item["features"]
+            : featureOfferingArrayDeserializer(item["features"]),
+        skus: !item["skus"] ? item["skus"] : skuOfferingArrayDeserializer(item["skus"]),
+    };
+}
+export function featureOfferingArrayDeserializer(result) {
+    return result.map((item) => {
+        return featureOfferingDeserializer(item);
+    });
+}
+export function featureOfferingDeserializer(item) {
+    return {
+        name: item["name"],
+    };
+}
+export function skuOfferingArrayDeserializer(result) {
+    return result.map((item) => {
+        return skuOfferingDeserializer(item);
+    });
+}
+export function skuOfferingDeserializer(item) {
+    return {
+        sku: !item["sku"] ? item["sku"] : skuDeserializer(item["sku"]),
+        limits: !item["limits"] ? item["limits"] : skuLimitsDeserializer(item["limits"]),
+    };
+}
+export function skuSerializer(item) {
+    return { name: item["name"] };
+}
+export function skuDeserializer(item) {
+    return {
+        name: item["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. */
+export var KnownSkuName;
+(function (KnownSkuName) {
+    /** Free tier, with no SLA guarantees and a subset of the features offered on billable tiers. */
+    KnownSkuName["Free"] = "free";
+    /** Billable tier for a dedicated service having up to 3 replicas. */
+    KnownSkuName["Basic"] = "basic";
+    /** Billable tier for a dedicated service having up to 12 partitions and 12 replicas. */
+    KnownSkuName["Standard"] = "standard";
+    /** Similar to 'standard', but with more capacity per search unit. */
+    KnownSkuName["Standard2"] = "standard2";
+    /** 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'). */
+    KnownSkuName["Standard3"] = "standard3";
+    /** Billable tier for a dedicated service that supports 1TB per partition, up to 12 partitions. */
+    KnownSkuName["StorageOptimizedL1"] = "storage_optimized_l1";
+    /** Billable tier for a dedicated service that supports 2TB per partition, up to 12 partitions. */
+    KnownSkuName["StorageOptimizedL2"] = "storage_optimized_l2";
+    /** Serverless tier, offering low-touch, consumption-based, and pay-as-you-go experience, with auto-scaling capabilities. */
+    KnownSkuName["Serverless"] = "serverless";
+})(KnownSkuName || (KnownSkuName = {}));
+export function skuLimitsDeserializer(item) {
+    return {
+        indexes: item["indexes"],
+        indexers: item["indexers"],
+        partitionStorageInGigabytes: item["partitionStorageInGigabytes"],
+        partitionVectorStorageInGigabytes: item["partitionVectorStorageInGigabytes"],
+        searchUnits: item["searchUnits"],
+        replicas: item["replicas"],
+        partitions: item["partitions"],
+    };
+}
+export function _operationListResultDeserializer(item) {
+    return {
+        value: !item["value"] ? item["value"] : operationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function operationArrayDeserializer(result) {
+    return result.map((item) => {
+        return operationDeserializer(item);
+    });
+}
+export function operationDeserializer(item) {
+    return {
+        name: item["name"],
+        isDataAction: item["isDataAction"],
+        display: !item["display"] ? item["display"] : operationDisplayDeserializer(item["display"]),
+        origin: item["origin"],
+        actionType: item["actionType"],
+    };
+}
+export function operationDisplayDeserializer(item) {
+    return {
+        provider: item["provider"],
+        resource: item["resource"],
+        operation: item["operation"],
+        description: item["description"],
+    };
+}
+/** The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" */
+export var KnownOrigin;
+(function (KnownOrigin) {
+    /** Indicates the operation is initiated by a user. */
+    KnownOrigin["User"] = "user";
+    /** Indicates the operation is initiated by a system. */
+    KnownOrigin["System"] = "system";
+    /** Indicates the operation is initiated by a user or system. */
+    KnownOrigin["UserSystem"] = "user,system";
+})(KnownOrigin || (KnownOrigin = {}));
+/** Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. */
+export var KnownActionType;
+(function (KnownActionType) {
+    /** Actions are for internal-only APIs. */
+    KnownActionType["Internal"] = "Internal";
+})(KnownActionType || (KnownActionType = {}));
+export function privateEndpointConnectionSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : privateEndpointConnectionPropertiesSerializer(item["properties"]),
+    };
+}
+export function privateEndpointConnectionDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : privateEndpointConnectionPropertiesDeserializer(item["properties"]),
+    };
+}
+export function privateEndpointConnectionPropertiesSerializer(item) {
+    return {
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointConnectionPropertiesPrivateEndpointSerializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: !item["privateLinkServiceConnectionState"]
+            ? item["privateLinkServiceConnectionState"]
+            : privateEndpointConnectionPropertiesPrivateLinkServiceConnectionStateSerializer(item["privateLinkServiceConnectionState"]),
+        groupId: item["groupId"],
+        provisioningState: item["provisioningState"],
+    };
+}
+export function privateEndpointConnectionPropertiesDeserializer(item) {
+    return {
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointConnectionPropertiesPrivateEndpointDeserializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: !item["privateLinkServiceConnectionState"]
+            ? item["privateLinkServiceConnectionState"]
+            : privateEndpointConnectionPropertiesPrivateLinkServiceConnectionStateDeserializer(item["privateLinkServiceConnectionState"]),
+        groupId: item["groupId"],
+        provisioningState: item["provisioningState"],
+    };
+}
+export function privateEndpointConnectionPropertiesPrivateEndpointSerializer(item) {
+    return { id: item["id"] };
+}
+export function privateEndpointConnectionPropertiesPrivateEndpointDeserializer(item) {
+    return {
+        id: item["id"],
+    };
+}
+export function privateEndpointConnectionPropertiesPrivateLinkServiceConnectionStateSerializer(item) {
+    return {
+        status: item["status"],
+        description: item["description"],
+        actionsRequired: item["actionsRequired"],
+    };
+}
+export function privateEndpointConnectionPropertiesPrivateLinkServiceConnectionStateDeserializer(item) {
+    return {
+        status: item["status"],
+        description: item["description"],
+        actionsRequired: item["actionsRequired"],
+    };
+}
+/** The provisioning state of the private link service connection. Valid values are Updating, Deleting, Failed, Succeeded, Incomplete, or Canceled. */
+export var KnownPrivateLinkServiceConnectionProvisioningState;
+(function (KnownPrivateLinkServiceConnectionProvisioningState) {
+    /** The private link service connection is in the process of being created along with other resources for it to be fully functional. */
+    KnownPrivateLinkServiceConnectionProvisioningState["Updating"] = "Updating";
+    /** The private link service connection is in the process of being deleted. */
+    KnownPrivateLinkServiceConnectionProvisioningState["Deleting"] = "Deleting";
+    /** The private link service connection has failed to be provisioned or deleted. */
+    KnownPrivateLinkServiceConnectionProvisioningState["Failed"] = "Failed";
+    /** The private link service connection has finished provisioning and is ready for approval. */
+    KnownPrivateLinkServiceConnectionProvisioningState["Succeeded"] = "Succeeded";
+    /** Provisioning request for the private link service connection resource has been accepted but the process of creation has not commenced yet. */
+    KnownPrivateLinkServiceConnectionProvisioningState["Incomplete"] = "Incomplete";
+    /** Provisioning request for the private link service connection resource has been canceled. */
+    KnownPrivateLinkServiceConnectionProvisioningState["Canceled"] = "Canceled";
+})(KnownPrivateLinkServiceConnectionProvisioningState || (KnownPrivateLinkServiceConnectionProvisioningState = {}));
+export function proxyResourceSerializer(_item) {
+    return {};
+}
+export function proxyResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+export function resourceSerializer(_item) {
+    return {};
+}
+export function resourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+export function systemDataDeserializer(item) {
+    return {
+        createdBy: item["createdBy"],
+        createdByType: item["createdByType"],
+        createdAt: !item["createdAt"] ? item["createdAt"] : new Date(item["createdAt"]),
+        lastModifiedBy: item["lastModifiedBy"],
+        lastModifiedByType: item["lastModifiedByType"],
+        lastModifiedAt: !item["lastModifiedAt"]
+            ? item["lastModifiedAt"]
+            : new Date(item["lastModifiedAt"]),
+    };
+}
+/** The kind of entity that created the resource. */
+export var KnownCreatedByType;
+(function (KnownCreatedByType) {
+    /** The entity was created by a user. */
+    KnownCreatedByType["User"] = "User";
+    /** The entity was created by an application. */
+    KnownCreatedByType["Application"] = "Application";
+    /** The entity was created by a managed identity. */
+    KnownCreatedByType["ManagedIdentity"] = "ManagedIdentity";
+    /** The entity was created by a key. */
+    KnownCreatedByType["Key"] = "Key";
+})(KnownCreatedByType || (KnownCreatedByType = {}));
+export function _privateEndpointConnectionListResultDeserializer(item) {
+    return {
+        value: !item["value"]
+            ? item["value"]
+            : privateEndpointConnectionArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function privateEndpointConnectionArraySerializer(result) {
+    return result.map((item) => {
+        return privateEndpointConnectionSerializer(item);
+    });
+}
+export function privateEndpointConnectionArrayDeserializer(result) {
+    return result.map((item) => {
+        return privateEndpointConnectionDeserializer(item);
+    });
+}
+export function sharedPrivateLinkResourceSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : sharedPrivateLinkResourcePropertiesSerializer(item["properties"]),
+    };
+}
+export function sharedPrivateLinkResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : sharedPrivateLinkResourcePropertiesDeserializer(item["properties"]),
+    };
+}
+export function sharedPrivateLinkResourcePropertiesSerializer(item) {
+    return {
+        privateLinkResourceId: item["privateLinkResourceId"],
+        groupId: item["groupId"],
+        requestMessage: item["requestMessage"],
+        resourceRegion: item["resourceRegion"],
+        status: item["status"],
+        provisioningState: item["provisioningState"],
+    };
+}
+export function sharedPrivateLinkResourcePropertiesDeserializer(item) {
+    return {
+        privateLinkResourceId: item["privateLinkResourceId"],
+        groupId: item["groupId"],
+        requestMessage: item["requestMessage"],
+        resourceRegion: item["resourceRegion"],
+        status: item["status"],
+        provisioningState: item["provisioningState"],
+    };
+}
+/** Status of the shared private link resource. Valid values are Pending, Approved, Rejected or Disconnected. */
+export var KnownSharedPrivateLinkResourceStatus;
+(function (KnownSharedPrivateLinkResourceStatus) {
+    /** The shared private link resource has been created and is pending approval. */
+    KnownSharedPrivateLinkResourceStatus["Pending"] = "Pending";
+    /** The shared private link resource is approved and is ready for use. */
+    KnownSharedPrivateLinkResourceStatus["Approved"] = "Approved";
+    /** The shared private link resource has been rejected and cannot be used. */
+    KnownSharedPrivateLinkResourceStatus["Rejected"] = "Rejected";
+    /** The shared private link resource has been removed from the service. */
+    KnownSharedPrivateLinkResourceStatus["Disconnected"] = "Disconnected";
+})(KnownSharedPrivateLinkResourceStatus || (KnownSharedPrivateLinkResourceStatus = {}));
+/** The provisioning state of the shared private link resource. Valid values are Updating, Deleting, Failed, Succeeded or Incomplete. */
+export var KnownSharedPrivateLinkResourceProvisioningState;
+(function (KnownSharedPrivateLinkResourceProvisioningState) {
+    /** The shared private link resource is in the process of being created along with other resources for it to be fully functional. */
+    KnownSharedPrivateLinkResourceProvisioningState["Updating"] = "Updating";
+    /** The shared private link resource is in the process of being deleted. */
+    KnownSharedPrivateLinkResourceProvisioningState["Deleting"] = "Deleting";
+    /** The shared private link resource has failed to be provisioned or deleted. */
+    KnownSharedPrivateLinkResourceProvisioningState["Failed"] = "Failed";
+    /** The shared private link resource has finished provisioning and is ready for approval. */
+    KnownSharedPrivateLinkResourceProvisioningState["Succeeded"] = "Succeeded";
+    /** Provisioning request for the shared private link resource has been accepted but the process of creation has not commenced yet. */
+    KnownSharedPrivateLinkResourceProvisioningState["Incomplete"] = "Incomplete";
+})(KnownSharedPrivateLinkResourceProvisioningState || (KnownSharedPrivateLinkResourceProvisioningState = {}));
+export function _sharedPrivateLinkResourceListResultDeserializer(item) {
+    return {
+        value: !item["value"]
+            ? item["value"]
+            : sharedPrivateLinkResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function sharedPrivateLinkResourceArraySerializer(result) {
+    return result.map((item) => {
+        return sharedPrivateLinkResourceSerializer(item);
+    });
+}
+export function sharedPrivateLinkResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return sharedPrivateLinkResourceDeserializer(item);
+    });
+}
+export function networkSecurityPerimeterConfigurationDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : networkSecurityPerimeterConfigurationPropertiesDeserializer(item["properties"]),
+    };
+}
+export function networkSecurityPerimeterConfigurationPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        provisioningIssues: !item["provisioningIssues"]
+            ? item["provisioningIssues"]
+            : provisioningIssueArrayDeserializer(item["provisioningIssues"]),
+        networkSecurityPerimeter: !item["networkSecurityPerimeter"]
+            ? item["networkSecurityPerimeter"]
+            : networkSecurityPerimeterDeserializer(item["networkSecurityPerimeter"]),
+        resourceAssociation: !item["resourceAssociation"]
+            ? item["resourceAssociation"]
+            : resourceAssociationDeserializer(item["resourceAssociation"]),
+        profile: !item["profile"]
+            ? item["profile"]
+            : networkSecurityProfileDeserializer(item["profile"]),
+    };
+}
+/** Provisioning state of a network security perimeter configuration that is being created or updated. */
+export var KnownNetworkSecurityPerimeterConfigurationProvisioningState;
+(function (KnownNetworkSecurityPerimeterConfigurationProvisioningState) {
+    /** Succeeded */
+    KnownNetworkSecurityPerimeterConfigurationProvisioningState["Succeeded"] = "Succeeded";
+    /** Creating */
+    KnownNetworkSecurityPerimeterConfigurationProvisioningState["Creating"] = "Creating";
+    /** Updating */
+    KnownNetworkSecurityPerimeterConfigurationProvisioningState["Updating"] = "Updating";
+    /** Deleting */
+    KnownNetworkSecurityPerimeterConfigurationProvisioningState["Deleting"] = "Deleting";
+    /** Accepted */
+    KnownNetworkSecurityPerimeterConfigurationProvisioningState["Accepted"] = "Accepted";
+    /** Failed */
+    KnownNetworkSecurityPerimeterConfigurationProvisioningState["Failed"] = "Failed";
+    /** Canceled */
+    KnownNetworkSecurityPerimeterConfigurationProvisioningState["Canceled"] = "Canceled";
+})(KnownNetworkSecurityPerimeterConfigurationProvisioningState || (KnownNetworkSecurityPerimeterConfigurationProvisioningState = {}));
+export function provisioningIssueArrayDeserializer(result) {
+    return result.map((item) => {
+        return provisioningIssueDeserializer(item);
+    });
+}
+export function provisioningIssueDeserializer(item) {
+    return {
+        name: item["name"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : provisioningIssuePropertiesDeserializer(item["properties"]),
+    };
+}
+export function provisioningIssuePropertiesDeserializer(item) {
+    return {
+        issueType: item["issueType"],
+        severity: item["severity"],
+        description: item["description"],
+        suggestedResourceIds: !item["suggestedResourceIds"]
+            ? item["suggestedResourceIds"]
+            : item["suggestedResourceIds"].map((p) => {
+                return p;
+            }),
+        suggestedAccessRules: !item["suggestedAccessRules"]
+            ? item["suggestedAccessRules"]
+            : accessRuleArrayDeserializer(item["suggestedAccessRules"]),
+    };
+}
+/** Type of issue */
+export var KnownIssueType;
+(function (KnownIssueType) {
+    /** Unknown issue type */
+    KnownIssueType["Unknown"] = "Unknown";
+    /** An error occurred while applying the network security perimeter (NSP) configuration. */
+    KnownIssueType["ConfigurationPropagationFailure"] = "ConfigurationPropagationFailure";
+    /** A network connectivity issue is happening on the resource which could be addressed either by adding new resources to the network security perimeter (NSP) or by modifying access rules. */
+    KnownIssueType["MissingPerimeterConfiguration"] = "MissingPerimeterConfiguration";
+    /** An managed identity hasn't been associated with the resource. The resource will still be able to validate inbound traffic from the network security perimeter (NSP) or matching inbound access rules, but it won't be able to perform outbound access as a member of the NSP. */
+    KnownIssueType["MissingIdentityConfiguration"] = "MissingIdentityConfiguration";
+})(KnownIssueType || (KnownIssueType = {}));
+/** Severity of the issue. */
+export var KnownSeverity;
+(function (KnownSeverity) {
+    /** Warning */
+    KnownSeverity["Warning"] = "Warning";
+    /** Error */
+    KnownSeverity["Error"] = "Error";
+})(KnownSeverity || (KnownSeverity = {}));
+export function accessRuleArrayDeserializer(result) {
+    return result.map((item) => {
+        return accessRuleDeserializer(item);
+    });
+}
+export function accessRuleDeserializer(item) {
+    return {
+        name: item["name"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : accessRulePropertiesDeserializer(item["properties"]),
+    };
+}
+export function accessRulePropertiesDeserializer(item) {
+    return {
+        direction: item["direction"],
+        addressPrefixes: !item["addressPrefixes"]
+            ? item["addressPrefixes"]
+            : item["addressPrefixes"].map((p) => {
+                return p;
+            }),
+        subscriptions: !item["subscriptions"]
+            ? item["subscriptions"]
+            : accessRulePropertiesSubscriptionsItemArrayDeserializer(item["subscriptions"]),
+        networkSecurityPerimeters: !item["networkSecurityPerimeters"]
+            ? item["networkSecurityPerimeters"]
+            : networkSecurityPerimeterArrayDeserializer(item["networkSecurityPerimeters"]),
+        fullyQualifiedDomainNames: !item["fullyQualifiedDomainNames"]
+            ? item["fullyQualifiedDomainNames"]
+            : item["fullyQualifiedDomainNames"].map((p) => {
+                return p;
+            }),
+        emailAddresses: !item["emailAddresses"]
+            ? item["emailAddresses"]
+            : item["emailAddresses"].map((p) => {
+                return p;
+            }),
+        phoneNumbers: !item["phoneNumbers"]
+            ? item["phoneNumbers"]
+            : item["phoneNumbers"].map((p) => {
+                return p;
+            }),
+    };
+}
+/** Direction of Access Rule */
+export var KnownAccessRuleDirection;
+(function (KnownAccessRuleDirection) {
+    /** Applies to inbound network traffic to the secured resources. */
+    KnownAccessRuleDirection["Inbound"] = "Inbound";
+    /** Applies to outbound network traffic from the secured resources */
+    KnownAccessRuleDirection["Outbound"] = "Outbound";
+})(KnownAccessRuleDirection || (KnownAccessRuleDirection = {}));
+export function accessRulePropertiesSubscriptionsItemArrayDeserializer(result) {
+    return result.map((item) => {
+        return accessRulePropertiesSubscriptionsItemDeserializer(item);
+    });
+}
+export function accessRulePropertiesSubscriptionsItemDeserializer(item) {
+    return {
+        id: item["id"],
+    };
+}
+export function networkSecurityPerimeterArrayDeserializer(result) {
+    return result.map((item) => {
+        return networkSecurityPerimeterDeserializer(item);
+    });
+}
+export function networkSecurityPerimeterDeserializer(item) {
+    return {
+        id: item["id"],
+        perimeterGuid: item["perimeterGuid"],
+        location: item["location"],
+    };
+}
+export function resourceAssociationDeserializer(item) {
+    return {
+        name: item["name"],
+        accessMode: item["accessMode"],
+    };
+}
+/** Access mode of the resource association */
+export var KnownResourceAssociationAccessMode;
+(function (KnownResourceAssociationAccessMode) {
+    /** Enforced access mode - traffic to the resource that failed access checks is blocked */
+    KnownResourceAssociationAccessMode["Enforced"] = "Enforced";
+    /** Learning access mode - traffic to the resource is enabled for analysis but not blocked */
+    KnownResourceAssociationAccessMode["Learning"] = "Learning";
+    /** Audit access mode - traffic to the resource that fails access checks is logged but not blocked */
+    KnownResourceAssociationAccessMode["Audit"] = "Audit";
+})(KnownResourceAssociationAccessMode || (KnownResourceAssociationAccessMode = {}));
+export function networkSecurityProfileDeserializer(item) {
+    return {
+        name: item["name"],
+        accessRulesVersion: item["accessRulesVersion"],
+        accessRules: !item["accessRules"]
+            ? item["accessRules"]
+            : accessRuleArrayDeserializer(item["accessRules"]),
+        diagnosticSettingsVersion: item["diagnosticSettingsVersion"],
+        enabledLogCategories: !item["enabledLogCategories"]
+            ? item["enabledLogCategories"]
+            : item["enabledLogCategories"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function _networkSecurityPerimeterConfigurationListResultDeserializer(item) {
+    return {
+        value: networkSecurityPerimeterConfigurationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function networkSecurityPerimeterConfigurationArrayDeserializer(result) {
+    return result.map((item) => {
+        return networkSecurityPerimeterConfigurationDeserializer(item);
+    });
+}
+export function checkNameAvailabilityInputSerializer(item) {
+    return { name: item["name"], type: item["type"] };
+}
+export function checkNameAvailabilityOutputDeserializer(item) {
+    return {
+        isNameAvailable: item["nameAvailable"],
+        reason: item["reason"],
+        message: item["message"],
+    };
+}
+/** The reason why the name is not available. 'Invalid' indicates the name provided does not match the naming requirements (incorrect length, unsupported characters, etc.). 'AlreadyExists' indicates that the name is already in use and is therefore unavailable. */
+export var KnownUnavailableNameReason;
+(function (KnownUnavailableNameReason) {
+    /** The search service name doesn't match naming requirements. */
+    KnownUnavailableNameReason["Invalid"] = "Invalid";
+    /** The search service name is already assigned to a different search service. */
+    KnownUnavailableNameReason["AlreadyExists"] = "AlreadyExists";
+})(KnownUnavailableNameReason || (KnownUnavailableNameReason = {}));
+export function searchServiceSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: areAllPropsUndefined(item, [
+            "replicaCount",
+            "partitionCount",
+            "endpoint",
+            "hostingMode",
+            "computeType",
+            "publicNetworkAccess",
+            "networkRuleSet",
+            "dataExfiltrationProtections",
+            "encryptionWithCmk",
+            "disableLocalAuth",
+            "authOptions",
+            "semanticSearch",
+            "knowledgeRetrieval",
+            "upgradeAvailable",
+        ])
+            ? undefined
+            : _searchServicePropertiesSerializer(item),
+        sku: !item["sku"] ? item["sku"] : skuSerializer(item["sku"]),
+        identity: !item["identity"] ? item["identity"] : identitySerializer(item["identity"]),
+    };
+}
+export function searchServiceDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _searchServicePropertiesDeserializer(item["properties"])),
+        sku: !item["sku"] ? item["sku"] : skuDeserializer(item["sku"]),
+        identity: !item["identity"] ? item["identity"] : identityDeserializer(item["identity"]),
+    };
+}
+export function searchServicePropertiesSerializer(item) {
+    return {
+        replicaCount: item["replicaCount"],
+        partitionCount: item["partitionCount"],
+        endpoint: item["endpoint"],
+        hostingMode: item["hostingMode"],
+        computeType: item["computeType"],
+        publicNetworkAccess: item["publicNetworkAccess"],
+        networkRuleSet: !item["networkRuleSet"]
+            ? item["networkRuleSet"]
+            : networkRuleSetSerializer(item["networkRuleSet"]),
+        dataExfiltrationProtections: !item["dataExfiltrationProtections"]
+            ? item["dataExfiltrationProtections"]
+            : item["dataExfiltrationProtections"].map((p) => {
+                return p;
+            }),
+        encryptionWithCmk: !item["encryptionWithCmk"]
+            ? item["encryptionWithCmk"]
+            : encryptionWithCmkSerializer(item["encryptionWithCmk"]),
+        disableLocalAuth: item["disableLocalAuth"],
+        authOptions: !item["authOptions"]
+            ? item["authOptions"]
+            : dataPlaneAuthOptionsSerializer(item["authOptions"]),
+        semanticSearch: item["semanticSearch"],
+        knowledgeRetrieval: item["knowledgeRetrieval"],
+        upgradeAvailable: item["upgradeAvailable"],
+    };
+}
+export function searchServicePropertiesDeserializer(item) {
+    return {
+        replicaCount: item["replicaCount"],
+        partitionCount: item["partitionCount"],
+        endpoint: item["endpoint"],
+        hostingMode: item["hostingMode"],
+        computeType: item["computeType"],
+        publicNetworkAccess: item["publicNetworkAccess"],
+        status: item["status"],
+        statusDetails: item["statusDetails"],
+        provisioningState: item["provisioningState"],
+        networkRuleSet: !item["networkRuleSet"]
+            ? item["networkRuleSet"]
+            : networkRuleSetDeserializer(item["networkRuleSet"]),
+        dataExfiltrationProtections: !item["dataExfiltrationProtections"]
+            ? item["dataExfiltrationProtections"]
+            : item["dataExfiltrationProtections"].map((p) => {
+                return p;
+            }),
+        encryptionWithCmk: !item["encryptionWithCmk"]
+            ? item["encryptionWithCmk"]
+            : encryptionWithCmkDeserializer(item["encryptionWithCmk"]),
+        disableLocalAuth: item["disableLocalAuth"],
+        authOptions: !item["authOptions"]
+            ? item["authOptions"]
+            : dataPlaneAuthOptionsDeserializer(item["authOptions"]),
+        semanticSearch: item["semanticSearch"],
+        knowledgeRetrieval: item["knowledgeRetrieval"],
+        privateEndpointConnections: !item["privateEndpointConnections"]
+            ? item["privateEndpointConnections"]
+            : privateEndpointConnectionArrayDeserializer(item["privateEndpointConnections"]),
+        sharedPrivateLinkResources: !item["sharedPrivateLinkResources"]
+            ? item["sharedPrivateLinkResources"]
+            : sharedPrivateLinkResourceArrayDeserializer(item["sharedPrivateLinkResources"]),
+        eTag: item["eTag"],
+        upgradeAvailable: item["upgradeAvailable"],
+        serviceUpgradedAt: !item["serviceUpgradedAt"]
+            ? item["serviceUpgradedAt"]
+            : new Date(item["serviceUpgradedAt"]),
+    };
+}
+/** Configure this property to support the search service using either the Default Compute or Azure Confidential Compute. */
+export var KnownComputeType;
+(function (KnownComputeType) {
+    /** Create the service with the Default Compute. */
+    KnownComputeType["Default"] = "Default";
+    /** Create the dedicated service with Azure Confidential Compute. */
+    KnownComputeType["Confidential"] = "Confidential";
+})(KnownComputeType || (KnownComputeType = {}));
+/** 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. */
+export var KnownPublicNetworkAccess;
+(function (KnownPublicNetworkAccess) {
+    /** The search service is accessible from traffic originating from the public internet. */
+    KnownPublicNetworkAccess["Enabled"] = "Enabled";
+    /** The search service is not accessible from traffic originating from the public internet. Access is only permitted over approved private endpoint connections. */
+    KnownPublicNetworkAccess["Disabled"] = "Disabled";
+    /** The network security perimeter configuration rules allow or disallow public network access to the resource. Requires an associated network security perimeter. */
+    KnownPublicNetworkAccess["SecuredByPerimeter"] = "SecuredByPerimeter";
+})(KnownPublicNetworkAccess || (KnownPublicNetworkAccess = {}));
+export function networkRuleSetSerializer(item) {
+    return {
+        ipRules: !item["ipRules"] ? item["ipRules"] : ipRuleArraySerializer(item["ipRules"]),
+        bypass: item["bypass"],
+    };
+}
+export function networkRuleSetDeserializer(item) {
+    return {
+        ipRules: !item["ipRules"] ? item["ipRules"] : ipRuleArrayDeserializer(item["ipRules"]),
+        bypass: item["bypass"],
+    };
+}
+export function ipRuleArraySerializer(result) {
+    return result.map((item) => {
+        return ipRuleSerializer(item);
+    });
+}
+export function ipRuleArrayDeserializer(result) {
+    return result.map((item) => {
+        return ipRuleDeserializer(item);
+    });
+}
+export function ipRuleSerializer(item) {
+    return { value: item["value"] };
+}
+export function ipRuleDeserializer(item) {
+    return {
+        value: item["value"],
+    };
+}
+/** Possible origins of inbound traffic that can bypass the rules defined in the 'ipRules' section. */
+export var KnownSearchBypass;
+(function (KnownSearchBypass) {
+    /** Indicates that no origin can bypass the rules defined in the 'ipRules' section. This is the default. */
+    KnownSearchBypass["None"] = "None";
+    /** Indicates that requests originating from the Azure Portal can bypass the rules defined in the 'ipRules' section. */
+    KnownSearchBypass["AzurePortal"] = "AzurePortal";
+    /** Indicates that requests originating from Azure trusted services can bypass the rules defined in the 'ipRules' section. */
+    KnownSearchBypass["AzureServices"] = "AzureServices";
+})(KnownSearchBypass || (KnownSearchBypass = {}));
+/** A specific data exfiltration scenario that is disabled for the service. */
+export var KnownSearchDataExfiltrationProtection;
+(function (KnownSearchDataExfiltrationProtection) {
+    /** Indicates that all data exfiltration scenarios are disabled. */
+    KnownSearchDataExfiltrationProtection["BlockAll"] = "BlockAll";
+})(KnownSearchDataExfiltrationProtection || (KnownSearchDataExfiltrationProtection = {}));
+export function encryptionWithCmkSerializer(item) {
+    return {
+        enforcement: item["enforcement"],
+        serviceLevelEncryptionKey: !item["serviceLevelEncryptionKey"]
+            ? item["serviceLevelEncryptionKey"]
+            : searchResourceEncryptionKeySerializer(item["serviceLevelEncryptionKey"]),
+    };
+}
+export function encryptionWithCmkDeserializer(item) {
+    return {
+        enforcement: item["enforcement"],
+        encryptionComplianceStatus: item["encryptionComplianceStatus"],
+        serviceLevelEncryptionKey: !item["serviceLevelEncryptionKey"]
+            ? item["serviceLevelEncryptionKey"]
+            : searchResourceEncryptionKeyDeserializer(item["serviceLevelEncryptionKey"]),
+    };
+}
+export function searchResourceEncryptionKeySerializer(item) {
+    return {
+        keyVaultKeyName: item["keyName"],
+        keyVaultKeyVersion: item["keyVersion"],
+        keyVaultUri: item["vaultUri"],
+        identity: !item["identity"] ? item["identity"] : dataIdentityUnionSerializer(item["identity"]),
+        accessCredentials: !item["accessCredentials"]
+            ? item["accessCredentials"]
+            : azureActiveDirectoryApplicationCredentialsSerializer(item["accessCredentials"]),
+    };
+}
+export function searchResourceEncryptionKeyDeserializer(item) {
+    return {
+        keyName: item["keyVaultKeyName"],
+        keyVersion: item["keyVaultKeyVersion"],
+        vaultUri: item["keyVaultUri"],
+        identity: !item["identity"]
+            ? item["identity"]
+            : dataIdentityUnionDeserializer(item["identity"]),
+        accessCredentials: !item["accessCredentials"]
+            ? item["accessCredentials"]
+            : azureActiveDirectoryApplicationCredentialsDeserializer(item["accessCredentials"]),
+    };
+}
+export function dataIdentitySerializer(item) {
+    return { "@odata.type": item["odataType"] };
+}
+export function dataIdentityDeserializer(item) {
+    return {
+        odataType: item["@odata.type"],
+    };
+}
+export function dataIdentityUnionSerializer(item) {
+    switch (item.odataType) {
+        case "#Microsoft.Azure.Search.DataNoneIdentity":
+            return dataNoneIdentitySerializer(item);
+        case "#Microsoft.Azure.Search.DataUserAssignedIdentity":
+            return dataUserAssignedIdentitySerializer(item);
+        default:
+            return dataIdentitySerializer(item);
+    }
+}
+export function dataIdentityUnionDeserializer(item) {
+    switch (item["@odata.type"]) {
+        case "#Microsoft.Azure.Search.DataNoneIdentity":
+            return dataNoneIdentityDeserializer(item);
+        case "#Microsoft.Azure.Search.DataUserAssignedIdentity":
+            return dataUserAssignedIdentityDeserializer(item);
+        default:
+            return dataIdentityDeserializer(item);
+    }
+}
+export function dataNoneIdentitySerializer(item) {
+    return { "@odata.type": item["odataType"] };
+}
+export function dataNoneIdentityDeserializer(item) {
+    return {
+        odataType: item["@odata.type"],
+    };
+}
+export function dataUserAssignedIdentitySerializer(item) {
+    return {
+        "@odata.type": item["odataType"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+        federatedIdentityClientId: item["federatedIdentityClientId"],
+    };
+}
+export function dataUserAssignedIdentityDeserializer(item) {
+    return {
+        odataType: item["@odata.type"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+        federatedIdentityClientId: item["federatedIdentityClientId"],
+    };
+}
+export function azureActiveDirectoryApplicationCredentialsSerializer(item) {
+    return { applicationId: item["applicationId"], applicationSecret: item["applicationSecret"] };
+}
+export function azureActiveDirectoryApplicationCredentialsDeserializer(item) {
+    return {
+        applicationId: item["applicationId"],
+        applicationSecret: item["applicationSecret"],
+    };
+}
+export function dataPlaneAuthOptionsSerializer(item) {
+    return {
+        apiKeyOnly: item["apiKeyOnly"],
+        aadOrApiKey: !item["aadOrApiKey"]
+            ? item["aadOrApiKey"]
+            : dataPlaneAadOrApiKeyAuthOptionSerializer(item["aadOrApiKey"]),
+    };
+}
+export function dataPlaneAuthOptionsDeserializer(item) {
+    return {
+        apiKeyOnly: item["apiKeyOnly"],
+        aadOrApiKey: !item["aadOrApiKey"]
+            ? item["aadOrApiKey"]
+            : dataPlaneAadOrApiKeyAuthOptionDeserializer(item["aadOrApiKey"]),
+    };
+}
+export function dataPlaneAadOrApiKeyAuthOptionSerializer(item) {
+    return { aadAuthFailureMode: item["aadAuthFailureMode"] };
+}
+export function dataPlaneAadOrApiKeyAuthOptionDeserializer(item) {
+    return {
+        aadAuthFailureMode: item["aadAuthFailureMode"],
+    };
+}
+/** 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. */
+export var KnownSearchSemanticSearch;
+(function (KnownSearchSemanticSearch) {
+    /** Indicates that semantic reranker is disabled for the search service. */
+    KnownSearchSemanticSearch["Disabled"] = "disabled";
+    /** Enables semantic reranker on a search service and indicates that it is to be used within the limits of the free plan. The free plan would cap the volume of semantic ranking requests and is offered at no extra charge. This is the default for newly provisioned search services. This is the default. */
+    KnownSearchSemanticSearch["Free"] = "free";
+    /** Enables semantic reranker on a search service as a billable feature after the free quota is exhausted, with higher throughput and volume of semantically reranked queries. */
+    KnownSearchSemanticSearch["Standard"] = "standard";
+})(KnownSearchSemanticSearch || (KnownSearchSemanticSearch = {}));
+/** 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. */
+export var KnownKnowledgeRetrieval;
+(function (KnownKnowledgeRetrieval) {
+    /** Enables knowledge retrieval on a search service and indicates that it is to be used within the limits of the free plan. The free plan would cap the volume of knowledge retrieval requests and is offered at no extra charge. */
+    KnownKnowledgeRetrieval["Free"] = "free";
+    /** Enables knowledge retrieval on a search service as a billable feature after the free quota is exhausted, with higher throughput and volume of knowledge retrieval requests. */
+    KnownKnowledgeRetrieval["Standard"] = "standard";
+})(KnownKnowledgeRetrieval || (KnownKnowledgeRetrieval = {}));
+/** Indicates if the dedicated search service has an upgrade available. */
+export var KnownUpgradeAvailable;
+(function (KnownUpgradeAvailable) {
+    /** An upgrade is currently not available for the dedicated service. */
+    KnownUpgradeAvailable["NotAvailable"] = "notAvailable";
+    /** There is an upgrade available for the dedicated service. */
+    KnownUpgradeAvailable["Available"] = "available";
+})(KnownUpgradeAvailable || (KnownUpgradeAvailable = {}));
+export function identitySerializer(item) {
+    return {
+        type: item["type"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : userAssignedIdentityRecordSerializer(item["userAssignedIdentities"]),
+    };
+}
+export function identityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        tenantId: item["tenantId"],
+        type: item["type"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : userAssignedIdentityRecordDeserializer(item["userAssignedIdentities"]),
+    };
+}
+/** 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. */
+export var KnownIdentityType;
+(function (KnownIdentityType) {
+    /** Indicates that any identity associated with the search service needs to be removed. */
+    KnownIdentityType["None"] = "None";
+    /** Indicates that system-assigned identity for the search service will be enabled. */
+    KnownIdentityType["SystemAssigned"] = "SystemAssigned";
+    /** Indicates that one or more user assigned identities will be assigned to the search service. */
+    KnownIdentityType["UserAssigned"] = "UserAssigned";
+    /** Indicates that system-assigned identity for the search service will be enabled along with the assignment of one or more user assigned identities. */
+    KnownIdentityType["SystemAssignedUserAssigned"] = "SystemAssigned, UserAssigned";
+})(KnownIdentityType || (KnownIdentityType = {}));
+export function userAssignedIdentityRecordSerializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userAssignedIdentitySerializer(item[key]);
+    });
+    return result;
+}
+export function userAssignedIdentityRecordDeserializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userAssignedIdentityDeserializer(item[key]);
+    });
+    return result;
+}
+export function userAssignedIdentitySerializer(_item) {
+    return {};
+}
+export function userAssignedIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        clientId: item["clientId"],
+    };
+}
+export function trackedResourceSerializer(item) {
+    return { tags: item["tags"], location: item["location"] };
+}
+export function trackedResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+    };
+}
+export function searchServiceUpdateSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, [
+            "replicaCount",
+            "partitionCount",
+            "endpoint",
+            "hostingMode",
+            "computeType",
+            "publicNetworkAccess",
+            "networkRuleSet",
+            "dataExfiltrationProtections",
+            "encryptionWithCmk",
+            "disableLocalAuth",
+            "authOptions",
+            "semanticSearch",
+            "knowledgeRetrieval",
+            "upgradeAvailable",
+        ])
+            ? undefined
+            : _searchServiceUpdatePropertiesSerializer(item),
+        sku: !item["sku"] ? item["sku"] : skuSerializer(item["sku"]),
+        location: item["location"],
+        tags: item["tags"],
+        identity: !item["identity"] ? item["identity"] : identitySerializer(item["identity"]),
+    };
+}
+export function _searchServiceListResultDeserializer(item) {
+    return {
+        value: !item["value"] ? item["value"] : searchServiceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function searchServiceArraySerializer(result) {
+    return result.map((item) => {
+        return searchServiceSerializer(item);
+    });
+}
+export function searchServiceArrayDeserializer(result) {
+    return result.map((item) => {
+        return searchServiceDeserializer(item);
+    });
+}
+export function _quotaUsagesListResultDeserializer(item) {
+    return {
+        value: !item["value"] ? item["value"] : quotaUsageResultArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function quotaUsageResultArrayDeserializer(result) {
+    return result.map((item) => {
+        return quotaUsageResultDeserializer(item);
+    });
+}
+export function adminKeyResultDeserializer(item) {
+    return {
+        primaryKey: item["primaryKey"],
+        secondaryKey: item["secondaryKey"],
+    };
+}
+export function queryKeyDeserializer(item) {
+    return {
+        name: item["name"],
+        key: item["key"],
+    };
+}
+export function _listQueryKeysResultDeserializer(item) {
+    return {
+        value: !item["value"] ? item["value"] : queryKeyArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function queryKeyArrayDeserializer(result) {
+    return result.map((item) => {
+        return queryKeyDeserializer(item);
+    });
+}
+export function _privateLinkResourcesResultDeserializer(item) {
+    return {
+        value: !item["value"] ? item["value"] : privateLinkResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function privateLinkResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return privateLinkResourceDeserializer(item);
+    });
+}
+export function privateLinkResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : privateLinkResourcePropertiesDeserializer(item["properties"]),
+    };
+}
+export function privateLinkResourcePropertiesDeserializer(item) {
+    return {
+        groupId: item["groupId"],
+        requiredMembers: !item["requiredMembers"]
+            ? item["requiredMembers"]
+            : item["requiredMembers"].map((p) => {
+                return p;
+            }),
+        requiredZoneNames: !item["requiredZoneNames"]
+            ? item["requiredZoneNames"]
+            : item["requiredZoneNames"].map((p) => {
+                return p;
+            }),
+        shareablePrivateLinkResourceTypes: !item["shareablePrivateLinkResourceTypes"]
+            ? item["shareablePrivateLinkResourceTypes"]
+            : shareablePrivateLinkResourceTypeArrayDeserializer(item["shareablePrivateLinkResourceTypes"]),
+    };
+}
+export function shareablePrivateLinkResourceTypeArrayDeserializer(result) {
+    return result.map((item) => {
+        return shareablePrivateLinkResourceTypeDeserializer(item);
+    });
+}
+export function shareablePrivateLinkResourceTypeDeserializer(item) {
+    return {
+        name: item["name"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : shareablePrivateLinkResourcePropertiesDeserializer(item["properties"]),
+    };
+}
+export function shareablePrivateLinkResourcePropertiesDeserializer(item) {
+    return {
+        type: item["type"],
+        groupId: item["groupId"],
+        description: item["description"],
+    };
+}
+/** The available API versions. */
+export var KnownVersions;
+(function (KnownVersions) {
+    /** The 2025-05-01 API version. */
+    KnownVersions["V20250501"] = "2025-05-01";
+    /** The 2026-03-01-preview API version. */
+    KnownVersions["V20260301Preview"] = "2026-03-01-preview";
+})(KnownVersions || (KnownVersions = {}));
+export function _searchServicePropertiesSerializer(item) {
+    return {
+        replicaCount: item["replicaCount"],
+        partitionCount: item["partitionCount"],
+        endpoint: item["endpoint"],
+        hostingMode: item["hostingMode"],
+        computeType: item["computeType"],
+        publicNetworkAccess: item["publicNetworkAccess"],
+        networkRuleSet: !item["networkRuleSet"]
+            ? item["networkRuleSet"]
+            : networkRuleSetSerializer(item["networkRuleSet"]),
+        dataExfiltrationProtections: !item["dataExfiltrationProtections"]
+            ? item["dataExfiltrationProtections"]
+            : item["dataExfiltrationProtections"].map((p) => {
+                return p;
+            }),
+        encryptionWithCmk: !item["encryptionWithCmk"]
+            ? item["encryptionWithCmk"]
+            : encryptionWithCmkSerializer(item["encryptionWithCmk"]),
+        disableLocalAuth: item["disableLocalAuth"],
+        authOptions: !item["authOptions"]
+            ? item["authOptions"]
+            : dataPlaneAuthOptionsSerializer(item["authOptions"]),
+        semanticSearch: item["semanticSearch"],
+        knowledgeRetrieval: item["knowledgeRetrieval"],
+        upgradeAvailable: item["upgradeAvailable"],
+    };
+}
+export function _searchServicePropertiesDeserializer(item) {
+    return {
+        replicaCount: item["replicaCount"],
+        partitionCount: item["partitionCount"],
+        endpoint: item["endpoint"],
+        hostingMode: item["hostingMode"],
+        computeType: item["computeType"],
+        publicNetworkAccess: item["publicNetworkAccess"],
+        status: item["status"],
+        statusDetails: item["statusDetails"],
+        provisioningState: item["provisioningState"],
+        networkRuleSet: !item["networkRuleSet"]
+            ? item["networkRuleSet"]
+            : networkRuleSetDeserializer(item["networkRuleSet"]),
+        dataExfiltrationProtections: !item["dataExfiltrationProtections"]
+            ? item["dataExfiltrationProtections"]
+            : item["dataExfiltrationProtections"].map((p) => {
+                return p;
+            }),
+        encryptionWithCmk: !item["encryptionWithCmk"]
+            ? item["encryptionWithCmk"]
+            : encryptionWithCmkDeserializer(item["encryptionWithCmk"]),
+        disableLocalAuth: item["disableLocalAuth"],
+        authOptions: !item["authOptions"]
+            ? item["authOptions"]
+            : dataPlaneAuthOptionsDeserializer(item["authOptions"]),
+        semanticSearch: item["semanticSearch"],
+        knowledgeRetrieval: item["knowledgeRetrieval"],
+        privateEndpointConnections: !item["privateEndpointConnections"]
+            ? item["privateEndpointConnections"]
+            : privateEndpointConnectionArrayDeserializer(item["privateEndpointConnections"]),
+        sharedPrivateLinkResources: !item["sharedPrivateLinkResources"]
+            ? item["sharedPrivateLinkResources"]
+            : sharedPrivateLinkResourceArrayDeserializer(item["sharedPrivateLinkResources"]),
+        eTag: item["eTag"],
+        upgradeAvailable: item["upgradeAvailable"],
+        serviceUpgradedAt: !item["serviceUpgradedAt"]
+            ? item["serviceUpgradedAt"]
+            : new Date(item["serviceUpgradedAt"]),
+    };
+}
+export function _searchServiceUpdatePropertiesSerializer(item) {
+    return {
+        replicaCount: item["replicaCount"],
+        partitionCount: item["partitionCount"],
+        endpoint: item["endpoint"],
+        hostingMode: item["hostingMode"],
+        computeType: item["computeType"],
+        publicNetworkAccess: item["publicNetworkAccess"],
+        networkRuleSet: !item["networkRuleSet"]
+            ? item["networkRuleSet"]
+            : networkRuleSetSerializer(item["networkRuleSet"]),
+        dataExfiltrationProtections: !item["dataExfiltrationProtections"]
+            ? item["dataExfiltrationProtections"]
+            : item["dataExfiltrationProtections"].map((p) => {
+                return p;
+            }),
+        encryptionWithCmk: !item["encryptionWithCmk"]
+            ? item["encryptionWithCmk"]
+            : encryptionWithCmkSerializer(item["encryptionWithCmk"]),
+        disableLocalAuth: item["disableLocalAuth"],
+        authOptions: !item["authOptions"]
+            ? item["authOptions"]
+            : dataPlaneAuthOptionsSerializer(item["authOptions"]),
+        semanticSearch: item["semanticSearch"],
+        knowledgeRetrieval: item["knowledgeRetrieval"],
+        upgradeAvailable: item["upgradeAvailable"],
+    };
+}
+export function _searchServiceUpdatePropertiesDeserializer(item) {
+    return {
+        replicaCount: item["replicaCount"],
+        partitionCount: item["partitionCount"],
+        endpoint: item["endpoint"],
+        hostingMode: item["hostingMode"],
+        computeType: item["computeType"],
+        publicNetworkAccess: item["publicNetworkAccess"],
+        status: item["status"],
+        statusDetails: item["statusDetails"],
+        provisioningState: item["provisioningState"],
+        networkRuleSet: !item["networkRuleSet"]
+            ? item["networkRuleSet"]
+            : networkRuleSetDeserializer(item["networkRuleSet"]),
+        dataExfiltrationProtections: !item["dataExfiltrationProtections"]
+            ? item["dataExfiltrationProtections"]
+            : item["dataExfiltrationProtections"].map((p) => {
+                return p;
+            }),
+        encryptionWithCmk: !item["encryptionWithCmk"]
+            ? item["encryptionWithCmk"]
+            : encryptionWithCmkDeserializer(item["encryptionWithCmk"]),
+        disableLocalAuth: item["disableLocalAuth"],
+        authOptions: !item["authOptions"]
+            ? item["authOptions"]
+            : dataPlaneAuthOptionsDeserializer(item["authOptions"]),
+        semanticSearch: item["semanticSearch"],
+        knowledgeRetrieval: item["knowledgeRetrieval"],
+        privateEndpointConnections: !item["privateEndpointConnections"]
+            ? item["privateEndpointConnections"]
+            : privateEndpointConnectionArrayDeserializer(item["privateEndpointConnections"]),
+        sharedPrivateLinkResources: !item["sharedPrivateLinkResources"]
+            ? item["sharedPrivateLinkResources"]
+            : sharedPrivateLinkResourceArrayDeserializer(item["sharedPrivateLinkResources"]),
+        eTag: item["eTag"],
+        upgradeAvailable: item["upgradeAvailable"],
+        serviceUpgradedAt: !item["serviceUpgradedAt"]
+            ? item["serviceUpgradedAt"]
+            : new Date(item["serviceUpgradedAt"]),
+    };
+}
+//# sourceMappingURL=models.js.map