@azure/arm-dnsresolver 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/commonjs/models/models.js

@@ -0,0 +1,1307 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var models_exports = {};
+__export(models_exports, {
+  KnownAction: () => KnownAction,
+  KnownActionType: () => KnownActionType,
+  KnownCreatedByType: () => KnownCreatedByType,
+  KnownDnsResolverState: () => KnownDnsResolverState,
+  KnownDnsSecurityRuleState: () => KnownDnsSecurityRuleState,
+  KnownForwardingRuleState: () => KnownForwardingRuleState,
+  KnownIpAllocationMethod: () => KnownIpAllocationMethod,
+  KnownManagedDomainList: () => KnownManagedDomainList,
+  KnownProvisioningState: () => KnownProvisioningState,
+  KnownVersions: () => KnownVersions,
+  _dnsForwardingRulesetListResultDeserializer: () => _dnsForwardingRulesetListResultDeserializer,
+  _dnsForwardingRulesetPropertiesDeserializer: () => _dnsForwardingRulesetPropertiesDeserializer,
+  _dnsForwardingRulesetPropertiesSerializer: () => _dnsForwardingRulesetPropertiesSerializer,
+  _dnsResolverDomainListBulkPropertiesSerializer: () => _dnsResolverDomainListBulkPropertiesSerializer,
+  _dnsResolverDomainListListResultDeserializer: () => _dnsResolverDomainListListResultDeserializer,
+  _dnsResolverDomainListPatchPropertiesSerializer: () => _dnsResolverDomainListPatchPropertiesSerializer,
+  _dnsResolverDomainListPropertiesDeserializer: () => _dnsResolverDomainListPropertiesDeserializer,
+  _dnsResolverDomainListPropertiesSerializer: () => _dnsResolverDomainListPropertiesSerializer,
+  _dnsResolverListResultDeserializer: () => _dnsResolverListResultDeserializer,
+  _dnsResolverPolicyListResultDeserializer: () => _dnsResolverPolicyListResultDeserializer,
+  _dnsResolverPolicyPropertiesDeserializer: () => _dnsResolverPolicyPropertiesDeserializer,
+  _dnsResolverPolicyPropertiesSerializer: () => _dnsResolverPolicyPropertiesSerializer,
+  _dnsResolverPolicyVirtualNetworkLinkListResultDeserializer: () => _dnsResolverPolicyVirtualNetworkLinkListResultDeserializer,
+  _dnsResolverPolicyVirtualNetworkLinkPropertiesDeserializer: () => _dnsResolverPolicyVirtualNetworkLinkPropertiesDeserializer,
+  _dnsResolverPolicyVirtualNetworkLinkPropertiesSerializer: () => _dnsResolverPolicyVirtualNetworkLinkPropertiesSerializer,
+  _dnsResolverPropertiesDeserializer: () => _dnsResolverPropertiesDeserializer,
+  _dnsResolverPropertiesSerializer: () => _dnsResolverPropertiesSerializer,
+  _dnsSecurityRuleListResultDeserializer: () => _dnsSecurityRuleListResultDeserializer,
+  _dnsSecurityRulePatchPropertiesSerializer: () => _dnsSecurityRulePatchPropertiesSerializer,
+  _dnsSecurityRulePropertiesDeserializer: () => _dnsSecurityRulePropertiesDeserializer,
+  _dnsSecurityRulePropertiesSerializer: () => _dnsSecurityRulePropertiesSerializer,
+  _forwardingRuleListResultDeserializer: () => _forwardingRuleListResultDeserializer,
+  _forwardingRulePatchPropertiesSerializer: () => _forwardingRulePatchPropertiesSerializer,
+  _forwardingRulePropertiesDeserializer: () => _forwardingRulePropertiesDeserializer,
+  _forwardingRulePropertiesSerializer: () => _forwardingRulePropertiesSerializer,
+  _inboundEndpointListResultDeserializer: () => _inboundEndpointListResultDeserializer,
+  _inboundEndpointPropertiesDeserializer: () => _inboundEndpointPropertiesDeserializer,
+  _inboundEndpointPropertiesSerializer: () => _inboundEndpointPropertiesSerializer,
+  _outboundEndpointListResultDeserializer: () => _outboundEndpointListResultDeserializer,
+  _outboundEndpointPropertiesDeserializer: () => _outboundEndpointPropertiesDeserializer,
+  _outboundEndpointPropertiesSerializer: () => _outboundEndpointPropertiesSerializer,
+  _subResourceListResultDeserializer: () => _subResourceListResultDeserializer,
+  _virtualNetworkDnsForwardingRulesetListResultDeserializer: () => _virtualNetworkDnsForwardingRulesetListResultDeserializer,
+  _virtualNetworkDnsForwardingRulesetPropertiesDeserializer: () => _virtualNetworkDnsForwardingRulesetPropertiesDeserializer,
+  _virtualNetworkLinkListResultDeserializer: () => _virtualNetworkLinkListResultDeserializer,
+  _virtualNetworkLinkPatchPropertiesSerializer: () => _virtualNetworkLinkPatchPropertiesSerializer,
+  _virtualNetworkLinkPropertiesDeserializer: () => _virtualNetworkLinkPropertiesDeserializer,
+  _virtualNetworkLinkPropertiesSerializer: () => _virtualNetworkLinkPropertiesSerializer,
+  cloudErrorBodyArrayDeserializer: () => cloudErrorBodyArrayDeserializer,
+  cloudErrorBodyDeserializer: () => cloudErrorBodyDeserializer,
+  cloudErrorDeserializer: () => cloudErrorDeserializer,
+  dnsForwardingRulesetArrayDeserializer: () => dnsForwardingRulesetArrayDeserializer,
+  dnsForwardingRulesetArraySerializer: () => dnsForwardingRulesetArraySerializer,
+  dnsForwardingRulesetDeserializer: () => dnsForwardingRulesetDeserializer,
+  dnsForwardingRulesetPatchSerializer: () => dnsForwardingRulesetPatchSerializer,
+  dnsForwardingRulesetPropertiesDeserializer: () => dnsForwardingRulesetPropertiesDeserializer,
+  dnsForwardingRulesetPropertiesSerializer: () => dnsForwardingRulesetPropertiesSerializer,
+  dnsForwardingRulesetSerializer: () => dnsForwardingRulesetSerializer,
+  dnsResolverArrayDeserializer: () => dnsResolverArrayDeserializer,
+  dnsResolverArraySerializer: () => dnsResolverArraySerializer,
+  dnsResolverDeserializer: () => dnsResolverDeserializer,
+  dnsResolverDomainListArrayDeserializer: () => dnsResolverDomainListArrayDeserializer,
+  dnsResolverDomainListArraySerializer: () => dnsResolverDomainListArraySerializer,
+  dnsResolverDomainListBulkPropertiesSerializer: () => dnsResolverDomainListBulkPropertiesSerializer,
+  dnsResolverDomainListBulkSerializer: () => dnsResolverDomainListBulkSerializer,
+  dnsResolverDomainListDeserializer: () => dnsResolverDomainListDeserializer,
+  dnsResolverDomainListPatchPropertiesSerializer: () => dnsResolverDomainListPatchPropertiesSerializer,
+  dnsResolverDomainListPatchSerializer: () => dnsResolverDomainListPatchSerializer,
+  dnsResolverDomainListPropertiesDeserializer: () => dnsResolverDomainListPropertiesDeserializer,
+  dnsResolverDomainListPropertiesSerializer: () => dnsResolverDomainListPropertiesSerializer,
+  dnsResolverDomainListSerializer: () => dnsResolverDomainListSerializer,
+  dnsResolverPatchSerializer: () => dnsResolverPatchSerializer,
+  dnsResolverPolicyArrayDeserializer: () => dnsResolverPolicyArrayDeserializer,
+  dnsResolverPolicyArraySerializer: () => dnsResolverPolicyArraySerializer,
+  dnsResolverPolicyDeserializer: () => dnsResolverPolicyDeserializer,
+  dnsResolverPolicyPatchSerializer: () => dnsResolverPolicyPatchSerializer,
+  dnsResolverPolicyPropertiesDeserializer: () => dnsResolverPolicyPropertiesDeserializer,
+  dnsResolverPolicyPropertiesSerializer: () => dnsResolverPolicyPropertiesSerializer,
+  dnsResolverPolicySerializer: () => dnsResolverPolicySerializer,
+  dnsResolverPolicyVirtualNetworkLinkArrayDeserializer: () => dnsResolverPolicyVirtualNetworkLinkArrayDeserializer,
+  dnsResolverPolicyVirtualNetworkLinkArraySerializer: () => dnsResolverPolicyVirtualNetworkLinkArraySerializer,
+  dnsResolverPolicyVirtualNetworkLinkDeserializer: () => dnsResolverPolicyVirtualNetworkLinkDeserializer,
+  dnsResolverPolicyVirtualNetworkLinkPatchSerializer: () => dnsResolverPolicyVirtualNetworkLinkPatchSerializer,
+  dnsResolverPolicyVirtualNetworkLinkPropertiesDeserializer: () => dnsResolverPolicyVirtualNetworkLinkPropertiesDeserializer,
+  dnsResolverPolicyVirtualNetworkLinkPropertiesSerializer: () => dnsResolverPolicyVirtualNetworkLinkPropertiesSerializer,
+  dnsResolverPolicyVirtualNetworkLinkSerializer: () => dnsResolverPolicyVirtualNetworkLinkSerializer,
+  dnsResolverPropertiesDeserializer: () => dnsResolverPropertiesDeserializer,
+  dnsResolverPropertiesSerializer: () => dnsResolverPropertiesSerializer,
+  dnsResolverSerializer: () => dnsResolverSerializer,
+  dnsSecurityRuleActionDeserializer: () => dnsSecurityRuleActionDeserializer,
+  dnsSecurityRuleActionSerializer: () => dnsSecurityRuleActionSerializer,
+  dnsSecurityRuleArrayDeserializer: () => dnsSecurityRuleArrayDeserializer,
+  dnsSecurityRuleArraySerializer: () => dnsSecurityRuleArraySerializer,
+  dnsSecurityRuleDeserializer: () => dnsSecurityRuleDeserializer,
+  dnsSecurityRulePatchPropertiesSerializer: () => dnsSecurityRulePatchPropertiesSerializer,
+  dnsSecurityRulePatchSerializer: () => dnsSecurityRulePatchSerializer,
+  dnsSecurityRulePropertiesDeserializer: () => dnsSecurityRulePropertiesDeserializer,
+  dnsSecurityRulePropertiesSerializer: () => dnsSecurityRulePropertiesSerializer,
+  dnsSecurityRuleSerializer: () => dnsSecurityRuleSerializer,
+  errorAdditionalInfoArrayDeserializer: () => errorAdditionalInfoArrayDeserializer,
+  errorAdditionalInfoDeserializer: () => errorAdditionalInfoDeserializer,
+  errorDetailArrayDeserializer: () => errorDetailArrayDeserializer,
+  errorDetailDeserializer: () => errorDetailDeserializer,
+  errorResponseDeserializer: () => errorResponseDeserializer,
+  forwardingRuleArrayDeserializer: () => forwardingRuleArrayDeserializer,
+  forwardingRuleArraySerializer: () => forwardingRuleArraySerializer,
+  forwardingRuleDeserializer: () => forwardingRuleDeserializer,
+  forwardingRulePatchPropertiesSerializer: () => forwardingRulePatchPropertiesSerializer,
+  forwardingRulePatchSerializer: () => forwardingRulePatchSerializer,
+  forwardingRulePropertiesDeserializer: () => forwardingRulePropertiesDeserializer,
+  forwardingRulePropertiesSerializer: () => forwardingRulePropertiesSerializer,
+  forwardingRuleSerializer: () => forwardingRuleSerializer,
+  inboundEndpointArrayDeserializer: () => inboundEndpointArrayDeserializer,
+  inboundEndpointArraySerializer: () => inboundEndpointArraySerializer,
+  inboundEndpointDeserializer: () => inboundEndpointDeserializer,
+  inboundEndpointPatchSerializer: () => inboundEndpointPatchSerializer,
+  inboundEndpointPropertiesDeserializer: () => inboundEndpointPropertiesDeserializer,
+  inboundEndpointPropertiesSerializer: () => inboundEndpointPropertiesSerializer,
+  inboundEndpointSerializer: () => inboundEndpointSerializer,
+  ipConfigurationArrayDeserializer: () => ipConfigurationArrayDeserializer,
+  ipConfigurationArraySerializer: () => ipConfigurationArraySerializer,
+  ipConfigurationDeserializer: () => ipConfigurationDeserializer,
+  ipConfigurationSerializer: () => ipConfigurationSerializer,
+  outboundEndpointArrayDeserializer: () => outboundEndpointArrayDeserializer,
+  outboundEndpointArraySerializer: () => outboundEndpointArraySerializer,
+  outboundEndpointDeserializer: () => outboundEndpointDeserializer,
+  outboundEndpointPatchSerializer: () => outboundEndpointPatchSerializer,
+  outboundEndpointPropertiesDeserializer: () => outboundEndpointPropertiesDeserializer,
+  outboundEndpointPropertiesSerializer: () => outboundEndpointPropertiesSerializer,
+  outboundEndpointSerializer: () => outboundEndpointSerializer,
+  proxyResourceDeserializer: () => proxyResourceDeserializer,
+  proxyResourceSerializer: () => proxyResourceSerializer,
+  resourceDeserializer: () => resourceDeserializer,
+  resourceSerializer: () => resourceSerializer,
+  subResourceArrayDeserializer: () => subResourceArrayDeserializer,
+  subResourceArraySerializer: () => subResourceArraySerializer,
+  subResourceDeserializer: () => subResourceDeserializer,
+  subResourceSerializer: () => subResourceSerializer,
+  systemDataDeserializer: () => systemDataDeserializer,
+  targetDnsServerArrayDeserializer: () => targetDnsServerArrayDeserializer,
+  targetDnsServerArraySerializer: () => targetDnsServerArraySerializer,
+  targetDnsServerDeserializer: () => targetDnsServerDeserializer,
+  targetDnsServerSerializer: () => targetDnsServerSerializer,
+  trackedResourceDeserializer: () => trackedResourceDeserializer,
+  trackedResourceSerializer: () => trackedResourceSerializer,
+  virtualNetworkDnsForwardingRulesetArrayDeserializer: () => virtualNetworkDnsForwardingRulesetArrayDeserializer,
+  virtualNetworkDnsForwardingRulesetDeserializer: () => virtualNetworkDnsForwardingRulesetDeserializer,
+  virtualNetworkLinkArrayDeserializer: () => virtualNetworkLinkArrayDeserializer,
+  virtualNetworkLinkArraySerializer: () => virtualNetworkLinkArraySerializer,
+  virtualNetworkLinkDeserializer: () => virtualNetworkLinkDeserializer,
+  virtualNetworkLinkPatchPropertiesSerializer: () => virtualNetworkLinkPatchPropertiesSerializer,
+  virtualNetworkLinkPatchSerializer: () => virtualNetworkLinkPatchSerializer,
+  virtualNetworkLinkPropertiesDeserializer: () => virtualNetworkLinkPropertiesDeserializer,
+  virtualNetworkLinkPropertiesSerializer: () => virtualNetworkLinkPropertiesSerializer,
+  virtualNetworkLinkSerializer: () => virtualNetworkLinkSerializer,
+  virtualNetworkLinkSubResourcePropertiesDeserializer: () => virtualNetworkLinkSubResourcePropertiesDeserializer
+});
+module.exports = __toCommonJS(models_exports);
+var import_check_prop_undefined = require("../static-helpers/serialization/check-prop-undefined.js");
+function dnsResolverSerializer(item) {
+  return {
+    tags: item["tags"],
+    location: item["location"],
+    properties: _dnsResolverPropertiesSerializer(item)
+  };
+}
+function dnsResolverDeserializer(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"]),
+    ..._dnsResolverPropertiesDeserializer(item["properties"]),
+    etag: item["etag"]
+  };
+}
+function dnsResolverPropertiesSerializer(item) {
+  return { virtualNetwork: subResourceSerializer(item["virtualNetwork"]) };
+}
+function dnsResolverPropertiesDeserializer(item) {
+  return {
+    virtualNetwork: subResourceDeserializer(item["virtualNetwork"]),
+    dnsResolverState: item["dnsResolverState"],
+    provisioningState: item["provisioningState"],
+    resourceGuid: item["resourceGuid"]
+  };
+}
+function subResourceSerializer(item) {
+  return { id: item["id"] };
+}
+function subResourceDeserializer(item) {
+  return {
+    id: item["id"]
+  };
+}
+var KnownDnsResolverState = /* @__PURE__ */ ((KnownDnsResolverState2) => {
+  KnownDnsResolverState2["Connected"] = "Connected";
+  KnownDnsResolverState2["Disconnected"] = "Disconnected";
+  return KnownDnsResolverState2;
+})(KnownDnsResolverState || {});
+var KnownProvisioningState = /* @__PURE__ */ ((KnownProvisioningState2) => {
+  KnownProvisioningState2["Creating"] = "Creating";
+  KnownProvisioningState2["Updating"] = "Updating";
+  KnownProvisioningState2["Deleting"] = "Deleting";
+  KnownProvisioningState2["Succeeded"] = "Succeeded";
+  KnownProvisioningState2["Failed"] = "Failed";
+  KnownProvisioningState2["Canceled"] = "Canceled";
+  return KnownProvisioningState2;
+})(KnownProvisioningState || {});
+function trackedResourceSerializer(item) {
+  return { tags: item["tags"], location: item["location"] };
+}
+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"]
+  };
+}
+function resourceSerializer(_item) {
+  return {};
+}
+function resourceDeserializer(item) {
+  return {
+    id: item["id"],
+    name: item["name"],
+    type: item["type"],
+    systemData: !item["systemData"] ? item["systemData"] : systemDataDeserializer(item["systemData"])
+  };
+}
+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"])
+  };
+}
+var KnownCreatedByType = /* @__PURE__ */ ((KnownCreatedByType2) => {
+  KnownCreatedByType2["User"] = "User";
+  KnownCreatedByType2["Application"] = "Application";
+  KnownCreatedByType2["ManagedIdentity"] = "ManagedIdentity";
+  KnownCreatedByType2["Key"] = "Key";
+  return KnownCreatedByType2;
+})(KnownCreatedByType || {});
+function cloudErrorDeserializer(item) {
+  return {
+    error: !item["error"] ? item["error"] : cloudErrorBodyDeserializer(item["error"])
+  };
+}
+function cloudErrorBodyDeserializer(item) {
+  return {
+    code: item["code"],
+    message: item["message"],
+    target: item["target"],
+    details: !item["details"] ? item["details"] : cloudErrorBodyArrayDeserializer(item["details"])
+  };
+}
+function cloudErrorBodyArrayDeserializer(result) {
+  return result.map((item) => {
+    return cloudErrorBodyDeserializer(item);
+  });
+}
+function errorDetailDeserializer(item) {
+  return {
+    code: item["code"],
+    message: item["message"],
+    target: item["target"],
+    details: !item["details"] ? item["details"] : errorDetailArrayDeserializer(item["details"]),
+    additionalInfo: !item["additionalInfo"] ? item["additionalInfo"] : errorAdditionalInfoArrayDeserializer(item["additionalInfo"])
+  };
+}
+function errorDetailArrayDeserializer(result) {
+  return result.map((item) => {
+    return errorDetailDeserializer(item);
+  });
+}
+function errorAdditionalInfoArrayDeserializer(result) {
+  return result.map((item) => {
+    return errorAdditionalInfoDeserializer(item);
+  });
+}
+function errorAdditionalInfoDeserializer(item) {
+  return {
+    type: item["type"],
+    info: item["info"]
+  };
+}
+function dnsResolverPatchSerializer(item) {
+  return { tags: item["tags"] };
+}
+function _dnsResolverListResultDeserializer(item) {
+  return {
+    value: dnsResolverArrayDeserializer(item["value"]),
+    nextLink: item["nextLink"]
+  };
+}
+function dnsResolverArraySerializer(result) {
+  return result.map((item) => {
+    return dnsResolverSerializer(item);
+  });
+}
+function dnsResolverArrayDeserializer(result) {
+  return result.map((item) => {
+    return dnsResolverDeserializer(item);
+  });
+}
+function _subResourceListResultDeserializer(item) {
+  return {
+    value: subResourceArrayDeserializer(item["value"]),
+    nextLink: item["nextLink"]
+  };
+}
+function subResourceArraySerializer(result) {
+  return result.map((item) => {
+    return subResourceSerializer(item);
+  });
+}
+function subResourceArrayDeserializer(result) {
+  return result.map((item) => {
+    return subResourceDeserializer(item);
+  });
+}
+function inboundEndpointSerializer(item) {
+  return {
+    tags: item["tags"],
+    location: item["location"],
+    properties: _inboundEndpointPropertiesSerializer(item)
+  };
+}
+function inboundEndpointDeserializer(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"]),
+    ..._inboundEndpointPropertiesDeserializer(item["properties"]),
+    etag: item["etag"]
+  };
+}
+function inboundEndpointPropertiesSerializer(item) {
+  return { ipConfigurations: ipConfigurationArraySerializer(item["ipConfigurations"]) };
+}
+function inboundEndpointPropertiesDeserializer(item) {
+  return {
+    ipConfigurations: ipConfigurationArrayDeserializer(item["ipConfigurations"]),
+    provisioningState: item["provisioningState"],
+    resourceGuid: item["resourceGuid"]
+  };
+}
+function ipConfigurationArraySerializer(result) {
+  return result.map((item) => {
+    return ipConfigurationSerializer(item);
+  });
+}
+function ipConfigurationArrayDeserializer(result) {
+  return result.map((item) => {
+    return ipConfigurationDeserializer(item);
+  });
+}
+function ipConfigurationSerializer(item) {
+  return {
+    subnet: subResourceSerializer(item["subnet"]),
+    privateIpAddress: item["privateIpAddress"],
+    privateIpAllocationMethod: item["privateIpAllocationMethod"]
+  };
+}
+function ipConfigurationDeserializer(item) {
+  return {
+    subnet: subResourceDeserializer(item["subnet"]),
+    privateIpAddress: item["privateIpAddress"],
+    privateIpAllocationMethod: item["privateIpAllocationMethod"]
+  };
+}
+var KnownIpAllocationMethod = /* @__PURE__ */ ((KnownIpAllocationMethod2) => {
+  KnownIpAllocationMethod2["Static"] = "Static";
+  KnownIpAllocationMethod2["Dynamic"] = "Dynamic";
+  return KnownIpAllocationMethod2;
+})(KnownIpAllocationMethod || {});
+function inboundEndpointPatchSerializer(item) {
+  return { tags: item["tags"] };
+}
+function _inboundEndpointListResultDeserializer(item) {
+  return {
+    value: inboundEndpointArrayDeserializer(item["value"]),
+    nextLink: item["nextLink"]
+  };
+}
+function inboundEndpointArraySerializer(result) {
+  return result.map((item) => {
+    return inboundEndpointSerializer(item);
+  });
+}
+function inboundEndpointArrayDeserializer(result) {
+  return result.map((item) => {
+    return inboundEndpointDeserializer(item);
+  });
+}
+function outboundEndpointSerializer(item) {
+  return {
+    tags: item["tags"],
+    location: item["location"],
+    properties: _outboundEndpointPropertiesSerializer(item)
+  };
+}
+function outboundEndpointDeserializer(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"]),
+    ..._outboundEndpointPropertiesDeserializer(item["properties"]),
+    etag: item["etag"]
+  };
+}
+function outboundEndpointPropertiesSerializer(item) {
+  return { subnet: subResourceSerializer(item["subnet"]) };
+}
+function outboundEndpointPropertiesDeserializer(item) {
+  return {
+    subnet: subResourceDeserializer(item["subnet"]),
+    provisioningState: item["provisioningState"],
+    resourceGuid: item["resourceGuid"]
+  };
+}
+function outboundEndpointPatchSerializer(item) {
+  return { tags: item["tags"] };
+}
+function _outboundEndpointListResultDeserializer(item) {
+  return {
+    value: outboundEndpointArrayDeserializer(item["value"]),
+    nextLink: item["nextLink"]
+  };
+}
+function outboundEndpointArraySerializer(result) {
+  return result.map((item) => {
+    return outboundEndpointSerializer(item);
+  });
+}
+function outboundEndpointArrayDeserializer(result) {
+  return result.map((item) => {
+    return outboundEndpointDeserializer(item);
+  });
+}
+function dnsForwardingRulesetSerializer(item) {
+  return {
+    tags: item["tags"],
+    location: item["location"],
+    properties: _dnsForwardingRulesetPropertiesSerializer(item)
+  };
+}
+function dnsForwardingRulesetDeserializer(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"]),
+    ..._dnsForwardingRulesetPropertiesDeserializer(item["properties"]),
+    etag: item["etag"]
+  };
+}
+function dnsForwardingRulesetPropertiesSerializer(item) {
+  return {
+    dnsResolverOutboundEndpoints: subResourceArraySerializer(item["dnsResolverOutboundEndpoints"])
+  };
+}
+function dnsForwardingRulesetPropertiesDeserializer(item) {
+  return {
+    dnsResolverOutboundEndpoints: subResourceArrayDeserializer(
+      item["dnsResolverOutboundEndpoints"]
+    ),
+    provisioningState: item["provisioningState"],
+    resourceGuid: item["resourceGuid"]
+  };
+}
+function dnsForwardingRulesetPatchSerializer(item) {
+  return {
+    dnsResolverOutboundEndpoints: !item["dnsResolverOutboundEndpoints"] ? item["dnsResolverOutboundEndpoints"] : subResourceArraySerializer(item["dnsResolverOutboundEndpoints"]),
+    tags: item["tags"]
+  };
+}
+function _dnsForwardingRulesetListResultDeserializer(item) {
+  return {
+    value: dnsForwardingRulesetArrayDeserializer(item["value"]),
+    nextLink: item["nextLink"]
+  };
+}
+function dnsForwardingRulesetArraySerializer(result) {
+  return result.map((item) => {
+    return dnsForwardingRulesetSerializer(item);
+  });
+}
+function dnsForwardingRulesetArrayDeserializer(result) {
+  return result.map((item) => {
+    return dnsForwardingRulesetDeserializer(item);
+  });
+}
+function _virtualNetworkDnsForwardingRulesetListResultDeserializer(item) {
+  return {
+    value: virtualNetworkDnsForwardingRulesetArrayDeserializer(item["value"]),
+    nextLink: item["nextLink"]
+  };
+}
+function virtualNetworkDnsForwardingRulesetArrayDeserializer(result) {
+  return result.map((item) => {
+    return virtualNetworkDnsForwardingRulesetDeserializer(item);
+  });
+}
+function virtualNetworkDnsForwardingRulesetDeserializer(item) {
+  return {
+    id: item["id"],
+    ...!item["properties"] ? item["properties"] : _virtualNetworkDnsForwardingRulesetPropertiesDeserializer(item["properties"])
+  };
+}
+function virtualNetworkLinkSubResourcePropertiesDeserializer(item) {
+  return {
+    virtualNetworkLink: !item["virtualNetworkLink"] ? item["virtualNetworkLink"] : subResourceDeserializer(item["virtualNetworkLink"])
+  };
+}
+function forwardingRuleSerializer(item) {
+  return { properties: _forwardingRulePropertiesSerializer(item) };
+}
+function forwardingRuleDeserializer(item) {
+  return {
+    id: item["id"],
+    name: item["name"],
+    type: item["type"],
+    systemData: !item["systemData"] ? item["systemData"] : systemDataDeserializer(item["systemData"]),
+    ..._forwardingRulePropertiesDeserializer(item["properties"]),
+    etag: item["etag"]
+  };
+}
+function forwardingRulePropertiesSerializer(item) {
+  return {
+    domainName: item["domainName"],
+    targetDnsServers: targetDnsServerArraySerializer(item["targetDnsServers"]),
+    metadata: item["metadata"],
+    forwardingRuleState: item["forwardingRuleState"]
+  };
+}
+function forwardingRulePropertiesDeserializer(item) {
+  return {
+    domainName: item["domainName"],
+    targetDnsServers: targetDnsServerArrayDeserializer(item["targetDnsServers"]),
+    metadata: !item["metadata"] ? item["metadata"] : Object.fromEntries(Object.entries(item["metadata"]).map(([k, p]) => [k, p])),
+    forwardingRuleState: item["forwardingRuleState"],
+    provisioningState: item["provisioningState"]
+  };
+}
+function targetDnsServerArraySerializer(result) {
+  return result.map((item) => {
+    return targetDnsServerSerializer(item);
+  });
+}
+function targetDnsServerArrayDeserializer(result) {
+  return result.map((item) => {
+    return targetDnsServerDeserializer(item);
+  });
+}
+function targetDnsServerSerializer(item) {
+  return { ipAddress: item["ipAddress"], port: item["port"] };
+}
+function targetDnsServerDeserializer(item) {
+  return {
+    ipAddress: item["ipAddress"],
+    port: item["port"]
+  };
+}
+var KnownForwardingRuleState = /* @__PURE__ */ ((KnownForwardingRuleState2) => {
+  KnownForwardingRuleState2["Enabled"] = "Enabled";
+  KnownForwardingRuleState2["Disabled"] = "Disabled";
+  return KnownForwardingRuleState2;
+})(KnownForwardingRuleState || {});
+function proxyResourceSerializer(_item) {
+  return {};
+}
+function proxyResourceDeserializer(item) {
+  return {
+    id: item["id"],
+    name: item["name"],
+    type: item["type"],
+    systemData: !item["systemData"] ? item["systemData"] : systemDataDeserializer(item["systemData"])
+  };
+}
+function forwardingRulePatchSerializer(item) {
+  return {
+    properties: (0, import_check_prop_undefined.areAllPropsUndefined)(item, ["targetDnsServers", "metadata", "forwardingRuleState"]) ? void 0 : _forwardingRulePatchPropertiesSerializer(item)
+  };
+}
+function forwardingRulePatchPropertiesSerializer(item) {
+  return {
+    targetDnsServers: !item["targetDnsServers"] ? item["targetDnsServers"] : targetDnsServerArraySerializer(item["targetDnsServers"]),
+    metadata: item["metadata"],
+    forwardingRuleState: item["forwardingRuleState"]
+  };
+}
+function _forwardingRuleListResultDeserializer(item) {
+  return {
+    value: forwardingRuleArrayDeserializer(item["value"]),
+    nextLink: item["nextLink"]
+  };
+}
+function forwardingRuleArraySerializer(result) {
+  return result.map((item) => {
+    return forwardingRuleSerializer(item);
+  });
+}
+function forwardingRuleArrayDeserializer(result) {
+  return result.map((item) => {
+    return forwardingRuleDeserializer(item);
+  });
+}
+function virtualNetworkLinkSerializer(item) {
+  return { properties: _virtualNetworkLinkPropertiesSerializer(item) };
+}
+function virtualNetworkLinkDeserializer(item) {
+  return {
+    id: item["id"],
+    name: item["name"],
+    type: item["type"],
+    systemData: !item["systemData"] ? item["systemData"] : systemDataDeserializer(item["systemData"]),
+    ..._virtualNetworkLinkPropertiesDeserializer(item["properties"]),
+    etag: item["etag"]
+  };
+}
+function virtualNetworkLinkPropertiesSerializer(item) {
+  return {
+    virtualNetwork: subResourceSerializer(item["virtualNetwork"]),
+    metadata: item["metadata"]
+  };
+}
+function virtualNetworkLinkPropertiesDeserializer(item) {
+  return {
+    virtualNetwork: subResourceDeserializer(item["virtualNetwork"]),
+    metadata: !item["metadata"] ? item["metadata"] : Object.fromEntries(Object.entries(item["metadata"]).map(([k, p]) => [k, p])),
+    provisioningState: item["provisioningState"]
+  };
+}
+function virtualNetworkLinkPatchSerializer(item) {
+  return {
+    properties: (0, import_check_prop_undefined.areAllPropsUndefined)(item, ["metadata"]) ? void 0 : _virtualNetworkLinkPatchPropertiesSerializer(item)
+  };
+}
+function virtualNetworkLinkPatchPropertiesSerializer(item) {
+  return { metadata: item["metadata"] };
+}
+function _virtualNetworkLinkListResultDeserializer(item) {
+  return {
+    value: virtualNetworkLinkArrayDeserializer(item["value"]),
+    nextLink: item["nextLink"]
+  };
+}
+function virtualNetworkLinkArraySerializer(result) {
+  return result.map((item) => {
+    return virtualNetworkLinkSerializer(item);
+  });
+}
+function virtualNetworkLinkArrayDeserializer(result) {
+  return result.map((item) => {
+    return virtualNetworkLinkDeserializer(item);
+  });
+}
+function dnsResolverPolicySerializer(item) {
+  return {
+    tags: item["tags"],
+    location: item["location"],
+    properties: (0, import_check_prop_undefined.areAllPropsUndefined)(item, []) ? void 0 : _dnsResolverPolicyPropertiesSerializer(item)
+  };
+}
+function dnsResolverPolicyDeserializer(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"] : _dnsResolverPolicyPropertiesDeserializer(item["properties"]),
+    etag: item["etag"]
+  };
+}
+function dnsResolverPolicyPropertiesSerializer(_item) {
+  return {};
+}
+function dnsResolverPolicyPropertiesDeserializer(item) {
+  return {
+    provisioningState: item["provisioningState"],
+    resourceGuid: item["resourceGuid"]
+  };
+}
+function errorResponseDeserializer(item) {
+  return {
+    error: !item["error"] ? item["error"] : errorDetailDeserializer(item["error"])
+  };
+}
+function dnsResolverPolicyPatchSerializer(item) {
+  return { tags: item["tags"] };
+}
+function _dnsResolverPolicyListResultDeserializer(item) {
+  return {
+    value: dnsResolverPolicyArrayDeserializer(item["value"]),
+    nextLink: item["nextLink"]
+  };
+}
+function dnsResolverPolicyArraySerializer(result) {
+  return result.map((item) => {
+    return dnsResolverPolicySerializer(item);
+  });
+}
+function dnsResolverPolicyArrayDeserializer(result) {
+  return result.map((item) => {
+    return dnsResolverPolicyDeserializer(item);
+  });
+}
+function dnsSecurityRuleSerializer(item) {
+  return {
+    tags: item["tags"],
+    location: item["location"],
+    properties: _dnsSecurityRulePropertiesSerializer(item)
+  };
+}
+function dnsSecurityRuleDeserializer(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"]),
+    ..._dnsSecurityRulePropertiesDeserializer(item["properties"]),
+    etag: item["etag"]
+  };
+}
+function dnsSecurityRulePropertiesSerializer(item) {
+  return {
+    priority: item["priority"],
+    action: dnsSecurityRuleActionSerializer(item["action"]),
+    dnsResolverDomainLists: !item["dnsResolverDomainLists"] ? item["dnsResolverDomainLists"] : subResourceArraySerializer(item["dnsResolverDomainLists"]),
+    managedDomainLists: !item["managedDomainLists"] ? item["managedDomainLists"] : item["managedDomainLists"].map((p) => {
+      return p;
+    }),
+    dnsSecurityRuleState: item["dnsSecurityRuleState"]
+  };
+}
+function dnsSecurityRulePropertiesDeserializer(item) {
+  return {
+    priority: item["priority"],
+    action: dnsSecurityRuleActionDeserializer(item["action"]),
+    dnsResolverDomainLists: !item["dnsResolverDomainLists"] ? item["dnsResolverDomainLists"] : subResourceArrayDeserializer(item["dnsResolverDomainLists"]),
+    managedDomainLists: !item["managedDomainLists"] ? item["managedDomainLists"] : item["managedDomainLists"].map((p) => {
+      return p;
+    }),
+    dnsSecurityRuleState: item["dnsSecurityRuleState"],
+    provisioningState: item["provisioningState"]
+  };
+}
+function dnsSecurityRuleActionSerializer(item) {
+  return { actionType: item["actionType"] };
+}
+function dnsSecurityRuleActionDeserializer(item) {
+  return {
+    actionType: item["actionType"]
+  };
+}
+var KnownActionType = /* @__PURE__ */ ((KnownActionType2) => {
+  KnownActionType2["Allow"] = "Allow";
+  KnownActionType2["Alert"] = "Alert";
+  KnownActionType2["Block"] = "Block";
+  return KnownActionType2;
+})(KnownActionType || {});
+var KnownManagedDomainList = /* @__PURE__ */ ((KnownManagedDomainList2) => {
+  KnownManagedDomainList2["AzureDnsThreatIntel"] = "AzureDnsThreatIntel";
+  return KnownManagedDomainList2;
+})(KnownManagedDomainList || {});
+var KnownDnsSecurityRuleState = /* @__PURE__ */ ((KnownDnsSecurityRuleState2) => {
+  KnownDnsSecurityRuleState2["Enabled"] = "Enabled";
+  KnownDnsSecurityRuleState2["Disabled"] = "Disabled";
+  return KnownDnsSecurityRuleState2;
+})(KnownDnsSecurityRuleState || {});
+function dnsSecurityRulePatchSerializer(item) {
+  return {
+    properties: (0, import_check_prop_undefined.areAllPropsUndefined)(item, [
+      "action",
+      "dnsResolverDomainLists",
+      "managedDomainLists",
+      "dnsSecurityRuleState",
+      "priority"
+    ]) ? void 0 : _dnsSecurityRulePatchPropertiesSerializer(item),
+    tags: item["tags"]
+  };
+}
+function dnsSecurityRulePatchPropertiesSerializer(item) {
+  return {
+    action: !item["action"] ? item["action"] : dnsSecurityRuleActionSerializer(item["action"]),
+    dnsResolverDomainLists: !item["dnsResolverDomainLists"] ? item["dnsResolverDomainLists"] : subResourceArraySerializer(item["dnsResolverDomainLists"]),
+    managedDomainLists: !item["managedDomainLists"] ? item["managedDomainLists"] : item["managedDomainLists"].map((p) => {
+      return p;
+    }),
+    dnsSecurityRuleState: item["dnsSecurityRuleState"],
+    priority: item["priority"]
+  };
+}
+function _dnsSecurityRuleListResultDeserializer(item) {
+  return {
+    value: dnsSecurityRuleArrayDeserializer(item["value"]),
+    nextLink: item["nextLink"]
+  };
+}
+function dnsSecurityRuleArraySerializer(result) {
+  return result.map((item) => {
+    return dnsSecurityRuleSerializer(item);
+  });
+}
+function dnsSecurityRuleArrayDeserializer(result) {
+  return result.map((item) => {
+    return dnsSecurityRuleDeserializer(item);
+  });
+}
+function dnsResolverPolicyVirtualNetworkLinkSerializer(item) {
+  return {
+    tags: item["tags"],
+    location: item["location"],
+    properties: _dnsResolverPolicyVirtualNetworkLinkPropertiesSerializer(item)
+  };
+}
+function dnsResolverPolicyVirtualNetworkLinkDeserializer(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"]),
+    ..._dnsResolverPolicyVirtualNetworkLinkPropertiesDeserializer(item["properties"]),
+    etag: item["etag"]
+  };
+}
+function dnsResolverPolicyVirtualNetworkLinkPropertiesSerializer(item) {
+  return { virtualNetwork: subResourceSerializer(item["virtualNetwork"]) };
+}
+function dnsResolverPolicyVirtualNetworkLinkPropertiesDeserializer(item) {
+  return {
+    virtualNetwork: subResourceDeserializer(item["virtualNetwork"]),
+    provisioningState: item["provisioningState"]
+  };
+}
+function dnsResolverPolicyVirtualNetworkLinkPatchSerializer(item) {
+  return { tags: item["tags"] };
+}
+function _dnsResolverPolicyVirtualNetworkLinkListResultDeserializer(item) {
+  return {
+    value: dnsResolverPolicyVirtualNetworkLinkArrayDeserializer(item["value"]),
+    nextLink: item["nextLink"]
+  };
+}
+function dnsResolverPolicyVirtualNetworkLinkArraySerializer(result) {
+  return result.map((item) => {
+    return dnsResolverPolicyVirtualNetworkLinkSerializer(item);
+  });
+}
+function dnsResolverPolicyVirtualNetworkLinkArrayDeserializer(result) {
+  return result.map((item) => {
+    return dnsResolverPolicyVirtualNetworkLinkDeserializer(item);
+  });
+}
+function dnsResolverDomainListSerializer(item) {
+  return {
+    tags: item["tags"],
+    location: item["location"],
+    properties: (0, import_check_prop_undefined.areAllPropsUndefined)(item, ["domains"]) ? void 0 : _dnsResolverDomainListPropertiesSerializer(item)
+  };
+}
+function dnsResolverDomainListDeserializer(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"] : _dnsResolverDomainListPropertiesDeserializer(item["properties"]),
+    etag: item["etag"]
+  };
+}
+function dnsResolverDomainListPropertiesSerializer(item) {
+  return {
+    domains: !item["domains"] ? item["domains"] : item["domains"].map((p) => {
+      return p;
+    })
+  };
+}
+function dnsResolverDomainListPropertiesDeserializer(item) {
+  return {
+    domains: !item["domains"] ? item["domains"] : item["domains"].map((p) => {
+      return p;
+    }),
+    domainsUrl: item["domainsUrl"],
+    provisioningState: item["provisioningState"],
+    resourceGuid: item["resourceGuid"]
+  };
+}
+function dnsResolverDomainListPatchSerializer(item) {
+  return {
+    properties: (0, import_check_prop_undefined.areAllPropsUndefined)(item, ["domains"]) ? void 0 : _dnsResolverDomainListPatchPropertiesSerializer(item),
+    tags: item["tags"]
+  };
+}
+function dnsResolverDomainListPatchPropertiesSerializer(item) {
+  return {
+    domains: !item["domains"] ? item["domains"] : item["domains"].map((p) => {
+      return p;
+    })
+  };
+}
+function _dnsResolverDomainListListResultDeserializer(item) {
+  return {
+    value: dnsResolverDomainListArrayDeserializer(item["value"]),
+    nextLink: item["nextLink"]
+  };
+}
+function dnsResolverDomainListArraySerializer(result) {
+  return result.map((item) => {
+    return dnsResolverDomainListSerializer(item);
+  });
+}
+function dnsResolverDomainListArrayDeserializer(result) {
+  return result.map((item) => {
+    return dnsResolverDomainListDeserializer(item);
+  });
+}
+function dnsResolverDomainListBulkSerializer(item) {
+  return { properties: _dnsResolverDomainListBulkPropertiesSerializer(item) };
+}
+function dnsResolverDomainListBulkPropertiesSerializer(item) {
+  return { storageUrl: item["storageUrl"], action: item["action"] };
+}
+var KnownAction = /* @__PURE__ */ ((KnownAction2) => {
+  KnownAction2["Upload"] = "Upload";
+  KnownAction2["Download"] = "Download";
+  return KnownAction2;
+})(KnownAction || {});
+var KnownVersions = /* @__PURE__ */ ((KnownVersions2) => {
+  KnownVersions2["V20250501"] = "2025-05-01";
+  KnownVersions2["V20251001Preview"] = "2025-10-01-preview";
+  return KnownVersions2;
+})(KnownVersions || {});
+function _dnsResolverPropertiesSerializer(item) {
+  return { virtualNetwork: subResourceSerializer(item["virtualNetwork"]) };
+}
+function _dnsResolverPropertiesDeserializer(item) {
+  return {
+    virtualNetwork: subResourceDeserializer(item["virtualNetwork"]),
+    dnsResolverState: item["dnsResolverState"],
+    provisioningState: item["provisioningState"],
+    resourceGuid: item["resourceGuid"]
+  };
+}
+function _inboundEndpointPropertiesSerializer(item) {
+  return { ipConfigurations: ipConfigurationArraySerializer(item["ipConfigurations"]) };
+}
+function _inboundEndpointPropertiesDeserializer(item) {
+  return {
+    ipConfigurations: ipConfigurationArrayDeserializer(item["ipConfigurations"]),
+    provisioningState: item["provisioningState"],
+    resourceGuid: item["resourceGuid"]
+  };
+}
+function _outboundEndpointPropertiesSerializer(item) {
+  return { subnet: subResourceSerializer(item["subnet"]) };
+}
+function _outboundEndpointPropertiesDeserializer(item) {
+  return {
+    subnet: subResourceDeserializer(item["subnet"]),
+    provisioningState: item["provisioningState"],
+    resourceGuid: item["resourceGuid"]
+  };
+}
+function _dnsForwardingRulesetPropertiesSerializer(item) {
+  return {
+    dnsResolverOutboundEndpoints: subResourceArraySerializer(item["dnsResolverOutboundEndpoints"])
+  };
+}
+function _dnsForwardingRulesetPropertiesDeserializer(item) {
+  return {
+    dnsResolverOutboundEndpoints: subResourceArrayDeserializer(
+      item["dnsResolverOutboundEndpoints"]
+    ),
+    provisioningState: item["provisioningState"],
+    resourceGuid: item["resourceGuid"]
+  };
+}
+function _virtualNetworkDnsForwardingRulesetPropertiesDeserializer(item) {
+  return {
+    virtualNetworkLink: !item["virtualNetworkLink"] ? item["virtualNetworkLink"] : subResourceDeserializer(item["virtualNetworkLink"])
+  };
+}
+function _forwardingRulePropertiesSerializer(item) {
+  return {
+    domainName: item["domainName"],
+    targetDnsServers: targetDnsServerArraySerializer(item["targetDnsServers"]),
+    metadata: item["metadata"],
+    forwardingRuleState: item["forwardingRuleState"]
+  };
+}
+function _forwardingRulePropertiesDeserializer(item) {
+  return {
+    domainName: item["domainName"],
+    targetDnsServers: targetDnsServerArrayDeserializer(item["targetDnsServers"]),
+    metadata: !item["metadata"] ? item["metadata"] : Object.fromEntries(Object.entries(item["metadata"]).map(([k, p]) => [k, p])),
+    forwardingRuleState: item["forwardingRuleState"],
+    provisioningState: item["provisioningState"]
+  };
+}
+function _forwardingRulePatchPropertiesSerializer(item) {
+  return {
+    targetDnsServers: !item["targetDnsServers"] ? item["targetDnsServers"] : targetDnsServerArraySerializer(item["targetDnsServers"]),
+    metadata: item["metadata"],
+    forwardingRuleState: item["forwardingRuleState"]
+  };
+}
+function _virtualNetworkLinkPropertiesSerializer(item) {
+  return {
+    virtualNetwork: subResourceSerializer(item["virtualNetwork"]),
+    metadata: item["metadata"]
+  };
+}
+function _virtualNetworkLinkPropertiesDeserializer(item) {
+  return {
+    virtualNetwork: subResourceDeserializer(item["virtualNetwork"]),
+    metadata: !item["metadata"] ? item["metadata"] : Object.fromEntries(Object.entries(item["metadata"]).map(([k, p]) => [k, p])),
+    provisioningState: item["provisioningState"]
+  };
+}
+function _virtualNetworkLinkPatchPropertiesSerializer(item) {
+  return { metadata: item["metadata"] };
+}
+function _dnsResolverPolicyPropertiesSerializer(_item) {
+  return {};
+}
+function _dnsResolverPolicyPropertiesDeserializer(item) {
+  return {
+    provisioningState: item["provisioningState"],
+    resourceGuid: item["resourceGuid"]
+  };
+}
+function _dnsSecurityRulePropertiesSerializer(item) {
+  return {
+    priority: item["priority"],
+    action: dnsSecurityRuleActionSerializer(item["action"]),
+    dnsResolverDomainLists: !item["dnsResolverDomainLists"] ? item["dnsResolverDomainLists"] : subResourceArraySerializer(item["dnsResolverDomainLists"]),
+    managedDomainLists: !item["managedDomainLists"] ? item["managedDomainLists"] : item["managedDomainLists"].map((p) => {
+      return p;
+    }),
+    dnsSecurityRuleState: item["dnsSecurityRuleState"]
+  };
+}
+function _dnsSecurityRulePropertiesDeserializer(item) {
+  return {
+    priority: item["priority"],
+    action: dnsSecurityRuleActionDeserializer(item["action"]),
+    dnsResolverDomainLists: !item["dnsResolverDomainLists"] ? item["dnsResolverDomainLists"] : subResourceArrayDeserializer(item["dnsResolverDomainLists"]),
+    managedDomainLists: !item["managedDomainLists"] ? item["managedDomainLists"] : item["managedDomainLists"].map((p) => {
+      return p;
+    }),
+    dnsSecurityRuleState: item["dnsSecurityRuleState"],
+    provisioningState: item["provisioningState"]
+  };
+}
+function _dnsSecurityRulePatchPropertiesSerializer(item) {
+  return {
+    action: !item["action"] ? item["action"] : dnsSecurityRuleActionSerializer(item["action"]),
+    dnsResolverDomainLists: !item["dnsResolverDomainLists"] ? item["dnsResolverDomainLists"] : subResourceArraySerializer(item["dnsResolverDomainLists"]),
+    managedDomainLists: !item["managedDomainLists"] ? item["managedDomainLists"] : item["managedDomainLists"].map((p) => {
+      return p;
+    }),
+    dnsSecurityRuleState: item["dnsSecurityRuleState"],
+    priority: item["priority"]
+  };
+}
+function _dnsResolverPolicyVirtualNetworkLinkPropertiesSerializer(item) {
+  return { virtualNetwork: subResourceSerializer(item["virtualNetwork"]) };
+}
+function _dnsResolverPolicyVirtualNetworkLinkPropertiesDeserializer(item) {
+  return {
+    virtualNetwork: subResourceDeserializer(item["virtualNetwork"]),
+    provisioningState: item["provisioningState"]
+  };
+}
+function _dnsResolverDomainListPropertiesSerializer(item) {
+  return {
+    domains: !item["domains"] ? item["domains"] : item["domains"].map((p) => {
+      return p;
+    })
+  };
+}
+function _dnsResolverDomainListPropertiesDeserializer(item) {
+  return {
+    domains: !item["domains"] ? item["domains"] : item["domains"].map((p) => {
+      return p;
+    }),
+    domainsUrl: item["domainsUrl"],
+    provisioningState: item["provisioningState"],
+    resourceGuid: item["resourceGuid"]
+  };
+}
+function _dnsResolverDomainListPatchPropertiesSerializer(item) {
+  return {
+    domains: !item["domains"] ? item["domains"] : item["domains"].map((p) => {
+      return p;
+    })
+  };
+}
+function _dnsResolverDomainListBulkPropertiesSerializer(item) {
+  return { storageUrl: item["storageUrl"], action: item["action"] };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KnownAction,
+  KnownActionType,
+  KnownCreatedByType,
+  KnownDnsResolverState,
+  KnownDnsSecurityRuleState,
+  KnownForwardingRuleState,
+  KnownIpAllocationMethod,
+  KnownManagedDomainList,
+  KnownProvisioningState,
+  KnownVersions,
+  _dnsForwardingRulesetListResultDeserializer,
+  _dnsForwardingRulesetPropertiesDeserializer,
+  _dnsForwardingRulesetPropertiesSerializer,
+  _dnsResolverDomainListBulkPropertiesSerializer,
+  _dnsResolverDomainListListResultDeserializer,
+  _dnsResolverDomainListPatchPropertiesSerializer,
+  _dnsResolverDomainListPropertiesDeserializer,
+  _dnsResolverDomainListPropertiesSerializer,
+  _dnsResolverListResultDeserializer,
+  _dnsResolverPolicyListResultDeserializer,
+  _dnsResolverPolicyPropertiesDeserializer,
+  _dnsResolverPolicyPropertiesSerializer,
+  _dnsResolverPolicyVirtualNetworkLinkListResultDeserializer,
+  _dnsResolverPolicyVirtualNetworkLinkPropertiesDeserializer,
+  _dnsResolverPolicyVirtualNetworkLinkPropertiesSerializer,
+  _dnsResolverPropertiesDeserializer,
+  _dnsResolverPropertiesSerializer,
+  _dnsSecurityRuleListResultDeserializer,
+  _dnsSecurityRulePatchPropertiesSerializer,
+  _dnsSecurityRulePropertiesDeserializer,
+  _dnsSecurityRulePropertiesSerializer,
+  _forwardingRuleListResultDeserializer,
+  _forwardingRulePatchPropertiesSerializer,
+  _forwardingRulePropertiesDeserializer,
+  _forwardingRulePropertiesSerializer,
+  _inboundEndpointListResultDeserializer,
+  _inboundEndpointPropertiesDeserializer,
+  _inboundEndpointPropertiesSerializer,
+  _outboundEndpointListResultDeserializer,
+  _outboundEndpointPropertiesDeserializer,
+  _outboundEndpointPropertiesSerializer,
+  _subResourceListResultDeserializer,
+  _virtualNetworkDnsForwardingRulesetListResultDeserializer,
+  _virtualNetworkDnsForwardingRulesetPropertiesDeserializer,
+  _virtualNetworkLinkListResultDeserializer,
+  _virtualNetworkLinkPatchPropertiesSerializer,
+  _virtualNetworkLinkPropertiesDeserializer,
+  _virtualNetworkLinkPropertiesSerializer,
+  cloudErrorBodyArrayDeserializer,
+  cloudErrorBodyDeserializer,
+  cloudErrorDeserializer,
+  dnsForwardingRulesetArrayDeserializer,
+  dnsForwardingRulesetArraySerializer,
+  dnsForwardingRulesetDeserializer,
+  dnsForwardingRulesetPatchSerializer,
+  dnsForwardingRulesetPropertiesDeserializer,
+  dnsForwardingRulesetPropertiesSerializer,
+  dnsForwardingRulesetSerializer,
+  dnsResolverArrayDeserializer,
+  dnsResolverArraySerializer,
+  dnsResolverDeserializer,
+  dnsResolverDomainListArrayDeserializer,
+  dnsResolverDomainListArraySerializer,
+  dnsResolverDomainListBulkPropertiesSerializer,
+  dnsResolverDomainListBulkSerializer,
+  dnsResolverDomainListDeserializer,
+  dnsResolverDomainListPatchPropertiesSerializer,
+  dnsResolverDomainListPatchSerializer,
+  dnsResolverDomainListPropertiesDeserializer,
+  dnsResolverDomainListPropertiesSerializer,
+  dnsResolverDomainListSerializer,
+  dnsResolverPatchSerializer,
+  dnsResolverPolicyArrayDeserializer,
+  dnsResolverPolicyArraySerializer,
+  dnsResolverPolicyDeserializer,
+  dnsResolverPolicyPatchSerializer,
+  dnsResolverPolicyPropertiesDeserializer,
+  dnsResolverPolicyPropertiesSerializer,
+  dnsResolverPolicySerializer,
+  dnsResolverPolicyVirtualNetworkLinkArrayDeserializer,
+  dnsResolverPolicyVirtualNetworkLinkArraySerializer,
+  dnsResolverPolicyVirtualNetworkLinkDeserializer,
+  dnsResolverPolicyVirtualNetworkLinkPatchSerializer,
+  dnsResolverPolicyVirtualNetworkLinkPropertiesDeserializer,
+  dnsResolverPolicyVirtualNetworkLinkPropertiesSerializer,
+  dnsResolverPolicyVirtualNetworkLinkSerializer,
+  dnsResolverPropertiesDeserializer,
+  dnsResolverPropertiesSerializer,
+  dnsResolverSerializer,
+  dnsSecurityRuleActionDeserializer,
+  dnsSecurityRuleActionSerializer,
+  dnsSecurityRuleArrayDeserializer,
+  dnsSecurityRuleArraySerializer,
+  dnsSecurityRuleDeserializer,
+  dnsSecurityRulePatchPropertiesSerializer,
+  dnsSecurityRulePatchSerializer,
+  dnsSecurityRulePropertiesDeserializer,
+  dnsSecurityRulePropertiesSerializer,
+  dnsSecurityRuleSerializer,
+  errorAdditionalInfoArrayDeserializer,
+  errorAdditionalInfoDeserializer,
+  errorDetailArrayDeserializer,
+  errorDetailDeserializer,
+  errorResponseDeserializer,
+  forwardingRuleArrayDeserializer,
+  forwardingRuleArraySerializer,
+  forwardingRuleDeserializer,
+  forwardingRulePatchPropertiesSerializer,
+  forwardingRulePatchSerializer,
+  forwardingRulePropertiesDeserializer,
+  forwardingRulePropertiesSerializer,
+  forwardingRuleSerializer,
+  inboundEndpointArrayDeserializer,
+  inboundEndpointArraySerializer,
+  inboundEndpointDeserializer,
+  inboundEndpointPatchSerializer,
+  inboundEndpointPropertiesDeserializer,
+  inboundEndpointPropertiesSerializer,
+  inboundEndpointSerializer,
+  ipConfigurationArrayDeserializer,
+  ipConfigurationArraySerializer,
+  ipConfigurationDeserializer,
+  ipConfigurationSerializer,
+  outboundEndpointArrayDeserializer,
+  outboundEndpointArraySerializer,
+  outboundEndpointDeserializer,
+  outboundEndpointPatchSerializer,
+  outboundEndpointPropertiesDeserializer,
+  outboundEndpointPropertiesSerializer,
+  outboundEndpointSerializer,
+  proxyResourceDeserializer,
+  proxyResourceSerializer,
+  resourceDeserializer,
+  resourceSerializer,
+  subResourceArrayDeserializer,
+  subResourceArraySerializer,
+  subResourceDeserializer,
+  subResourceSerializer,
+  systemDataDeserializer,
+  targetDnsServerArrayDeserializer,
+  targetDnsServerArraySerializer,
+  targetDnsServerDeserializer,
+  targetDnsServerSerializer,
+  trackedResourceDeserializer,
+  trackedResourceSerializer,
+  virtualNetworkDnsForwardingRulesetArrayDeserializer,
+  virtualNetworkDnsForwardingRulesetDeserializer,
+  virtualNetworkLinkArrayDeserializer,
+  virtualNetworkLinkArraySerializer,
+  virtualNetworkLinkDeserializer,
+  virtualNetworkLinkPatchPropertiesSerializer,
+  virtualNetworkLinkPatchSerializer,
+  virtualNetworkLinkPropertiesDeserializer,
+  virtualNetworkLinkPropertiesSerializer,
+  virtualNetworkLinkSerializer,
+  virtualNetworkLinkSubResourcePropertiesDeserializer
+});
+//# sourceMappingURL=models.js.map