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

package/dist/esm/models/models.d.ts

@@ -0,0 +1,900 @@
+/**
+ * This file contains only generated model types and their (de)serializers.
+ * Disable the following rules for internal models with '_' prefix and deserializers which require 'any' for raw JSON input.
+ */
+/** Describes a DNS resolver. */
+export interface DnsResolver extends TrackedResource {
+    /** "If etag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.") */
+    readonly etag?: string;
+    /** The reference to the virtual network. This cannot be changed after creation. */
+    virtualNetwork: SubResource;
+    /** The current status of the DNS resolver. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly dnsResolverState?: DnsResolverState;
+    /** The current provisioning state of the DNS resolver. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+    /** The resourceGuid property of the DNS resolver resource. */
+    readonly resourceGuid?: string;
+}
+export declare function dnsResolverSerializer(item: DnsResolver): any;
+export declare function dnsResolverDeserializer(item: any): DnsResolver;
+/** Represents the properties of a DNS resolver. */
+export interface DnsResolverProperties {
+    /** The reference to the virtual network. This cannot be changed after creation. */
+    virtualNetwork: SubResource;
+    /** The current status of the DNS resolver. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly dnsResolverState?: DnsResolverState;
+    /** The current provisioning state of the DNS resolver. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+    /** The resourceGuid property of the DNS resolver resource. */
+    readonly resourceGuid?: string;
+}
+export declare function dnsResolverPropertiesSerializer(item: DnsResolverProperties): any;
+export declare function dnsResolverPropertiesDeserializer(item: any): DnsResolverProperties;
+/** Reference to another ARM resource. */
+export interface SubResource {
+    /** Resource ID. */
+    id: string;
+}
+export declare function subResourceSerializer(item: SubResource): any;
+export declare function subResourceDeserializer(item: any): SubResource;
+/** The current status of the DNS resolver. This is a read-only property and any attempt to set this value will be ignored. */
+export declare enum KnownDnsResolverState {
+    /** Connected */
+    Connected = "Connected",
+    /** Disconnected */
+    Disconnected = "Disconnected"
+}
+/**
+ * The current status of the DNS resolver. This is a read-only property and any attempt to set this value will be ignored. \
+ * {@link KnownDnsResolverState} can be used interchangeably with DnsResolverState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Connected** \
+ * **Disconnected**
+ */
+export type DnsResolverState = string;
+/** The current provisioning state of the resource. */
+export declare enum KnownProvisioningState {
+    /** Creating */
+    Creating = "Creating",
+    /** Updating */
+    Updating = "Updating",
+    /** Deleting */
+    Deleting = "Deleting",
+    /** Succeeded */
+    Succeeded = "Succeeded",
+    /** Failed */
+    Failed = "Failed",
+    /** Canceled */
+    Canceled = "Canceled"
+}
+/**
+ * The current provisioning state of the resource. \
+ * {@link KnownProvisioningState} can be used interchangeably with ProvisioningState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Creating** \
+ * **Updating** \
+ * **Deleting** \
+ * **Succeeded** \
+ * **Failed** \
+ * **Canceled**
+ */
+export type ProvisioningState = string;
+/** The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location' */
+export interface TrackedResource extends Resource {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The geo-location where the resource lives */
+    location: string;
+}
+export declare function trackedResourceSerializer(item: TrackedResource): any;
+export declare function trackedResourceDeserializer(item: any): TrackedResource;
+/** Common fields that are returned in the response for all Azure Resource Manager resources */
+export interface Resource {
+    /** Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} */
+    readonly id?: string;
+    /** The name of the resource */
+    readonly name?: string;
+    /** The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" */
+    readonly type?: string;
+    /** Azure Resource Manager metadata containing createdBy and modifiedBy information. */
+    readonly systemData?: SystemData;
+}
+export declare function resourceSerializer(_item: Resource): any;
+export declare function resourceDeserializer(item: any): Resource;
+/** Metadata pertaining to creation and last modification of the resource. */
+export interface SystemData {
+    /** The identity that created the resource. */
+    createdBy?: string;
+    /** The type of identity that created the resource. */
+    createdByType?: CreatedByType;
+    /** The timestamp of resource creation (UTC). */
+    createdAt?: Date;
+    /** The identity that last modified the resource. */
+    lastModifiedBy?: string;
+    /** The type of identity that last modified the resource. */
+    lastModifiedByType?: CreatedByType;
+    /** The timestamp of resource last modification (UTC) */
+    lastModifiedAt?: Date;
+}
+export declare function systemDataDeserializer(item: any): SystemData;
+/** The kind of entity that created the resource. */
+export declare enum KnownCreatedByType {
+    /** The entity was created by a user. */
+    User = "User",
+    /** The entity was created by an application. */
+    Application = "Application",
+    /** The entity was created by a managed identity. */
+    ManagedIdentity = "ManagedIdentity",
+    /** The entity was created by a key. */
+    Key = "Key"
+}
+/**
+ * The kind of entity that created the resource. \
+ * {@link KnownCreatedByType} can be used interchangeably with CreatedByType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **User**: The entity was created by a user. \
+ * **Application**: The entity was created by an application. \
+ * **ManagedIdentity**: The entity was created by a managed identity. \
+ * **Key**: The entity was created by a key.
+ */
+export type CreatedByType = string;
+/** An error message */
+export interface CloudError {
+    /** The error message body */
+    error?: CloudErrorBody;
+}
+export declare function cloudErrorDeserializer(item: any): CloudError;
+/** The body of an error message */
+export interface CloudErrorBody {
+    /** The error code */
+    code?: string;
+    /** A description of what caused the error */
+    message?: string;
+    /** The target resource of the error message */
+    target?: string;
+    /** Extra error information */
+    details?: CloudErrorBody[];
+}
+export declare function cloudErrorBodyDeserializer(item: any): CloudErrorBody;
+export declare function cloudErrorBodyArrayDeserializer(result: Array<CloudErrorBody>): any[];
+/** The error detail. */
+export interface ErrorDetail {
+    /** The error code. */
+    readonly code?: string;
+    /** The error message. */
+    readonly message?: string;
+    /** The error target. */
+    readonly target?: string;
+    /** The error details. */
+    readonly details?: ErrorDetail[];
+    /** The error additional info. */
+    readonly additionalInfo?: ErrorAdditionalInfo[];
+}
+export declare function errorDetailDeserializer(item: any): ErrorDetail;
+export declare function errorDetailArrayDeserializer(result: Array<ErrorDetail>): any[];
+export declare function errorAdditionalInfoArrayDeserializer(result: Array<ErrorAdditionalInfo>): any[];
+/** The resource management error additional info. */
+export interface ErrorAdditionalInfo {
+    /** The additional info type. */
+    readonly type?: string;
+    /** The additional info. */
+    readonly info?: any;
+}
+export declare function errorAdditionalInfoDeserializer(item: any): ErrorAdditionalInfo;
+/** Describes a DNS resolver for PATCH operation. */
+export interface DnsResolverPatch {
+    /** Tags for DNS Resolver. */
+    tags?: Record<string, string>;
+}
+export declare function dnsResolverPatchSerializer(item: DnsResolverPatch): any;
+/** The response of a DnsResolver list operation. */
+export interface _DnsResolverListResult {
+    /** The DnsResolver items on this page */
+    value: DnsResolver[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _dnsResolverListResultDeserializer(item: any): _DnsResolverListResult;
+export declare function dnsResolverArraySerializer(result: Array<DnsResolver>): any[];
+export declare function dnsResolverArrayDeserializer(result: Array<DnsResolver>): any[];
+/** The response to an enumeration operation on sub-resources. */
+export interface _SubResourceListResult {
+    /** The SubResource items on this page */
+    value: SubResource[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _subResourceListResultDeserializer(item: any): _SubResourceListResult;
+export declare function subResourceArraySerializer(result: Array<SubResource>): any[];
+export declare function subResourceArrayDeserializer(result: Array<SubResource>): any[];
+/** Describes an inbound endpoint for a DNS resolver. */
+export interface InboundEndpoint extends TrackedResource {
+    /** "If etag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.") */
+    readonly etag?: string;
+    /** IP configurations for the inbound endpoint. */
+    ipConfigurations: IpConfiguration[];
+    /** The current provisioning state of the inbound endpoint. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+    /** The resourceGuid property of the inbound endpoint resource. */
+    readonly resourceGuid?: string;
+}
+export declare function inboundEndpointSerializer(item: InboundEndpoint): any;
+export declare function inboundEndpointDeserializer(item: any): InboundEndpoint;
+/** Represents the properties of an inbound endpoint for a DNS resolver. */
+export interface InboundEndpointProperties {
+    /** IP configurations for the inbound endpoint. */
+    ipConfigurations: IpConfiguration[];
+    /** The current provisioning state of the inbound endpoint. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+    /** The resourceGuid property of the inbound endpoint resource. */
+    readonly resourceGuid?: string;
+}
+export declare function inboundEndpointPropertiesSerializer(item: InboundEndpointProperties): any;
+export declare function inboundEndpointPropertiesDeserializer(item: any): InboundEndpointProperties;
+export declare function ipConfigurationArraySerializer(result: Array<IpConfiguration>): any[];
+export declare function ipConfigurationArrayDeserializer(result: Array<IpConfiguration>): any[];
+/** IP configuration. */
+export interface IpConfiguration {
+    /** The reference to the subnet bound to the IP configuration. */
+    subnet: SubResource;
+    /** Private IP address of the IP configuration. */
+    privateIpAddress?: string;
+    /** Private IP address allocation method. */
+    privateIpAllocationMethod?: IpAllocationMethod;
+}
+export declare function ipConfigurationSerializer(item: IpConfiguration): any;
+export declare function ipConfigurationDeserializer(item: any): IpConfiguration;
+/** Private IP address allocation method. */
+export declare enum KnownIpAllocationMethod {
+    /** Static */
+    Static = "Static",
+    /** Dynamic */
+    Dynamic = "Dynamic"
+}
+/**
+ * Private IP address allocation method. \
+ * {@link KnownIpAllocationMethod} can be used interchangeably with IpAllocationMethod,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Static** \
+ * **Dynamic**
+ */
+export type IpAllocationMethod = string;
+/** Describes an inbound endpoint for a DNS resolver for PATCH operation. */
+export interface InboundEndpointPatch {
+    /** Tags for inbound endpoint. */
+    tags?: Record<string, string>;
+}
+export declare function inboundEndpointPatchSerializer(item: InboundEndpointPatch): any;
+/** The response of a InboundEndpoint list operation. */
+export interface _InboundEndpointListResult {
+    /** The InboundEndpoint items on this page */
+    value: InboundEndpoint[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _inboundEndpointListResultDeserializer(item: any): _InboundEndpointListResult;
+export declare function inboundEndpointArraySerializer(result: Array<InboundEndpoint>): any[];
+export declare function inboundEndpointArrayDeserializer(result: Array<InboundEndpoint>): any[];
+/** Describes an outbound endpoint for a DNS resolver. */
+export interface OutboundEndpoint extends TrackedResource {
+    /** "If etag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.") */
+    readonly etag?: string;
+    /** The reference to the subnet used for the outbound endpoint. */
+    subnet: SubResource;
+    /** The current provisioning state of the outbound endpoint. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+    /** The resourceGuid property of the outbound endpoint resource. */
+    readonly resourceGuid?: string;
+}
+export declare function outboundEndpointSerializer(item: OutboundEndpoint): any;
+export declare function outboundEndpointDeserializer(item: any): OutboundEndpoint;
+/** Represents the properties of an outbound endpoint for a DNS resolver. */
+export interface OutboundEndpointProperties {
+    /** The reference to the subnet used for the outbound endpoint. */
+    subnet: SubResource;
+    /** The current provisioning state of the outbound endpoint. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+    /** The resourceGuid property of the outbound endpoint resource. */
+    readonly resourceGuid?: string;
+}
+export declare function outboundEndpointPropertiesSerializer(item: OutboundEndpointProperties): any;
+export declare function outboundEndpointPropertiesDeserializer(item: any): OutboundEndpointProperties;
+/** Describes an outbound endpoint for a DNS resolver for PATCH operation. */
+export interface OutboundEndpointPatch {
+    /** Tags for outbound endpoint. */
+    tags?: Record<string, string>;
+}
+export declare function outboundEndpointPatchSerializer(item: OutboundEndpointPatch): any;
+/** The response of a OutboundEndpoint list operation. */
+export interface _OutboundEndpointListResult {
+    /** The OutboundEndpoint items on this page */
+    value: OutboundEndpoint[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _outboundEndpointListResultDeserializer(item: any): _OutboundEndpointListResult;
+export declare function outboundEndpointArraySerializer(result: Array<OutboundEndpoint>): any[];
+export declare function outboundEndpointArrayDeserializer(result: Array<OutboundEndpoint>): any[];
+/** Describes a DNS forwarding ruleset. */
+export interface DnsForwardingRuleset extends TrackedResource {
+    /** "If etag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.") */
+    readonly etag?: string;
+    /** The reference to the DNS resolver outbound endpoints that are used to route DNS queries matching the forwarding rules in the ruleset to the target DNS servers. */
+    dnsResolverOutboundEndpoints: SubResource[];
+    /** The current provisioning state of the DNS forwarding ruleset. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+    /** The resourceGuid for the DNS forwarding ruleset. */
+    readonly resourceGuid?: string;
+}
+export declare function dnsForwardingRulesetSerializer(item: DnsForwardingRuleset): any;
+export declare function dnsForwardingRulesetDeserializer(item: any): DnsForwardingRuleset;
+/** Represents the properties of a DNS forwarding ruleset. */
+export interface DnsForwardingRulesetProperties {
+    /** The reference to the DNS resolver outbound endpoints that are used to route DNS queries matching the forwarding rules in the ruleset to the target DNS servers. */
+    dnsResolverOutboundEndpoints: SubResource[];
+    /** The current provisioning state of the DNS forwarding ruleset. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+    /** The resourceGuid for the DNS forwarding ruleset. */
+    readonly resourceGuid?: string;
+}
+export declare function dnsForwardingRulesetPropertiesSerializer(item: DnsForwardingRulesetProperties): any;
+export declare function dnsForwardingRulesetPropertiesDeserializer(item: any): DnsForwardingRulesetProperties;
+/** Describes a DNS forwarding ruleset PATCH operation. */
+export interface DnsForwardingRulesetPatch {
+    /** The reference to the DNS resolver outbound endpoints that are used to route DNS queries matching the forwarding rules in the ruleset to the target DNS servers. */
+    dnsResolverOutboundEndpoints?: SubResource[];
+    /** Tags for DNS Resolver. */
+    tags?: Record<string, string>;
+}
+export declare function dnsForwardingRulesetPatchSerializer(item: DnsForwardingRulesetPatch): any;
+/** The response of a DnsForwardingRuleset list operation. */
+export interface _DnsForwardingRulesetListResult {
+    /** The DnsForwardingRuleset items on this page */
+    value: DnsForwardingRuleset[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _dnsForwardingRulesetListResultDeserializer(item: any): _DnsForwardingRulesetListResult;
+export declare function dnsForwardingRulesetArraySerializer(result: Array<DnsForwardingRuleset>): any[];
+export declare function dnsForwardingRulesetArrayDeserializer(result: Array<DnsForwardingRuleset>): any[];
+/** The response to an enumeration operation on Virtual Network DNS Forwarding Ruleset. */
+export interface _VirtualNetworkDnsForwardingRulesetListResult {
+    /** The VirtualNetworkDnsForwardingRuleset items on this page */
+    value: VirtualNetworkDnsForwardingRuleset[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _virtualNetworkDnsForwardingRulesetListResultDeserializer(item: any): _VirtualNetworkDnsForwardingRulesetListResult;
+export declare function virtualNetworkDnsForwardingRulesetArrayDeserializer(result: Array<VirtualNetworkDnsForwardingRuleset>): any[];
+/** Reference to DNS forwarding ruleset and associated virtual network link. */
+export interface VirtualNetworkDnsForwardingRuleset {
+    /** DNS Forwarding Ruleset Resource ID. */
+    id?: string;
+    /** The reference to the virtual network link. */
+    virtualNetworkLink?: SubResource;
+}
+export declare function virtualNetworkDnsForwardingRulesetDeserializer(item: any): VirtualNetworkDnsForwardingRuleset;
+/** The reference to the virtual network link that associates between the DNS forwarding ruleset and virtual network. */
+export interface VirtualNetworkLinkSubResourceProperties {
+    /** The reference to the virtual network link. */
+    virtualNetworkLink?: SubResource;
+}
+export declare function virtualNetworkLinkSubResourcePropertiesDeserializer(item: any): VirtualNetworkLinkSubResourceProperties;
+/** Describes a forwarding rule within a DNS forwarding ruleset. */
+export interface ForwardingRule extends ProxyResource {
+    /** "If etag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.") */
+    readonly etag?: string;
+    /** The domain name for the forwarding rule. */
+    domainName: string;
+    /** DNS servers to forward the DNS query to. */
+    targetDnsServers: TargetDnsServer[];
+    /** Metadata attached to the forwarding rule. */
+    metadata?: Record<string, string>;
+    /** The state of forwarding rule. */
+    forwardingRuleState?: ForwardingRuleState;
+    /** The current provisioning state of the forwarding rule. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function forwardingRuleSerializer(item: ForwardingRule): any;
+export declare function forwardingRuleDeserializer(item: any): ForwardingRule;
+/** Represents the properties of a forwarding rule within a DNS forwarding ruleset. */
+export interface ForwardingRuleProperties {
+    /** The domain name for the forwarding rule. */
+    domainName: string;
+    /** DNS servers to forward the DNS query to. */
+    targetDnsServers: TargetDnsServer[];
+    /** Metadata attached to the forwarding rule. */
+    metadata?: Record<string, string>;
+    /** The state of forwarding rule. */
+    forwardingRuleState?: ForwardingRuleState;
+    /** The current provisioning state of the forwarding rule. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function forwardingRulePropertiesSerializer(item: ForwardingRuleProperties): any;
+export declare function forwardingRulePropertiesDeserializer(item: any): ForwardingRuleProperties;
+export declare function targetDnsServerArraySerializer(result: Array<TargetDnsServer>): any[];
+export declare function targetDnsServerArrayDeserializer(result: Array<TargetDnsServer>): any[];
+/** Describes a server to forward the DNS queries to. */
+export interface TargetDnsServer {
+    /** DNS server IP address. */
+    ipAddress: string;
+    /** DNS server port. */
+    port?: number;
+}
+export declare function targetDnsServerSerializer(item: TargetDnsServer): any;
+export declare function targetDnsServerDeserializer(item: any): TargetDnsServer;
+/** The state of forwarding rule. */
+export declare enum KnownForwardingRuleState {
+    /** Enabled */
+    Enabled = "Enabled",
+    /** Disabled */
+    Disabled = "Disabled"
+}
+/**
+ * The state of forwarding rule. \
+ * {@link KnownForwardingRuleState} can be used interchangeably with ForwardingRuleState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled** \
+ * **Disabled**
+ */
+export type ForwardingRuleState = string;
+/** The resource model definition for a Azure Resource Manager proxy resource. It will not have tags and a location */
+export interface ProxyResource extends Resource {
+}
+export declare function proxyResourceSerializer(_item: ProxyResource): any;
+export declare function proxyResourceDeserializer(item: any): ProxyResource;
+/** Describes a forwarding rule for PATCH operation. */
+export interface ForwardingRulePatch {
+    /** DNS servers to forward the DNS query to. */
+    targetDnsServers?: TargetDnsServer[];
+    /** Metadata attached to the forwarding rule. */
+    metadata?: Record<string, string>;
+    /** The state of forwarding rule. */
+    forwardingRuleState?: ForwardingRuleState;
+}
+export declare function forwardingRulePatchSerializer(item: ForwardingRulePatch): any;
+/** Represents the updatable properties of a forwarding rule within a DNS forwarding ruleset. */
+export interface ForwardingRulePatchProperties {
+    /** DNS servers to forward the DNS query to. */
+    targetDnsServers?: TargetDnsServer[];
+    /** Metadata attached to the forwarding rule. */
+    metadata?: Record<string, string>;
+    /** The state of forwarding rule. */
+    forwardingRuleState?: ForwardingRuleState;
+}
+export declare function forwardingRulePatchPropertiesSerializer(item: ForwardingRulePatchProperties): any;
+/** The response of a ForwardingRule list operation. */
+export interface _ForwardingRuleListResult {
+    /** The ForwardingRule items on this page */
+    value: ForwardingRule[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _forwardingRuleListResultDeserializer(item: any): _ForwardingRuleListResult;
+export declare function forwardingRuleArraySerializer(result: Array<ForwardingRule>): any[];
+export declare function forwardingRuleArrayDeserializer(result: Array<ForwardingRule>): any[];
+/** Describes a virtual network link. */
+export interface VirtualNetworkLink extends ProxyResource {
+    /** "If etag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.") */
+    readonly etag?: string;
+    /** The reference to the virtual network. This cannot be changed after creation. */
+    virtualNetwork: SubResource;
+    /** Metadata attached to the virtual network link. */
+    metadata?: Record<string, string>;
+    /** The current provisioning state of the virtual network link. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function virtualNetworkLinkSerializer(item: VirtualNetworkLink): any;
+export declare function virtualNetworkLinkDeserializer(item: any): VirtualNetworkLink;
+/** Represents the properties of a virtual network link. */
+export interface VirtualNetworkLinkProperties {
+    /** The reference to the virtual network. This cannot be changed after creation. */
+    virtualNetwork: SubResource;
+    /** Metadata attached to the virtual network link. */
+    metadata?: Record<string, string>;
+    /** The current provisioning state of the virtual network link. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function virtualNetworkLinkPropertiesSerializer(item: VirtualNetworkLinkProperties): any;
+export declare function virtualNetworkLinkPropertiesDeserializer(item: any): VirtualNetworkLinkProperties;
+/** Describes a virtual network link for PATCH operation. */
+export interface VirtualNetworkLinkPatch {
+    /** Metadata attached to the virtual network link. */
+    metadata?: Record<string, string>;
+}
+export declare function virtualNetworkLinkPatchSerializer(item: VirtualNetworkLinkPatch): any;
+/** Represents the updatable properties of the virtual network link. */
+export interface VirtualNetworkLinkPatchProperties {
+    /** Metadata attached to the virtual network link. */
+    metadata?: Record<string, string>;
+}
+export declare function virtualNetworkLinkPatchPropertiesSerializer(item: VirtualNetworkLinkPatchProperties): any;
+/** The response of a VirtualNetworkLink list operation. */
+export interface _VirtualNetworkLinkListResult {
+    /** The VirtualNetworkLink items on this page */
+    value: VirtualNetworkLink[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _virtualNetworkLinkListResultDeserializer(item: any): _VirtualNetworkLinkListResult;
+export declare function virtualNetworkLinkArraySerializer(result: Array<VirtualNetworkLink>): any[];
+export declare function virtualNetworkLinkArrayDeserializer(result: Array<VirtualNetworkLink>): any[];
+/** Describes a DNS resolver policy. */
+export interface DnsResolverPolicy extends TrackedResource {
+    /** "If etag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.") */
+    readonly etag?: string;
+    /** The current provisioning state of the DNS resolver policy. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+    /** The resourceGuid property of the DNS resolver policy resource. */
+    readonly resourceGuid?: string;
+}
+export declare function dnsResolverPolicySerializer(item: DnsResolverPolicy): any;
+export declare function dnsResolverPolicyDeserializer(item: any): DnsResolverPolicy;
+/** Represents the properties of a DNS resolver policy. */
+export interface DnsResolverPolicyProperties {
+    /** The current provisioning state of the DNS resolver policy. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+    /** The resourceGuid property of the DNS resolver policy resource. */
+    readonly resourceGuid?: string;
+}
+export declare function dnsResolverPolicyPropertiesSerializer(_item: DnsResolverPolicyProperties): any;
+export declare function dnsResolverPolicyPropertiesDeserializer(item: any): DnsResolverPolicyProperties;
+/** Common error response for all Azure Resource Manager APIs to return error details for failed operations. */
+export interface ErrorResponse {
+    /** The error object. */
+    error?: ErrorDetail;
+}
+export declare function errorResponseDeserializer(item: any): ErrorResponse;
+/** Describes a DNS resolver policy for PATCH operation. */
+export interface DnsResolverPolicyPatch {
+    /** Tags for DNS resolver policy. */
+    tags?: Record<string, string>;
+}
+export declare function dnsResolverPolicyPatchSerializer(item: DnsResolverPolicyPatch): any;
+/** The response of a DnsResolverPolicy list operation. */
+export interface _DnsResolverPolicyListResult {
+    /** The DnsResolverPolicy items on this page */
+    value: DnsResolverPolicy[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _dnsResolverPolicyListResultDeserializer(item: any): _DnsResolverPolicyListResult;
+export declare function dnsResolverPolicyArraySerializer(result: Array<DnsResolverPolicy>): any[];
+export declare function dnsResolverPolicyArrayDeserializer(result: Array<DnsResolverPolicy>): any[];
+/** Describes a DNS security rule. */
+export interface DnsSecurityRule extends TrackedResource {
+    /** "If etag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.") */
+    readonly etag?: string;
+    /** The priority of the DNS security rule. */
+    priority: number;
+    /** The action to take on DNS requests that match the DNS security rule. */
+    action: DnsSecurityRuleAction;
+    /** DNS resolver policy domains lists that the DNS security rule applies to. */
+    dnsResolverDomainLists?: SubResource[];
+    /** Managed domain lists that the DNS security rule applies to. */
+    managedDomainLists?: ManagedDomainList[];
+    /** The state of DNS security rule. */
+    dnsSecurityRuleState?: DnsSecurityRuleState;
+    /** The current provisioning state of the DNS security rule. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function dnsSecurityRuleSerializer(item: DnsSecurityRule): any;
+export declare function dnsSecurityRuleDeserializer(item: any): DnsSecurityRule;
+/** Represents the properties of a DNS security rule. */
+export interface DnsSecurityRuleProperties {
+    /** The priority of the DNS security rule. */
+    priority: number;
+    /** The action to take on DNS requests that match the DNS security rule. */
+    action: DnsSecurityRuleAction;
+    /** DNS resolver policy domains lists that the DNS security rule applies to. */
+    dnsResolverDomainLists?: SubResource[];
+    /** Managed domain lists that the DNS security rule applies to. */
+    managedDomainLists?: ManagedDomainList[];
+    /** The state of DNS security rule. */
+    dnsSecurityRuleState?: DnsSecurityRuleState;
+    /** The current provisioning state of the DNS security rule. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function dnsSecurityRulePropertiesSerializer(item: DnsSecurityRuleProperties): any;
+export declare function dnsSecurityRulePropertiesDeserializer(item: any): DnsSecurityRuleProperties;
+/** The action to take on DNS requests that match the DNS security rule. */
+export interface DnsSecurityRuleAction {
+    /** The type of action to take. */
+    actionType?: ActionType;
+}
+export declare function dnsSecurityRuleActionSerializer(item: DnsSecurityRuleAction): any;
+export declare function dnsSecurityRuleActionDeserializer(item: any): DnsSecurityRuleAction;
+/** The type of action to take. */
+export declare enum KnownActionType {
+    /** Allow */
+    Allow = "Allow",
+    /** Alert */
+    Alert = "Alert",
+    /** Block */
+    Block = "Block"
+}
+/**
+ * The type of action to take. \
+ * {@link KnownActionType} can be used interchangeably with ActionType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Allow** \
+ * **Alert** \
+ * **Block**
+ */
+export type ActionType = string;
+/** Describes Managed Domain List options for DNS security rules. */
+export declare enum KnownManagedDomainList {
+    /** Domain list managed by Azure DNS Threat Intelligence. */
+    AzureDnsThreatIntel = "AzureDnsThreatIntel"
+}
+/**
+ * Describes Managed Domain List options for DNS security rules. \
+ * {@link KnownManagedDomainList} can be used interchangeably with ManagedDomainList,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **AzureDnsThreatIntel**: Domain list managed by Azure DNS Threat Intelligence.
+ */
+export type ManagedDomainList = string;
+/** The state of DNS security rule. */
+export declare enum KnownDnsSecurityRuleState {
+    /** Enabled */
+    Enabled = "Enabled",
+    /** Disabled */
+    Disabled = "Disabled"
+}
+/**
+ * The state of DNS security rule. \
+ * {@link KnownDnsSecurityRuleState} can be used interchangeably with DnsSecurityRuleState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled** \
+ * **Disabled**
+ */
+export type DnsSecurityRuleState = string;
+/** Describes a DNS security rule for PATCH operation. */
+export interface DnsSecurityRulePatch {
+    /** Tags for DNS security rule. */
+    tags?: Record<string, string>;
+    /** The action to take on DNS requests that match the DNS security rule. */
+    action?: DnsSecurityRuleAction;
+    /** DNS resolver policy domains lists that the DNS security rule applies to. */
+    dnsResolverDomainLists?: SubResource[];
+    /** Managed domain lists that the DNS security rule applies to. */
+    managedDomainLists?: ManagedDomainList[];
+    /** The state of DNS security rule. */
+    dnsSecurityRuleState?: DnsSecurityRuleState;
+    /** The priority of the DNS security rule. */
+    priority?: number;
+}
+export declare function dnsSecurityRulePatchSerializer(item: DnsSecurityRulePatch): any;
+/** Represents the updatable properties of a DNS security rule. */
+export interface DnsSecurityRulePatchProperties {
+    /** The action to take on DNS requests that match the DNS security rule. */
+    action?: DnsSecurityRuleAction;
+    /** DNS resolver policy domains lists that the DNS security rule applies to. */
+    dnsResolverDomainLists?: SubResource[];
+    /** Managed domain lists that the DNS security rule applies to. */
+    managedDomainLists?: ManagedDomainList[];
+    /** The state of DNS security rule. */
+    dnsSecurityRuleState?: DnsSecurityRuleState;
+    /** The priority of the DNS security rule. */
+    priority?: number;
+}
+export declare function dnsSecurityRulePatchPropertiesSerializer(item: DnsSecurityRulePatchProperties): any;
+/** The response of a DnsSecurityRule list operation. */
+export interface _DnsSecurityRuleListResult {
+    /** The DnsSecurityRule items on this page */
+    value: DnsSecurityRule[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _dnsSecurityRuleListResultDeserializer(item: any): _DnsSecurityRuleListResult;
+export declare function dnsSecurityRuleArraySerializer(result: Array<DnsSecurityRule>): any[];
+export declare function dnsSecurityRuleArrayDeserializer(result: Array<DnsSecurityRule>): any[];
+/** Describes a DNS resolver policy virtual network link. */
+export interface DnsResolverPolicyVirtualNetworkLink extends TrackedResource {
+    /** "If etag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.") */
+    readonly etag?: string;
+    /** The reference to the virtual network. This cannot be changed after creation. */
+    virtualNetwork: SubResource;
+    /** The current provisioning state of the DNS resolver policy virtual network link. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function dnsResolverPolicyVirtualNetworkLinkSerializer(item: DnsResolverPolicyVirtualNetworkLink): any;
+export declare function dnsResolverPolicyVirtualNetworkLinkDeserializer(item: any): DnsResolverPolicyVirtualNetworkLink;
+/** Represents the properties of a DNS resolver policy virtual network link. */
+export interface DnsResolverPolicyVirtualNetworkLinkProperties {
+    /** The reference to the virtual network. This cannot be changed after creation. */
+    virtualNetwork: SubResource;
+    /** The current provisioning state of the DNS resolver policy virtual network link. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function dnsResolverPolicyVirtualNetworkLinkPropertiesSerializer(item: DnsResolverPolicyVirtualNetworkLinkProperties): any;
+export declare function dnsResolverPolicyVirtualNetworkLinkPropertiesDeserializer(item: any): DnsResolverPolicyVirtualNetworkLinkProperties;
+/** Describes a DNS resolver policy virtual network link for PATCH operation. */
+export interface DnsResolverPolicyVirtualNetworkLinkPatch {
+    /** Tags for the DNS resolver policy virtual network link. */
+    tags?: Record<string, string>;
+}
+export declare function dnsResolverPolicyVirtualNetworkLinkPatchSerializer(item: DnsResolverPolicyVirtualNetworkLinkPatch): any;
+/** The response of a DnsResolverPolicyVirtualNetworkLink list operation. */
+export interface _DnsResolverPolicyVirtualNetworkLinkListResult {
+    /** The DnsResolverPolicyVirtualNetworkLink items on this page */
+    value: DnsResolverPolicyVirtualNetworkLink[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _dnsResolverPolicyVirtualNetworkLinkListResultDeserializer(item: any): _DnsResolverPolicyVirtualNetworkLinkListResult;
+export declare function dnsResolverPolicyVirtualNetworkLinkArraySerializer(result: Array<DnsResolverPolicyVirtualNetworkLink>): any[];
+export declare function dnsResolverPolicyVirtualNetworkLinkArrayDeserializer(result: Array<DnsResolverPolicyVirtualNetworkLink>): any[];
+/** Describes a DNS resolver domain list. */
+export interface DnsResolverDomainList extends TrackedResource {
+    /** "If etag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.") */
+    readonly etag?: string;
+    /** The domains in the domain list. Will be null if user is using large domain list. */
+    domains?: string[];
+    /** The URL for bulk upload or download for domain lists containing larger set of domains. This will be populated if domains is empty or null. */
+    readonly domainsUrl?: string;
+    /** The current provisioning state of the DNS resolver domain list. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+    /** The resourceGuid property of the DNS resolver domain list resource. */
+    readonly resourceGuid?: string;
+}
+export declare function dnsResolverDomainListSerializer(item: DnsResolverDomainList): any;
+export declare function dnsResolverDomainListDeserializer(item: any): DnsResolverDomainList;
+/** Represents the properties of a DNS resolver domain list. */
+export interface DnsResolverDomainListProperties {
+    /** The domains in the domain list. Will be null if user is using large domain list. */
+    domains?: string[];
+    /** The URL for bulk upload or download for domain lists containing larger set of domains. This will be populated if domains is empty or null. */
+    readonly domainsUrl?: string;
+    /** The current provisioning state of the DNS resolver domain list. This is a read-only property and any attempt to set this value will be ignored. */
+    readonly provisioningState?: ProvisioningState;
+    /** The resourceGuid property of the DNS resolver domain list resource. */
+    readonly resourceGuid?: string;
+}
+export declare function dnsResolverDomainListPropertiesSerializer(item: DnsResolverDomainListProperties): any;
+export declare function dnsResolverDomainListPropertiesDeserializer(item: any): DnsResolverDomainListProperties;
+/** Describes a DNS resolver domain list for PATCH operation. */
+export interface DnsResolverDomainListPatch {
+    /** Tags for DNS resolver domain list. */
+    tags?: Record<string, string>;
+    /** The domains in the domain list. */
+    domains?: string[];
+}
+export declare function dnsResolverDomainListPatchSerializer(item: DnsResolverDomainListPatch): any;
+/** Represents the updatable properties of a DNS resolver domain list. */
+export interface DnsResolverDomainListPatchProperties {
+    /** The domains in the domain list. */
+    domains?: string[];
+}
+export declare function dnsResolverDomainListPatchPropertiesSerializer(item: DnsResolverDomainListPatchProperties): any;
+/** The response of a DnsResolverDomainList list operation. */
+export interface _DnsResolverDomainListListResult {
+    /** The DnsResolverDomainList items on this page */
+    value: DnsResolverDomainList[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _dnsResolverDomainListListResultDeserializer(item: any): _DnsResolverDomainListListResult;
+export declare function dnsResolverDomainListArraySerializer(result: Array<DnsResolverDomainList>): any[];
+export declare function dnsResolverDomainListArrayDeserializer(result: Array<DnsResolverDomainList>): any[];
+/** Describes a DNS resolver domain list for bulk UPLOAD or DOWNLOAD operations. */
+export interface DnsResolverDomainListBulk {
+    /** The storage account blob file URL to be used in the bulk upload or download request of DNS resolver domain list. */
+    storageUrl: string;
+    /** The action to take in the request, Upload or Download. */
+    action: Action;
+}
+export declare function dnsResolverDomainListBulkSerializer(item: DnsResolverDomainListBulk): any;
+/** Describes DNS resolver domain list properties for bulk UPLOAD or DOWNLOAD operations. */
+export interface DnsResolverDomainListBulkProperties {
+    /** The storage account blob file URL to be used in the bulk upload or download request of DNS resolver domain list. */
+    storageUrl: string;
+    /** The action to take in the request, Upload or Download. */
+    action: Action;
+}
+export declare function dnsResolverDomainListBulkPropertiesSerializer(item: DnsResolverDomainListBulkProperties): any;
+/** The action type in requests for bulk upload or download of a DNS resolver domain list. */
+export declare enum KnownAction {
+    /** Upload */
+    Upload = "Upload",
+    /** Download */
+    Download = "Download"
+}
+/**
+ * The action type in requests for bulk upload or download of a DNS resolver domain list. \
+ * {@link KnownAction} can be used interchangeably with Action,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Upload** \
+ * **Download**
+ */
+export type Action = string;
+/** The available API versions. */
+export declare enum KnownVersions {
+    /** The 2025-05-01 API version. */
+    V20250501 = "2025-05-01",
+    /** The 2025-10-01-Preview API version. */
+    V20251001Preview = "2025-10-01-preview"
+}
+export declare function _dnsResolverPropertiesSerializer(item: DnsResolver): any;
+export declare function _dnsResolverPropertiesDeserializer(item: any): {
+    virtualNetwork: SubResource;
+    dnsResolverState: any;
+    provisioningState: any;
+    resourceGuid: any;
+};
+export declare function _inboundEndpointPropertiesSerializer(item: InboundEndpoint): any;
+export declare function _inboundEndpointPropertiesDeserializer(item: any): {
+    ipConfigurations: any[];
+    provisioningState: any;
+    resourceGuid: any;
+};
+export declare function _outboundEndpointPropertiesSerializer(item: OutboundEndpoint): any;
+export declare function _outboundEndpointPropertiesDeserializer(item: any): {
+    subnet: SubResource;
+    provisioningState: any;
+    resourceGuid: any;
+};
+export declare function _dnsForwardingRulesetPropertiesSerializer(item: DnsForwardingRuleset): any;
+export declare function _dnsForwardingRulesetPropertiesDeserializer(item: any): {
+    dnsResolverOutboundEndpoints: any[];
+    provisioningState: any;
+    resourceGuid: any;
+};
+export declare function _virtualNetworkDnsForwardingRulesetPropertiesDeserializer(item: any): {
+    virtualNetworkLink: any;
+};
+export declare function _forwardingRulePropertiesSerializer(item: ForwardingRule): any;
+export declare function _forwardingRulePropertiesDeserializer(item: any): {
+    domainName: any;
+    targetDnsServers: any[];
+    metadata: any;
+    forwardingRuleState: any;
+    provisioningState: any;
+};
+export declare function _forwardingRulePatchPropertiesSerializer(item: ForwardingRulePatch): any;
+export declare function _virtualNetworkLinkPropertiesSerializer(item: VirtualNetworkLink): any;
+export declare function _virtualNetworkLinkPropertiesDeserializer(item: any): {
+    virtualNetwork: SubResource;
+    metadata: any;
+    provisioningState: any;
+};
+export declare function _virtualNetworkLinkPatchPropertiesSerializer(item: VirtualNetworkLinkPatch): any;
+export declare function _dnsResolverPolicyPropertiesSerializer(_item: DnsResolverPolicy): any;
+export declare function _dnsResolverPolicyPropertiesDeserializer(item: any): {
+    provisioningState: any;
+    resourceGuid: any;
+};
+export declare function _dnsSecurityRulePropertiesSerializer(item: DnsSecurityRule): any;
+export declare function _dnsSecurityRulePropertiesDeserializer(item: any): {
+    priority: any;
+    action: DnsSecurityRuleAction;
+    dnsResolverDomainLists: any;
+    managedDomainLists: any;
+    dnsSecurityRuleState: any;
+    provisioningState: any;
+};
+export declare function _dnsSecurityRulePatchPropertiesSerializer(item: DnsSecurityRulePatch): any;
+export declare function _dnsResolverPolicyVirtualNetworkLinkPropertiesSerializer(item: DnsResolverPolicyVirtualNetworkLink): any;
+export declare function _dnsResolverPolicyVirtualNetworkLinkPropertiesDeserializer(item: any): {
+    virtualNetwork: SubResource;
+    provisioningState: any;
+};
+export declare function _dnsResolverDomainListPropertiesSerializer(item: DnsResolverDomainList): any;
+export declare function _dnsResolverDomainListPropertiesDeserializer(item: any): {
+    domains: any;
+    domainsUrl: any;
+    provisioningState: any;
+    resourceGuid: any;
+};
+export declare function _dnsResolverDomainListPatchPropertiesSerializer(item: DnsResolverDomainListPatch): any;
+export declare function _dnsResolverDomainListBulkPropertiesSerializer(item: DnsResolverDomainListBulk): any;
+//# sourceMappingURL=models.d.ts.map