gogol-dns-1.0.0: gen/Gogol/DNS/Internal/Product.hs
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE ImportQualifiedPost #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
{-# OPTIONS_GHC -fno-warn-name-shadowing #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}
-- |
-- Module : Gogol.DNS.Internal.Product
-- Copyright : (c) 2015-2025 Brendan Hay
-- License : Mozilla Public License, v. 2.0.
-- Maintainer : Brendan Hay <brendan.g.hay+gogol@gmail.com>
-- Toni Cebrián <toni@tonicebrian.com>
-- Stability : auto-generated
-- Portability : non-portable (GHC extensions)
module Gogol.DNS.Internal.Product
( -- * Change
Change (..),
newChange,
-- * ChangesListResponse
ChangesListResponse (..),
newChangesListResponse,
-- * DnsKey
DnsKey (..),
newDnsKey,
-- * DnsKeyDigest
DnsKeyDigest (..),
newDnsKeyDigest,
-- * DnsKeySpec
DnsKeySpec (..),
newDnsKeySpec,
-- * DnsKeysListResponse
DnsKeysListResponse (..),
newDnsKeysListResponse,
-- * ManagedZone
ManagedZone (..),
newManagedZone,
-- * ManagedZone_Labels
ManagedZone_Labels (..),
newManagedZone_Labels,
-- * ManagedZoneCloudLoggingConfig
ManagedZoneCloudLoggingConfig (..),
newManagedZoneCloudLoggingConfig,
-- * ManagedZoneDnsSecConfig
ManagedZoneDnsSecConfig (..),
newManagedZoneDnsSecConfig,
-- * ManagedZoneForwardingConfig
ManagedZoneForwardingConfig (..),
newManagedZoneForwardingConfig,
-- * ManagedZoneForwardingConfigNameServerTarget
ManagedZoneForwardingConfigNameServerTarget (..),
newManagedZoneForwardingConfigNameServerTarget,
-- * ManagedZoneOperationsListResponse
ManagedZoneOperationsListResponse (..),
newManagedZoneOperationsListResponse,
-- * ManagedZonePeeringConfig
ManagedZonePeeringConfig (..),
newManagedZonePeeringConfig,
-- * ManagedZonePeeringConfigTargetNetwork
ManagedZonePeeringConfigTargetNetwork (..),
newManagedZonePeeringConfigTargetNetwork,
-- * ManagedZonePrivateVisibilityConfig
ManagedZonePrivateVisibilityConfig (..),
newManagedZonePrivateVisibilityConfig,
-- * ManagedZonePrivateVisibilityConfigGKECluster
ManagedZonePrivateVisibilityConfigGKECluster (..),
newManagedZonePrivateVisibilityConfigGKECluster,
-- * ManagedZonePrivateVisibilityConfigNetwork
ManagedZonePrivateVisibilityConfigNetwork (..),
newManagedZonePrivateVisibilityConfigNetwork,
-- * ManagedZoneReverseLookupConfig
ManagedZoneReverseLookupConfig (..),
newManagedZoneReverseLookupConfig,
-- * ManagedZoneServiceDirectoryConfig
ManagedZoneServiceDirectoryConfig (..),
newManagedZoneServiceDirectoryConfig,
-- * ManagedZoneServiceDirectoryConfigNamespace
ManagedZoneServiceDirectoryConfigNamespace (..),
newManagedZoneServiceDirectoryConfigNamespace,
-- * ManagedZonesListResponse
ManagedZonesListResponse (..),
newManagedZonesListResponse,
-- * Operation
Operation (..),
newOperation,
-- * OperationDnsKeyContext
OperationDnsKeyContext (..),
newOperationDnsKeyContext,
-- * OperationManagedZoneContext
OperationManagedZoneContext (..),
newOperationManagedZoneContext,
-- * PoliciesListResponse
PoliciesListResponse (..),
newPoliciesListResponse,
-- * PoliciesPatchResponse
PoliciesPatchResponse (..),
newPoliciesPatchResponse,
-- * PoliciesUpdateResponse
PoliciesUpdateResponse (..),
newPoliciesUpdateResponse,
-- * Policy
Policy (..),
newPolicy,
-- * PolicyAlternativeNameServerConfig
PolicyAlternativeNameServerConfig (..),
newPolicyAlternativeNameServerConfig,
-- * PolicyAlternativeNameServerConfigTargetNameServer
PolicyAlternativeNameServerConfigTargetNameServer (..),
newPolicyAlternativeNameServerConfigTargetNameServer,
-- * PolicyNetwork
PolicyNetwork (..),
newPolicyNetwork,
-- * Project
Project (..),
newProject,
-- * Quota
Quota (..),
newQuota,
-- * RRSetRoutingPolicy
RRSetRoutingPolicy (..),
newRRSetRoutingPolicy,
-- * RRSetRoutingPolicyGeoPolicy
RRSetRoutingPolicyGeoPolicy (..),
newRRSetRoutingPolicyGeoPolicy,
-- * RRSetRoutingPolicyGeoPolicyGeoPolicyItem
RRSetRoutingPolicyGeoPolicyGeoPolicyItem (..),
newRRSetRoutingPolicyGeoPolicyGeoPolicyItem,
-- * RRSetRoutingPolicyWrrPolicy
RRSetRoutingPolicyWrrPolicy (..),
newRRSetRoutingPolicyWrrPolicy,
-- * RRSetRoutingPolicyWrrPolicyWrrPolicyItem
RRSetRoutingPolicyWrrPolicyWrrPolicyItem (..),
newRRSetRoutingPolicyWrrPolicyWrrPolicyItem,
-- * ResourceRecordSet
ResourceRecordSet (..),
newResourceRecordSet,
-- * ResourceRecordSetsListResponse
ResourceRecordSetsListResponse (..),
newResourceRecordSetsListResponse,
-- * ResponseHeader
ResponseHeader (..),
newResponseHeader,
-- * ResponsePoliciesListResponse
ResponsePoliciesListResponse (..),
newResponsePoliciesListResponse,
-- * ResponsePoliciesPatchResponse
ResponsePoliciesPatchResponse (..),
newResponsePoliciesPatchResponse,
-- * ResponsePoliciesUpdateResponse
ResponsePoliciesUpdateResponse (..),
newResponsePoliciesUpdateResponse,
-- * ResponsePolicy
ResponsePolicy (..),
newResponsePolicy,
-- * ResponsePolicyGKECluster
ResponsePolicyGKECluster (..),
newResponsePolicyGKECluster,
-- * ResponsePolicyNetwork
ResponsePolicyNetwork (..),
newResponsePolicyNetwork,
-- * ResponsePolicyRule
ResponsePolicyRule (..),
newResponsePolicyRule,
-- * ResponsePolicyRuleLocalData
ResponsePolicyRuleLocalData (..),
newResponsePolicyRuleLocalData,
-- * ResponsePolicyRulesListResponse
ResponsePolicyRulesListResponse (..),
newResponsePolicyRulesListResponse,
-- * ResponsePolicyRulesPatchResponse
ResponsePolicyRulesPatchResponse (..),
newResponsePolicyRulesPatchResponse,
-- * ResponsePolicyRulesUpdateResponse
ResponsePolicyRulesUpdateResponse (..),
newResponsePolicyRulesUpdateResponse,
)
where
import Gogol.DNS.Internal.Sum
import Gogol.Prelude qualified as Core
-- | A Change represents a set of ResourceRecordSet additions and deletions applied atomically to a ManagedZone. ResourceRecordSets within a ManagedZone are modified by creating a new Change element in the Changes collection. In turn the Changes collection also records the past modifications to the ResourceRecordSets in a ManagedZone. The current state of the ManagedZone is the sum effect of applying all Change elements in the Changes collection in sequence.
--
-- /See:/ 'newChange' smart constructor.
data Change = Change
{ -- | Which ResourceRecordSets to add?
additions :: (Core.Maybe [ResourceRecordSet]),
-- | Which ResourceRecordSets to remove? Must match existing data exactly.
deletions :: (Core.Maybe [ResourceRecordSet]),
-- | Unique identifier for the resource; defined by the server (output only).
id :: (Core.Maybe Core.Text),
-- | If the DNS queries for the zone will be served.
isServing :: (Core.Maybe Core.Bool),
kind :: Core.Text,
-- | The time that this operation was started by the server (output only). This is in RFC3339 text format.
startTime :: (Core.Maybe Core.Text),
-- | Status of the operation (output only). A status of \"done\" means that the request to update the authoritative servers has been sent, but the servers might not be updated yet.
status :: (Core.Maybe Change_Status)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'Change' with the minimum fields required to make a request.
newChange ::
Change
newChange =
Change
{ additions = Core.Nothing,
deletions = Core.Nothing,
id = Core.Nothing,
isServing = Core.Nothing,
kind = "dns#change",
startTime = Core.Nothing,
status = Core.Nothing
}
instance Core.FromJSON Change where
parseJSON =
Core.withObject
"Change"
( \o ->
Change
Core.<$> (o Core..:? "additions")
Core.<*> (o Core..:? "deletions")
Core.<*> (o Core..:? "id")
Core.<*> (o Core..:? "isServing")
Core.<*> (o Core..:? "kind" Core..!= "dns#change")
Core.<*> (o Core..:? "startTime")
Core.<*> (o Core..:? "status")
)
instance Core.ToJSON Change where
toJSON Change {..} =
Core.object
( Core.catMaybes
[ ("additions" Core..=) Core.<$> additions,
("deletions" Core..=) Core.<$> deletions,
("id" Core..=) Core.<$> id,
("isServing" Core..=) Core.<$> isServing,
Core.Just ("kind" Core..= kind),
("startTime" Core..=) Core.<$> startTime,
("status" Core..=) Core.<$> status
]
)
-- | The response to a request to enumerate Changes to a ResourceRecordSets collection.
--
-- /See:/ 'newChangesListResponse' smart constructor.
data ChangesListResponse = ChangesListResponse
{ -- | The requested changes.
changes :: (Core.Maybe [Change]),
header :: (Core.Maybe ResponseHeader),
-- | Type of resource.
kind :: Core.Text,
-- | The presence of this field indicates that there exist more results following your last page of results in pagination order. To fetch them, make another list request using this value as your pagination token. This lets you retrieve the complete contents of even very large collections one page at a time. However, if the contents of the collection change between the first and last paginated list request, the set of all elements returned are an inconsistent view of the collection. You cannot retrieve a \"snapshot\" of collections larger than the maximum page size.
nextPageToken :: (Core.Maybe Core.Text)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ChangesListResponse' with the minimum fields required to make a request.
newChangesListResponse ::
ChangesListResponse
newChangesListResponse =
ChangesListResponse
{ changes = Core.Nothing,
header = Core.Nothing,
kind = "dns#changesListResponse",
nextPageToken = Core.Nothing
}
instance Core.FromJSON ChangesListResponse where
parseJSON =
Core.withObject
"ChangesListResponse"
( \o ->
ChangesListResponse
Core.<$> (o Core..:? "changes")
Core.<*> (o Core..:? "header")
Core.<*> (o Core..:? "kind" Core..!= "dns#changesListResponse")
Core.<*> (o Core..:? "nextPageToken")
)
instance Core.ToJSON ChangesListResponse where
toJSON ChangesListResponse {..} =
Core.object
( Core.catMaybes
[ ("changes" Core..=) Core.<$> changes,
("header" Core..=) Core.<$> header,
Core.Just ("kind" Core..= kind),
("nextPageToken" Core..=) Core.<$> nextPageToken
]
)
-- | A DNSSEC key pair.
--
-- /See:/ 'newDnsKey' smart constructor.
data DnsKey = DnsKey
{ -- | String mnemonic specifying the DNSSEC algorithm of this key. Immutable after creation time.
algorithm :: (Core.Maybe DnsKey_Algorithm),
-- | The time that this resource was created in the control plane. This is in RFC3339 text format. Output only.
creationTime :: (Core.Maybe Core.Text),
-- | A mutable string of at most 1024 characters associated with this resource for the user\'s convenience. Has no effect on the resource\'s function.
description :: (Core.Maybe Core.Text),
-- | Cryptographic hashes of the DNSKEY resource record associated with this DnsKey. These digests are needed to construct a DS record that points at this DNS key. Output only.
digests :: (Core.Maybe [DnsKeyDigest]),
-- | Unique identifier for the resource; defined by the server (output only).
id :: (Core.Maybe Core.Text),
-- | Active keys are used to sign subsequent changes to the ManagedZone. Inactive keys are still present as DNSKEY Resource Records for the use of resolvers validating existing signatures.
isActive :: (Core.Maybe Core.Bool),
-- | Length of the key in bits. Specified at creation time, and then immutable.
keyLength :: (Core.Maybe Core.Word32),
-- | The key tag is a non-cryptographic hash of the a DNSKEY resource record associated with this DnsKey. The key tag can be used to identify a DNSKEY more quickly (but it is not a unique identifier). In particular, the key tag is used in a parent zone\'s DS record to point at the DNSKEY in this child ManagedZone. The key tag is a number in the range [0, 65535] and the algorithm to calculate it is specified in RFC4034 Appendix B. Output only.
keyTag :: (Core.Maybe Core.Int32),
kind :: Core.Text,
-- | Base64 encoded public half of this key. Output only.
publicKey :: (Core.Maybe Core.Text),
-- | One of \"KEY/SIGNING\" or \"ZONE/SIGNING\". Keys of type KEY_SIGNING have the Secure Entry Point flag set and, when active, are used to sign only resource record sets of type DNSKEY. Otherwise, the Secure Entry Point flag is cleared, and this key is used to sign only resource record sets of other types. Immutable after creation time.
type' :: (Core.Maybe DnsKey_Type)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'DnsKey' with the minimum fields required to make a request.
newDnsKey ::
DnsKey
newDnsKey =
DnsKey
{ algorithm = Core.Nothing,
creationTime = Core.Nothing,
description = Core.Nothing,
digests = Core.Nothing,
id = Core.Nothing,
isActive = Core.Nothing,
keyLength = Core.Nothing,
keyTag = Core.Nothing,
kind = "dns#dnsKey",
publicKey = Core.Nothing,
type' = Core.Nothing
}
instance Core.FromJSON DnsKey where
parseJSON =
Core.withObject
"DnsKey"
( \o ->
DnsKey
Core.<$> (o Core..:? "algorithm")
Core.<*> (o Core..:? "creationTime")
Core.<*> (o Core..:? "description")
Core.<*> (o Core..:? "digests")
Core.<*> (o Core..:? "id")
Core.<*> (o Core..:? "isActive")
Core.<*> (o Core..:? "keyLength")
Core.<*> (o Core..:? "keyTag")
Core.<*> (o Core..:? "kind" Core..!= "dns#dnsKey")
Core.<*> (o Core..:? "publicKey")
Core.<*> (o Core..:? "type")
)
instance Core.ToJSON DnsKey where
toJSON DnsKey {..} =
Core.object
( Core.catMaybes
[ ("algorithm" Core..=) Core.<$> algorithm,
("creationTime" Core..=) Core.<$> creationTime,
("description" Core..=) Core.<$> description,
("digests" Core..=) Core.<$> digests,
("id" Core..=) Core.<$> id,
("isActive" Core..=) Core.<$> isActive,
("keyLength" Core..=) Core.<$> keyLength,
("keyTag" Core..=) Core.<$> keyTag,
Core.Just ("kind" Core..= kind),
("publicKey" Core..=) Core.<$> publicKey,
("type" Core..=) Core.<$> type'
]
)
--
-- /See:/ 'newDnsKeyDigest' smart constructor.
data DnsKeyDigest = DnsKeyDigest
{ -- | The base-16 encoded bytes of this digest. Suitable for use in a DS resource record.
digest :: (Core.Maybe Core.Text),
-- | Specifies the algorithm used to calculate this digest.
type' :: (Core.Maybe DnsKeyDigest_Type)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'DnsKeyDigest' with the minimum fields required to make a request.
newDnsKeyDigest ::
DnsKeyDigest
newDnsKeyDigest =
DnsKeyDigest {digest = Core.Nothing, type' = Core.Nothing}
instance Core.FromJSON DnsKeyDigest where
parseJSON =
Core.withObject
"DnsKeyDigest"
( \o ->
DnsKeyDigest
Core.<$> (o Core..:? "digest")
Core.<*> (o Core..:? "type")
)
instance Core.ToJSON DnsKeyDigest where
toJSON DnsKeyDigest {..} =
Core.object
( Core.catMaybes
[ ("digest" Core..=) Core.<$> digest,
("type" Core..=) Core.<$> type'
]
)
-- | Parameters for DnsKey key generation. Used for generating initial keys for a new ManagedZone and as default when adding a new DnsKey.
--
-- /See:/ 'newDnsKeySpec' smart constructor.
data DnsKeySpec = DnsKeySpec
{ -- | String mnemonic specifying the DNSSEC algorithm of this key.
algorithm :: (Core.Maybe DnsKeySpec_Algorithm),
-- | Length of the keys in bits.
keyLength :: (Core.Maybe Core.Word32),
-- | Specifies whether this is a key signing key (KSK) or a zone signing key (ZSK). Key signing keys have the Secure Entry Point flag set and, when active, are only used to sign resource record sets of type DNSKEY. Zone signing keys do not have the Secure Entry Point flag set and are used to sign all other types of resource record sets.
keyType :: (Core.Maybe DnsKeySpec_KeyType),
kind :: Core.Text
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'DnsKeySpec' with the minimum fields required to make a request.
newDnsKeySpec ::
DnsKeySpec
newDnsKeySpec =
DnsKeySpec
{ algorithm = Core.Nothing,
keyLength = Core.Nothing,
keyType = Core.Nothing,
kind = "dns#dnsKeySpec"
}
instance Core.FromJSON DnsKeySpec where
parseJSON =
Core.withObject
"DnsKeySpec"
( \o ->
DnsKeySpec
Core.<$> (o Core..:? "algorithm")
Core.<*> (o Core..:? "keyLength")
Core.<*> (o Core..:? "keyType")
Core.<*> (o Core..:? "kind" Core..!= "dns#dnsKeySpec")
)
instance Core.ToJSON DnsKeySpec where
toJSON DnsKeySpec {..} =
Core.object
( Core.catMaybes
[ ("algorithm" Core..=) Core.<$> algorithm,
("keyLength" Core..=) Core.<$> keyLength,
("keyType" Core..=) Core.<$> keyType,
Core.Just ("kind" Core..= kind)
]
)
-- | The response to a request to enumerate DnsKeys in a ManagedZone.
--
-- /See:/ 'newDnsKeysListResponse' smart constructor.
data DnsKeysListResponse = DnsKeysListResponse
{ -- | The requested resources.
dnsKeys :: (Core.Maybe [DnsKey]),
header :: (Core.Maybe ResponseHeader),
-- | Type of resource.
kind :: Core.Text,
-- | The presence of this field indicates that there exist more results following your last page of results in pagination order. To fetch them, make another list request using this value as your pagination token. In this way you can retrieve the complete contents of even very large collections one page at a time. However, if the contents of the collection change between the first and last paginated list request, the set of all elements returned are an inconsistent view of the collection. There is no way to retrieve a \"snapshot\" of collections larger than the maximum page size.
nextPageToken :: (Core.Maybe Core.Text)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'DnsKeysListResponse' with the minimum fields required to make a request.
newDnsKeysListResponse ::
DnsKeysListResponse
newDnsKeysListResponse =
DnsKeysListResponse
{ dnsKeys = Core.Nothing,
header = Core.Nothing,
kind = "dns#dnsKeysListResponse",
nextPageToken = Core.Nothing
}
instance Core.FromJSON DnsKeysListResponse where
parseJSON =
Core.withObject
"DnsKeysListResponse"
( \o ->
DnsKeysListResponse
Core.<$> (o Core..:? "dnsKeys")
Core.<*> (o Core..:? "header")
Core.<*> (o Core..:? "kind" Core..!= "dns#dnsKeysListResponse")
Core.<*> (o Core..:? "nextPageToken")
)
instance Core.ToJSON DnsKeysListResponse where
toJSON DnsKeysListResponse {..} =
Core.object
( Core.catMaybes
[ ("dnsKeys" Core..=) Core.<$> dnsKeys,
("header" Core..=) Core.<$> header,
Core.Just ("kind" Core..= kind),
("nextPageToken" Core..=) Core.<$> nextPageToken
]
)
-- | A zone is a subtree of the DNS namespace under one administrative responsibility. A ManagedZone is a resource that represents a DNS zone hosted by the Cloud DNS service.
--
-- /See:/ 'newManagedZone' smart constructor.
data ManagedZone = ManagedZone
{ cloudLoggingConfig :: (Core.Maybe ManagedZoneCloudLoggingConfig),
-- | The time that this resource was created on the server. This is in RFC3339 text format. Output only.
creationTime :: (Core.Maybe Core.Text),
-- | A mutable string of at most 1024 characters associated with this resource for the user\'s convenience. Has no effect on the managed zone\'s function.
description :: (Core.Maybe Core.Text),
-- | The DNS name of this managed zone, for instance \"example.com.\".
dnsName :: (Core.Maybe Core.Text),
-- | DNSSEC configuration.
dnssecConfig :: (Core.Maybe ManagedZoneDnsSecConfig),
-- | The presence for this field indicates that outbound forwarding is enabled for this zone. The value of this field contains the set of destinations to forward to.
forwardingConfig :: (Core.Maybe ManagedZoneForwardingConfig),
-- | Unique identifier for the resource; defined by the server (output only)
id :: (Core.Maybe Core.Word64),
kind :: Core.Text,
-- | User labels.
labels :: (Core.Maybe ManagedZone_Labels),
-- | User assigned name for this resource. Must be unique within the project. The name must be 1-63 characters long, must begin with a letter, end with a letter or digit, and only contain lowercase letters, digits or dashes.
name :: (Core.Maybe Core.Text),
-- | Optionally specifies the NameServerSet for this ManagedZone. A NameServerSet is a set of DNS name servers that all host the same ManagedZones. Most users leave this field unset. If you need to use this field, contact your account team.
nameServerSet :: (Core.Maybe Core.Text),
-- | Delegate your managed_zone to these virtual name servers; defined by the server (output only)
nameServers :: (Core.Maybe [Core.Text]),
-- | The presence of this field indicates that DNS Peering is enabled for this zone. The value of this field contains the network to peer with.
peeringConfig :: (Core.Maybe ManagedZonePeeringConfig),
-- | For privately visible zones, the set of Virtual Private Cloud resources that the zone is visible from.
privateVisibilityConfig :: (Core.Maybe ManagedZonePrivateVisibilityConfig),
-- | The presence of this field indicates that this is a managed reverse lookup zone and Cloud DNS resolves reverse lookup queries using automatically configured records for VPC resources. This only applies to networks listed under private/visibility/config.
reverseLookupConfig :: (Core.Maybe ManagedZoneReverseLookupConfig),
-- | This field links to the associated service directory namespace. Do not set this field for public zones or forwarding zones.
serviceDirectoryConfig :: (Core.Maybe ManagedZoneServiceDirectoryConfig),
-- | The zone\'s visibility: public zones are exposed to the Internet, while private zones are visible only to Virtual Private Cloud resources.
visibility :: (Core.Maybe ManagedZone_Visibility)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZone' with the minimum fields required to make a request.
newManagedZone ::
ManagedZone
newManagedZone =
ManagedZone
{ cloudLoggingConfig = Core.Nothing,
creationTime = Core.Nothing,
description = Core.Nothing,
dnsName = Core.Nothing,
dnssecConfig = Core.Nothing,
forwardingConfig = Core.Nothing,
id = Core.Nothing,
kind = "dns#managedZone",
labels = Core.Nothing,
name = Core.Nothing,
nameServerSet = Core.Nothing,
nameServers = Core.Nothing,
peeringConfig = Core.Nothing,
privateVisibilityConfig = Core.Nothing,
reverseLookupConfig = Core.Nothing,
serviceDirectoryConfig = Core.Nothing,
visibility = Core.Nothing
}
instance Core.FromJSON ManagedZone where
parseJSON =
Core.withObject
"ManagedZone"
( \o ->
ManagedZone
Core.<$> (o Core..:? "cloudLoggingConfig")
Core.<*> (o Core..:? "creationTime")
Core.<*> (o Core..:? "description")
Core.<*> (o Core..:? "dnsName")
Core.<*> (o Core..:? "dnssecConfig")
Core.<*> (o Core..:? "forwardingConfig")
Core.<*> (o Core..:? "id" Core.<&> Core.fmap Core.fromAsText)
Core.<*> (o Core..:? "kind" Core..!= "dns#managedZone")
Core.<*> (o Core..:? "labels")
Core.<*> (o Core..:? "name")
Core.<*> (o Core..:? "nameServerSet")
Core.<*> (o Core..:? "nameServers")
Core.<*> (o Core..:? "peeringConfig")
Core.<*> (o Core..:? "privateVisibilityConfig")
Core.<*> (o Core..:? "reverseLookupConfig")
Core.<*> (o Core..:? "serviceDirectoryConfig")
Core.<*> (o Core..:? "visibility")
)
instance Core.ToJSON ManagedZone where
toJSON ManagedZone {..} =
Core.object
( Core.catMaybes
[ ("cloudLoggingConfig" Core..=) Core.<$> cloudLoggingConfig,
("creationTime" Core..=) Core.<$> creationTime,
("description" Core..=) Core.<$> description,
("dnsName" Core..=) Core.<$> dnsName,
("dnssecConfig" Core..=) Core.<$> dnssecConfig,
("forwardingConfig" Core..=) Core.<$> forwardingConfig,
("id" Core..=) Core.. Core.AsText Core.<$> id,
Core.Just ("kind" Core..= kind),
("labels" Core..=) Core.<$> labels,
("name" Core..=) Core.<$> name,
("nameServerSet" Core..=) Core.<$> nameServerSet,
("nameServers" Core..=) Core.<$> nameServers,
("peeringConfig" Core..=) Core.<$> peeringConfig,
("privateVisibilityConfig" Core..=)
Core.<$> privateVisibilityConfig,
("reverseLookupConfig" Core..=) Core.<$> reverseLookupConfig,
("serviceDirectoryConfig" Core..=) Core.<$> serviceDirectoryConfig,
("visibility" Core..=) Core.<$> visibility
]
)
-- | User labels.
--
-- /See:/ 'newManagedZone_Labels' smart constructor.
newtype ManagedZone_Labels = ManagedZone_Labels
{ additional :: (Core.HashMap Core.Text Core.Text)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZone_Labels' with the minimum fields required to make a request.
newManagedZone_Labels ::
-- | See 'additional'.
Core.HashMap Core.Text Core.Text ->
ManagedZone_Labels
newManagedZone_Labels additional =
ManagedZone_Labels {additional = additional}
instance Core.FromJSON ManagedZone_Labels where
parseJSON =
Core.withObject
"ManagedZone_Labels"
(\o -> ManagedZone_Labels Core.<$> (Core.parseJSONObject o))
instance Core.ToJSON ManagedZone_Labels where
toJSON ManagedZone_Labels {..} = Core.toJSON additional
-- | Cloud Logging configurations for publicly visible zones.
--
-- /See:/ 'newManagedZoneCloudLoggingConfig' smart constructor.
data ManagedZoneCloudLoggingConfig = ManagedZoneCloudLoggingConfig
{ -- | If set, enable query logging for this ManagedZone. False by default, making logging opt-in.
enableLogging :: (Core.Maybe Core.Bool),
kind :: Core.Text
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZoneCloudLoggingConfig' with the minimum fields required to make a request.
newManagedZoneCloudLoggingConfig ::
ManagedZoneCloudLoggingConfig
newManagedZoneCloudLoggingConfig =
ManagedZoneCloudLoggingConfig
{ enableLogging = Core.Nothing,
kind = "dns#managedZoneCloudLoggingConfig"
}
instance Core.FromJSON ManagedZoneCloudLoggingConfig where
parseJSON =
Core.withObject
"ManagedZoneCloudLoggingConfig"
( \o ->
ManagedZoneCloudLoggingConfig
Core.<$> (o Core..:? "enableLogging")
Core.<*> (o Core..:? "kind" Core..!= "dns#managedZoneCloudLoggingConfig")
)
instance Core.ToJSON ManagedZoneCloudLoggingConfig where
toJSON ManagedZoneCloudLoggingConfig {..} =
Core.object
( Core.catMaybes
[ ("enableLogging" Core..=) Core.<$> enableLogging,
Core.Just ("kind" Core..= kind)
]
)
--
-- /See:/ 'newManagedZoneDnsSecConfig' smart constructor.
data ManagedZoneDnsSecConfig = ManagedZoneDnsSecConfig
{ -- | Specifies parameters for generating initial DnsKeys for this ManagedZone. Can only be changed while the state is OFF.
defaultKeySpecs :: (Core.Maybe [DnsKeySpec]),
kind :: Core.Text,
-- | Specifies the mechanism for authenticated denial-of-existence responses. Can only be changed while the state is OFF.
nonExistence :: (Core.Maybe ManagedZoneDnsSecConfig_NonExistence),
-- | Specifies whether DNSSEC is enabled, and what mode it is in.
state :: (Core.Maybe ManagedZoneDnsSecConfig_State)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZoneDnsSecConfig' with the minimum fields required to make a request.
newManagedZoneDnsSecConfig ::
ManagedZoneDnsSecConfig
newManagedZoneDnsSecConfig =
ManagedZoneDnsSecConfig
{ defaultKeySpecs = Core.Nothing,
kind = "dns#managedZoneDnsSecConfig",
nonExistence = Core.Nothing,
state = Core.Nothing
}
instance Core.FromJSON ManagedZoneDnsSecConfig where
parseJSON =
Core.withObject
"ManagedZoneDnsSecConfig"
( \o ->
ManagedZoneDnsSecConfig
Core.<$> (o Core..:? "defaultKeySpecs")
Core.<*> (o Core..:? "kind" Core..!= "dns#managedZoneDnsSecConfig")
Core.<*> (o Core..:? "nonExistence")
Core.<*> (o Core..:? "state")
)
instance Core.ToJSON ManagedZoneDnsSecConfig where
toJSON ManagedZoneDnsSecConfig {..} =
Core.object
( Core.catMaybes
[ ("defaultKeySpecs" Core..=) Core.<$> defaultKeySpecs,
Core.Just ("kind" Core..= kind),
("nonExistence" Core..=) Core.<$> nonExistence,
("state" Core..=) Core.<$> state
]
)
--
-- /See:/ 'newManagedZoneForwardingConfig' smart constructor.
data ManagedZoneForwardingConfig = ManagedZoneForwardingConfig
{ kind :: Core.Text,
-- | List of target name servers to forward to. Cloud DNS selects the best available name server if more than one target is given.
targetNameServers :: (Core.Maybe [ManagedZoneForwardingConfigNameServerTarget])
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZoneForwardingConfig' with the minimum fields required to make a request.
newManagedZoneForwardingConfig ::
ManagedZoneForwardingConfig
newManagedZoneForwardingConfig =
ManagedZoneForwardingConfig
{ kind =
"dns#managedZoneForwardingConfig",
targetNameServers = Core.Nothing
}
instance Core.FromJSON ManagedZoneForwardingConfig where
parseJSON =
Core.withObject
"ManagedZoneForwardingConfig"
( \o ->
ManagedZoneForwardingConfig
Core.<$> (o Core..:? "kind" Core..!= "dns#managedZoneForwardingConfig")
Core.<*> (o Core..:? "targetNameServers")
)
instance Core.ToJSON ManagedZoneForwardingConfig where
toJSON ManagedZoneForwardingConfig {..} =
Core.object
( Core.catMaybes
[ Core.Just ("kind" Core..= kind),
("targetNameServers" Core..=) Core.<$> targetNameServers
]
)
--
-- /See:/ 'newManagedZoneForwardingConfigNameServerTarget' smart constructor.
data ManagedZoneForwardingConfigNameServerTarget = ManagedZoneForwardingConfigNameServerTarget
{ -- | Forwarding path for this NameServerTarget. If unset or set to DEFAULT, Cloud DNS makes forwarding decisions based on IP address ranges; that is, RFC1918 addresses go to the VPC network, non-RFC1918 addresses go to the internet. When set to PRIVATE, Cloud DNS always sends queries through the VPC network for this target.
forwardingPath ::
( Core.Maybe
ManagedZoneForwardingConfigNameServerTarget_ForwardingPath
),
-- | IPv4 address of a target name server.
ipv4Address :: (Core.Maybe Core.Text),
kind :: Core.Text
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZoneForwardingConfigNameServerTarget' with the minimum fields required to make a request.
newManagedZoneForwardingConfigNameServerTarget ::
ManagedZoneForwardingConfigNameServerTarget
newManagedZoneForwardingConfigNameServerTarget =
ManagedZoneForwardingConfigNameServerTarget
{ forwardingPath =
Core.Nothing,
ipv4Address = Core.Nothing,
kind =
"dns#managedZoneForwardingConfigNameServerTarget"
}
instance Core.FromJSON ManagedZoneForwardingConfigNameServerTarget where
parseJSON =
Core.withObject
"ManagedZoneForwardingConfigNameServerTarget"
( \o ->
ManagedZoneForwardingConfigNameServerTarget
Core.<$> (o Core..:? "forwardingPath")
Core.<*> (o Core..:? "ipv4Address")
Core.<*> ( o
Core..:? "kind"
Core..!= "dns#managedZoneForwardingConfigNameServerTarget"
)
)
instance Core.ToJSON ManagedZoneForwardingConfigNameServerTarget where
toJSON ManagedZoneForwardingConfigNameServerTarget {..} =
Core.object
( Core.catMaybes
[ ("forwardingPath" Core..=) Core.<$> forwardingPath,
("ipv4Address" Core..=) Core.<$> ipv4Address,
Core.Just ("kind" Core..= kind)
]
)
--
-- /See:/ 'newManagedZoneOperationsListResponse' smart constructor.
data ManagedZoneOperationsListResponse = ManagedZoneOperationsListResponse
{ header :: (Core.Maybe ResponseHeader),
kind :: Core.Text,
-- | The presence of this field indicates that there exist more results following your last page of results in pagination order. To fetch them, make another list request using this value as your page token. This lets you retrieve the complete contents of even very large collections one page at a time. However, if the contents of the collection change between the first and last paginated list request, the set of all elements returned are an inconsistent view of the collection. You cannot retrieve a consistent snapshot of a collection larger than the maximum page size.
nextPageToken :: (Core.Maybe Core.Text),
-- | The operation resources.
operations :: (Core.Maybe [Operation])
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZoneOperationsListResponse' with the minimum fields required to make a request.
newManagedZoneOperationsListResponse ::
ManagedZoneOperationsListResponse
newManagedZoneOperationsListResponse =
ManagedZoneOperationsListResponse
{ header = Core.Nothing,
kind = "dns#managedZoneOperationsListResponse",
nextPageToken = Core.Nothing,
operations = Core.Nothing
}
instance Core.FromJSON ManagedZoneOperationsListResponse where
parseJSON =
Core.withObject
"ManagedZoneOperationsListResponse"
( \o ->
ManagedZoneOperationsListResponse
Core.<$> (o Core..:? "header")
Core.<*> ( o
Core..:? "kind"
Core..!= "dns#managedZoneOperationsListResponse"
)
Core.<*> (o Core..:? "nextPageToken")
Core.<*> (o Core..:? "operations")
)
instance Core.ToJSON ManagedZoneOperationsListResponse where
toJSON ManagedZoneOperationsListResponse {..} =
Core.object
( Core.catMaybes
[ ("header" Core..=) Core.<$> header,
Core.Just ("kind" Core..= kind),
("nextPageToken" Core..=) Core.<$> nextPageToken,
("operations" Core..=) Core.<$> operations
]
)
--
-- /See:/ 'newManagedZonePeeringConfig' smart constructor.
data ManagedZonePeeringConfig = ManagedZonePeeringConfig
{ kind :: Core.Text,
-- | The network with which to peer.
targetNetwork :: (Core.Maybe ManagedZonePeeringConfigTargetNetwork)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZonePeeringConfig' with the minimum fields required to make a request.
newManagedZonePeeringConfig ::
ManagedZonePeeringConfig
newManagedZonePeeringConfig =
ManagedZonePeeringConfig
{ kind = "dns#managedZonePeeringConfig",
targetNetwork = Core.Nothing
}
instance Core.FromJSON ManagedZonePeeringConfig where
parseJSON =
Core.withObject
"ManagedZonePeeringConfig"
( \o ->
ManagedZonePeeringConfig
Core.<$> (o Core..:? "kind" Core..!= "dns#managedZonePeeringConfig")
Core.<*> (o Core..:? "targetNetwork")
)
instance Core.ToJSON ManagedZonePeeringConfig where
toJSON ManagedZonePeeringConfig {..} =
Core.object
( Core.catMaybes
[ Core.Just ("kind" Core..= kind),
("targetNetwork" Core..=) Core.<$> targetNetwork
]
)
--
-- /See:/ 'newManagedZonePeeringConfigTargetNetwork' smart constructor.
data ManagedZonePeeringConfigTargetNetwork = ManagedZonePeeringConfigTargetNetwork
{ -- | The time at which the zone was deactivated, in RFC 3339 date-time format. An empty string indicates that the peering connection is active. The producer network can deactivate a zone. The zone is automatically deactivated if the producer network that the zone targeted is deleted. Output only.
deactivateTime :: (Core.Maybe Core.Text),
kind :: Core.Text,
-- | The fully qualified URL of the VPC network to forward queries to. This should be formatted like https:\/\/www.googleapis.com\/compute\/v1\/projects\/{project}\/global\/networks\/{network}
networkUrl :: (Core.Maybe Core.Text)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZonePeeringConfigTargetNetwork' with the minimum fields required to make a request.
newManagedZonePeeringConfigTargetNetwork ::
ManagedZonePeeringConfigTargetNetwork
newManagedZonePeeringConfigTargetNetwork =
ManagedZonePeeringConfigTargetNetwork
{ deactivateTime =
Core.Nothing,
kind = "dns#managedZonePeeringConfigTargetNetwork",
networkUrl = Core.Nothing
}
instance Core.FromJSON ManagedZonePeeringConfigTargetNetwork where
parseJSON =
Core.withObject
"ManagedZonePeeringConfigTargetNetwork"
( \o ->
ManagedZonePeeringConfigTargetNetwork
Core.<$> (o Core..:? "deactivateTime")
Core.<*> ( o
Core..:? "kind"
Core..!= "dns#managedZonePeeringConfigTargetNetwork"
)
Core.<*> (o Core..:? "networkUrl")
)
instance Core.ToJSON ManagedZonePeeringConfigTargetNetwork where
toJSON ManagedZonePeeringConfigTargetNetwork {..} =
Core.object
( Core.catMaybes
[ ("deactivateTime" Core..=) Core.<$> deactivateTime,
Core.Just ("kind" Core..= kind),
("networkUrl" Core..=) Core.<$> networkUrl
]
)
--
-- /See:/ 'newManagedZonePrivateVisibilityConfig' smart constructor.
data ManagedZonePrivateVisibilityConfig = ManagedZonePrivateVisibilityConfig
{ -- | The list of Google Kubernetes Engine clusters that can see this zone.
gkeClusters :: (Core.Maybe [ManagedZonePrivateVisibilityConfigGKECluster]),
kind :: Core.Text,
-- | The list of VPC networks that can see this zone.
networks :: (Core.Maybe [ManagedZonePrivateVisibilityConfigNetwork])
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZonePrivateVisibilityConfig' with the minimum fields required to make a request.
newManagedZonePrivateVisibilityConfig ::
ManagedZonePrivateVisibilityConfig
newManagedZonePrivateVisibilityConfig =
ManagedZonePrivateVisibilityConfig
{ gkeClusters = Core.Nothing,
kind = "dns#managedZonePrivateVisibilityConfig",
networks = Core.Nothing
}
instance Core.FromJSON ManagedZonePrivateVisibilityConfig where
parseJSON =
Core.withObject
"ManagedZonePrivateVisibilityConfig"
( \o ->
ManagedZonePrivateVisibilityConfig
Core.<$> (o Core..:? "gkeClusters")
Core.<*> ( o
Core..:? "kind"
Core..!= "dns#managedZonePrivateVisibilityConfig"
)
Core.<*> (o Core..:? "networks")
)
instance Core.ToJSON ManagedZonePrivateVisibilityConfig where
toJSON ManagedZonePrivateVisibilityConfig {..} =
Core.object
( Core.catMaybes
[ ("gkeClusters" Core..=) Core.<$> gkeClusters,
Core.Just ("kind" Core..= kind),
("networks" Core..=) Core.<$> networks
]
)
--
-- /See:/ 'newManagedZonePrivateVisibilityConfigGKECluster' smart constructor.
data ManagedZonePrivateVisibilityConfigGKECluster = ManagedZonePrivateVisibilityConfigGKECluster
{ -- | The resource name of the cluster to bind this ManagedZone to. This should be specified in the format like: projects\//\/locations\//\/clusters\/*. This is referenced from GKE projects.locations.clusters.get API: https:\/\/cloud.google.com\/kubernetes-engine\/docs\/reference\/rest\/v1\/projects.locations.clusters\/get
gkeClusterName :: (Core.Maybe Core.Text),
kind :: Core.Text
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZonePrivateVisibilityConfigGKECluster' with the minimum fields required to make a request.
newManagedZonePrivateVisibilityConfigGKECluster ::
ManagedZonePrivateVisibilityConfigGKECluster
newManagedZonePrivateVisibilityConfigGKECluster =
ManagedZonePrivateVisibilityConfigGKECluster
{ gkeClusterName =
Core.Nothing,
kind =
"dns#managedZonePrivateVisibilityConfigGKECluster"
}
instance Core.FromJSON ManagedZonePrivateVisibilityConfigGKECluster where
parseJSON =
Core.withObject
"ManagedZonePrivateVisibilityConfigGKECluster"
( \o ->
ManagedZonePrivateVisibilityConfigGKECluster
Core.<$> (o Core..:? "gkeClusterName")
Core.<*> ( o
Core..:? "kind"
Core..!= "dns#managedZonePrivateVisibilityConfigGKECluster"
)
)
instance Core.ToJSON ManagedZonePrivateVisibilityConfigGKECluster where
toJSON ManagedZonePrivateVisibilityConfigGKECluster {..} =
Core.object
( Core.catMaybes
[ ("gkeClusterName" Core..=) Core.<$> gkeClusterName,
Core.Just ("kind" Core..= kind)
]
)
--
-- /See:/ 'newManagedZonePrivateVisibilityConfigNetwork' smart constructor.
data ManagedZonePrivateVisibilityConfigNetwork = ManagedZonePrivateVisibilityConfigNetwork
{ kind :: Core.Text,
-- | The fully qualified URL of the VPC network to bind to. Format this URL like https:\/\/www.googleapis.com\/compute\/v1\/projects\/{project}\/global\/networks\/{network}
networkUrl :: (Core.Maybe Core.Text)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZonePrivateVisibilityConfigNetwork' with the minimum fields required to make a request.
newManagedZonePrivateVisibilityConfigNetwork ::
ManagedZonePrivateVisibilityConfigNetwork
newManagedZonePrivateVisibilityConfigNetwork =
ManagedZonePrivateVisibilityConfigNetwork
{ kind =
"dns#managedZonePrivateVisibilityConfigNetwork",
networkUrl = Core.Nothing
}
instance Core.FromJSON ManagedZonePrivateVisibilityConfigNetwork where
parseJSON =
Core.withObject
"ManagedZonePrivateVisibilityConfigNetwork"
( \o ->
ManagedZonePrivateVisibilityConfigNetwork
Core.<$> ( o
Core..:? "kind"
Core..!= "dns#managedZonePrivateVisibilityConfigNetwork"
)
Core.<*> (o Core..:? "networkUrl")
)
instance Core.ToJSON ManagedZonePrivateVisibilityConfigNetwork where
toJSON ManagedZonePrivateVisibilityConfigNetwork {..} =
Core.object
( Core.catMaybes
[ Core.Just ("kind" Core..= kind),
("networkUrl" Core..=) Core.<$> networkUrl
]
)
--
-- /See:/ 'newManagedZoneReverseLookupConfig' smart constructor.
newtype ManagedZoneReverseLookupConfig = ManagedZoneReverseLookupConfig
{ kind :: Core.Text
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZoneReverseLookupConfig' with the minimum fields required to make a request.
newManagedZoneReverseLookupConfig ::
ManagedZoneReverseLookupConfig
newManagedZoneReverseLookupConfig =
ManagedZoneReverseLookupConfig
{ kind =
"dns#managedZoneReverseLookupConfig"
}
instance Core.FromJSON ManagedZoneReverseLookupConfig where
parseJSON =
Core.withObject
"ManagedZoneReverseLookupConfig"
( \o ->
ManagedZoneReverseLookupConfig
Core.<$> (o Core..:? "kind" Core..!= "dns#managedZoneReverseLookupConfig")
)
instance Core.ToJSON ManagedZoneReverseLookupConfig where
toJSON ManagedZoneReverseLookupConfig {..} =
Core.object (Core.catMaybes [Core.Just ("kind" Core..= kind)])
-- | Contains information about Service Directory-backed zones.
--
-- /See:/ 'newManagedZoneServiceDirectoryConfig' smart constructor.
data ManagedZoneServiceDirectoryConfig = ManagedZoneServiceDirectoryConfig
{ kind :: Core.Text,
-- | Contains information about the namespace associated with the zone.
namespace :: (Core.Maybe ManagedZoneServiceDirectoryConfigNamespace)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZoneServiceDirectoryConfig' with the minimum fields required to make a request.
newManagedZoneServiceDirectoryConfig ::
ManagedZoneServiceDirectoryConfig
newManagedZoneServiceDirectoryConfig =
ManagedZoneServiceDirectoryConfig
{ kind =
"dns#managedZoneServiceDirectoryConfig",
namespace = Core.Nothing
}
instance Core.FromJSON ManagedZoneServiceDirectoryConfig where
parseJSON =
Core.withObject
"ManagedZoneServiceDirectoryConfig"
( \o ->
ManagedZoneServiceDirectoryConfig
Core.<$> ( o
Core..:? "kind"
Core..!= "dns#managedZoneServiceDirectoryConfig"
)
Core.<*> (o Core..:? "namespace")
)
instance Core.ToJSON ManagedZoneServiceDirectoryConfig where
toJSON ManagedZoneServiceDirectoryConfig {..} =
Core.object
( Core.catMaybes
[ Core.Just ("kind" Core..= kind),
("namespace" Core..=) Core.<$> namespace
]
)
--
-- /See:/ 'newManagedZoneServiceDirectoryConfigNamespace' smart constructor.
data ManagedZoneServiceDirectoryConfigNamespace = ManagedZoneServiceDirectoryConfigNamespace
{ -- | The time that the namespace backing this zone was deleted; an empty string if it still exists. This is in RFC3339 text format. Output only.
deletionTime :: (Core.Maybe Core.Text),
kind :: Core.Text,
-- | The fully qualified URL of the namespace associated with the zone. Format must be https:\/\/servicedirectory.googleapis.com\/v1\/projects\/{project}\/locations\/{location}\/namespaces\/{namespace}
namespaceUrl :: (Core.Maybe Core.Text)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZoneServiceDirectoryConfigNamespace' with the minimum fields required to make a request.
newManagedZoneServiceDirectoryConfigNamespace ::
ManagedZoneServiceDirectoryConfigNamespace
newManagedZoneServiceDirectoryConfigNamespace =
ManagedZoneServiceDirectoryConfigNamespace
{ deletionTime =
Core.Nothing,
kind =
"dns#managedZoneServiceDirectoryConfigNamespace",
namespaceUrl = Core.Nothing
}
instance Core.FromJSON ManagedZoneServiceDirectoryConfigNamespace where
parseJSON =
Core.withObject
"ManagedZoneServiceDirectoryConfigNamespace"
( \o ->
ManagedZoneServiceDirectoryConfigNamespace
Core.<$> (o Core..:? "deletionTime")
Core.<*> ( o
Core..:? "kind"
Core..!= "dns#managedZoneServiceDirectoryConfigNamespace"
)
Core.<*> (o Core..:? "namespaceUrl")
)
instance Core.ToJSON ManagedZoneServiceDirectoryConfigNamespace where
toJSON ManagedZoneServiceDirectoryConfigNamespace {..} =
Core.object
( Core.catMaybes
[ ("deletionTime" Core..=) Core.<$> deletionTime,
Core.Just ("kind" Core..= kind),
("namespaceUrl" Core..=) Core.<$> namespaceUrl
]
)
--
-- /See:/ 'newManagedZonesListResponse' smart constructor.
data ManagedZonesListResponse = ManagedZonesListResponse
{ header :: (Core.Maybe ResponseHeader),
-- | Type of resource.
kind :: Core.Text,
-- | The managed zone resources.
managedZones :: (Core.Maybe [ManagedZone]),
-- | The presence of this field indicates that there exist more results following your last page of results in pagination order. To fetch them, make another list request using this value as your page token. This lets you the complete contents of even very large collections one page at a time. However, if the contents of the collection change between the first and last paginated list request, the set of all elements returned are an inconsistent view of the collection. You cannot retrieve a consistent snapshot of a collection larger than the maximum page size.
nextPageToken :: (Core.Maybe Core.Text)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ManagedZonesListResponse' with the minimum fields required to make a request.
newManagedZonesListResponse ::
ManagedZonesListResponse
newManagedZonesListResponse =
ManagedZonesListResponse
{ header = Core.Nothing,
kind = "dns#managedZonesListResponse",
managedZones = Core.Nothing,
nextPageToken = Core.Nothing
}
instance Core.FromJSON ManagedZonesListResponse where
parseJSON =
Core.withObject
"ManagedZonesListResponse"
( \o ->
ManagedZonesListResponse
Core.<$> (o Core..:? "header")
Core.<*> (o Core..:? "kind" Core..!= "dns#managedZonesListResponse")
Core.<*> (o Core..:? "managedZones")
Core.<*> (o Core..:? "nextPageToken")
)
instance Core.ToJSON ManagedZonesListResponse where
toJSON ManagedZonesListResponse {..} =
Core.object
( Core.catMaybes
[ ("header" Core..=) Core.<$> header,
Core.Just ("kind" Core..= kind),
("managedZones" Core..=) Core.<$> managedZones,
("nextPageToken" Core..=) Core.<$> nextPageToken
]
)
-- | An operation represents a successful mutation performed on a Cloud DNS resource. Operations provide: - An audit log of server resource mutations. - A way to recover\/retry API calls in the case where the response is never received by the caller. Use the caller specified client/operation/id.
--
-- /See:/ 'newOperation' smart constructor.
data Operation = Operation
{ -- | Only populated if the operation targeted a DnsKey (output only).
dnsKeyContext :: (Core.Maybe OperationDnsKeyContext),
-- | Unique identifier for the resource. This is the client/operation/id if the client specified it when the mutation was initiated, otherwise, it is generated by the server. The name must be 1-63 characters long and match the regular expression [-a-z0-9]? (output only)
id :: (Core.Maybe Core.Text),
kind :: Core.Text,
-- | The time that this operation was started by the server. This is in RFC3339 text format (output only).
startTime :: (Core.Maybe Core.Text),
-- | Status of the operation. Can be one of the following: \"PENDING\" or \"DONE\" (output only). A status of \"DONE\" means that the request to update the authoritative servers has been sent, but the servers might not be updated yet.
status :: (Core.Maybe Operation_Status),
-- | Type of the operation. Operations include insert, update, and delete (output only).
type' :: (Core.Maybe Core.Text),
-- | User who requested the operation, for example: user\@example.com. cloud-dns-system for operations automatically done by the system. (output only)
user :: (Core.Maybe Core.Text),
-- | Only populated if the operation targeted a ManagedZone (output only).
zoneContext :: (Core.Maybe OperationManagedZoneContext)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'Operation' with the minimum fields required to make a request.
newOperation ::
Operation
newOperation =
Operation
{ dnsKeyContext = Core.Nothing,
id = Core.Nothing,
kind = "dns#operation",
startTime = Core.Nothing,
status = Core.Nothing,
type' = Core.Nothing,
user = Core.Nothing,
zoneContext = Core.Nothing
}
instance Core.FromJSON Operation where
parseJSON =
Core.withObject
"Operation"
( \o ->
Operation
Core.<$> (o Core..:? "dnsKeyContext")
Core.<*> (o Core..:? "id")
Core.<*> (o Core..:? "kind" Core..!= "dns#operation")
Core.<*> (o Core..:? "startTime")
Core.<*> (o Core..:? "status")
Core.<*> (o Core..:? "type")
Core.<*> (o Core..:? "user")
Core.<*> (o Core..:? "zoneContext")
)
instance Core.ToJSON Operation where
toJSON Operation {..} =
Core.object
( Core.catMaybes
[ ("dnsKeyContext" Core..=) Core.<$> dnsKeyContext,
("id" Core..=) Core.<$> id,
Core.Just ("kind" Core..= kind),
("startTime" Core..=) Core.<$> startTime,
("status" Core..=) Core.<$> status,
("type" Core..=) Core.<$> type',
("user" Core..=) Core.<$> user,
("zoneContext" Core..=) Core.<$> zoneContext
]
)
--
-- /See:/ 'newOperationDnsKeyContext' smart constructor.
data OperationDnsKeyContext = OperationDnsKeyContext
{ -- | The post-operation DnsKey resource.
newValue' :: (Core.Maybe DnsKey),
-- | The pre-operation DnsKey resource.
oldValue :: (Core.Maybe DnsKey)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'OperationDnsKeyContext' with the minimum fields required to make a request.
newOperationDnsKeyContext ::
OperationDnsKeyContext
newOperationDnsKeyContext =
OperationDnsKeyContext
{ newValue' = Core.Nothing,
oldValue = Core.Nothing
}
instance Core.FromJSON OperationDnsKeyContext where
parseJSON =
Core.withObject
"OperationDnsKeyContext"
( \o ->
OperationDnsKeyContext
Core.<$> (o Core..:? "newValue")
Core.<*> (o Core..:? "oldValue")
)
instance Core.ToJSON OperationDnsKeyContext where
toJSON OperationDnsKeyContext {..} =
Core.object
( Core.catMaybes
[ ("newValue" Core..=) Core.<$> newValue',
("oldValue" Core..=) Core.<$> oldValue
]
)
--
-- /See:/ 'newOperationManagedZoneContext' smart constructor.
data OperationManagedZoneContext = OperationManagedZoneContext
{ -- | The post-operation ManagedZone resource.
newValue' :: (Core.Maybe ManagedZone),
-- | The pre-operation ManagedZone resource.
oldValue :: (Core.Maybe ManagedZone)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'OperationManagedZoneContext' with the minimum fields required to make a request.
newOperationManagedZoneContext ::
OperationManagedZoneContext
newOperationManagedZoneContext =
OperationManagedZoneContext
{ newValue' = Core.Nothing,
oldValue = Core.Nothing
}
instance Core.FromJSON OperationManagedZoneContext where
parseJSON =
Core.withObject
"OperationManagedZoneContext"
( \o ->
OperationManagedZoneContext
Core.<$> (o Core..:? "newValue")
Core.<*> (o Core..:? "oldValue")
)
instance Core.ToJSON OperationManagedZoneContext where
toJSON OperationManagedZoneContext {..} =
Core.object
( Core.catMaybes
[ ("newValue" Core..=) Core.<$> newValue',
("oldValue" Core..=) Core.<$> oldValue
]
)
--
-- /See:/ 'newPoliciesListResponse' smart constructor.
data PoliciesListResponse = PoliciesListResponse
{ header :: (Core.Maybe ResponseHeader),
-- | Type of resource.
kind :: Core.Text,
-- | The presence of this field indicates that there exist more results following your last page of results in pagination order. To fetch them, make another list request using this value as your page token. This lets you the complete contents of even very large collections one page at a time. However, if the contents of the collection change between the first and last paginated list request, the set of all elements returned are an inconsistent view of the collection. You cannot retrieve a consistent snapshot of a collection larger than the maximum page size.
nextPageToken :: (Core.Maybe Core.Text),
-- | The policy resources.
policies :: (Core.Maybe [Policy])
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'PoliciesListResponse' with the minimum fields required to make a request.
newPoliciesListResponse ::
PoliciesListResponse
newPoliciesListResponse =
PoliciesListResponse
{ header = Core.Nothing,
kind = "dns#policiesListResponse",
nextPageToken = Core.Nothing,
policies = Core.Nothing
}
instance Core.FromJSON PoliciesListResponse where
parseJSON =
Core.withObject
"PoliciesListResponse"
( \o ->
PoliciesListResponse
Core.<$> (o Core..:? "header")
Core.<*> (o Core..:? "kind" Core..!= "dns#policiesListResponse")
Core.<*> (o Core..:? "nextPageToken")
Core.<*> (o Core..:? "policies")
)
instance Core.ToJSON PoliciesListResponse where
toJSON PoliciesListResponse {..} =
Core.object
( Core.catMaybes
[ ("header" Core..=) Core.<$> header,
Core.Just ("kind" Core..= kind),
("nextPageToken" Core..=) Core.<$> nextPageToken,
("policies" Core..=) Core.<$> policies
]
)
--
-- /See:/ 'newPoliciesPatchResponse' smart constructor.
data PoliciesPatchResponse = PoliciesPatchResponse
{ header :: (Core.Maybe ResponseHeader),
policy :: (Core.Maybe Policy)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'PoliciesPatchResponse' with the minimum fields required to make a request.
newPoliciesPatchResponse ::
PoliciesPatchResponse
newPoliciesPatchResponse =
PoliciesPatchResponse
{ header = Core.Nothing,
policy = Core.Nothing
}
instance Core.FromJSON PoliciesPatchResponse where
parseJSON =
Core.withObject
"PoliciesPatchResponse"
( \o ->
PoliciesPatchResponse
Core.<$> (o Core..:? "header")
Core.<*> (o Core..:? "policy")
)
instance Core.ToJSON PoliciesPatchResponse where
toJSON PoliciesPatchResponse {..} =
Core.object
( Core.catMaybes
[ ("header" Core..=) Core.<$> header,
("policy" Core..=) Core.<$> policy
]
)
--
-- /See:/ 'newPoliciesUpdateResponse' smart constructor.
data PoliciesUpdateResponse = PoliciesUpdateResponse
{ header :: (Core.Maybe ResponseHeader),
policy :: (Core.Maybe Policy)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'PoliciesUpdateResponse' with the minimum fields required to make a request.
newPoliciesUpdateResponse ::
PoliciesUpdateResponse
newPoliciesUpdateResponse =
PoliciesUpdateResponse
{ header = Core.Nothing,
policy = Core.Nothing
}
instance Core.FromJSON PoliciesUpdateResponse where
parseJSON =
Core.withObject
"PoliciesUpdateResponse"
( \o ->
PoliciesUpdateResponse
Core.<$> (o Core..:? "header")
Core.<*> (o Core..:? "policy")
)
instance Core.ToJSON PoliciesUpdateResponse where
toJSON PoliciesUpdateResponse {..} =
Core.object
( Core.catMaybes
[ ("header" Core..=) Core.<$> header,
("policy" Core..=) Core.<$> policy
]
)
-- | A policy is a collection of DNS rules applied to one or more Virtual Private Cloud resources.
--
-- /See:/ 'newPolicy' smart constructor.
data Policy = Policy
{ -- | Sets an alternative name server for the associated networks. When specified, all DNS queries are forwarded to a name server that you choose. Names such as .internal are not available when an alternative name server is specified.
alternativeNameServerConfig :: (Core.Maybe PolicyAlternativeNameServerConfig),
-- | A mutable string of at most 1024 characters associated with this resource for the user\'s convenience. Has no effect on the policy\'s function.
description :: (Core.Maybe Core.Text),
-- | Allows networks bound to this policy to receive DNS queries sent by VMs or applications over VPN connections. When enabled, a virtual IP address is allocated from each of the subnetworks that are bound to this policy.
enableInboundForwarding :: (Core.Maybe Core.Bool),
-- | Controls whether logging is enabled for the networks bound to this policy. Defaults to no logging if not set.
enableLogging :: (Core.Maybe Core.Bool),
-- | Unique identifier for the resource; defined by the server (output only).
id :: (Core.Maybe Core.Word64),
kind :: Core.Text,
-- | User-assigned name for this policy.
name :: (Core.Maybe Core.Text),
-- | List of network names specifying networks to which this policy is applied.
networks :: (Core.Maybe [PolicyNetwork])
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'Policy' with the minimum fields required to make a request.
newPolicy ::
Policy
newPolicy =
Policy
{ alternativeNameServerConfig = Core.Nothing,
description = Core.Nothing,
enableInboundForwarding = Core.Nothing,
enableLogging = Core.Nothing,
id = Core.Nothing,
kind = "dns#policy",
name = Core.Nothing,
networks = Core.Nothing
}
instance Core.FromJSON Policy where
parseJSON =
Core.withObject
"Policy"
( \o ->
Policy
Core.<$> (o Core..:? "alternativeNameServerConfig")
Core.<*> (o Core..:? "description")
Core.<*> (o Core..:? "enableInboundForwarding")
Core.<*> (o Core..:? "enableLogging")
Core.<*> (o Core..:? "id" Core.<&> Core.fmap Core.fromAsText)
Core.<*> (o Core..:? "kind" Core..!= "dns#policy")
Core.<*> (o Core..:? "name")
Core.<*> (o Core..:? "networks")
)
instance Core.ToJSON Policy where
toJSON Policy {..} =
Core.object
( Core.catMaybes
[ ("alternativeNameServerConfig" Core..=)
Core.<$> alternativeNameServerConfig,
("description" Core..=) Core.<$> description,
("enableInboundForwarding" Core..=)
Core.<$> enableInboundForwarding,
("enableLogging" Core..=) Core.<$> enableLogging,
("id" Core..=) Core.. Core.AsText Core.<$> id,
Core.Just ("kind" Core..= kind),
("name" Core..=) Core.<$> name,
("networks" Core..=) Core.<$> networks
]
)
--
-- /See:/ 'newPolicyAlternativeNameServerConfig' smart constructor.
data PolicyAlternativeNameServerConfig = PolicyAlternativeNameServerConfig
{ kind :: Core.Text,
-- | Sets an alternative name server for the associated networks. When specified, all DNS queries are forwarded to a name server that you choose. Names such as .internal are not available when an alternative name server is specified.
targetNameServers :: (Core.Maybe [PolicyAlternativeNameServerConfigTargetNameServer])
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'PolicyAlternativeNameServerConfig' with the minimum fields required to make a request.
newPolicyAlternativeNameServerConfig ::
PolicyAlternativeNameServerConfig
newPolicyAlternativeNameServerConfig =
PolicyAlternativeNameServerConfig
{ kind =
"dns#policyAlternativeNameServerConfig",
targetNameServers = Core.Nothing
}
instance Core.FromJSON PolicyAlternativeNameServerConfig where
parseJSON =
Core.withObject
"PolicyAlternativeNameServerConfig"
( \o ->
PolicyAlternativeNameServerConfig
Core.<$> ( o
Core..:? "kind"
Core..!= "dns#policyAlternativeNameServerConfig"
)
Core.<*> (o Core..:? "targetNameServers")
)
instance Core.ToJSON PolicyAlternativeNameServerConfig where
toJSON PolicyAlternativeNameServerConfig {..} =
Core.object
( Core.catMaybes
[ Core.Just ("kind" Core..= kind),
("targetNameServers" Core..=) Core.<$> targetNameServers
]
)
--
-- /See:/ 'newPolicyAlternativeNameServerConfigTargetNameServer' smart constructor.
data PolicyAlternativeNameServerConfigTargetNameServer = PolicyAlternativeNameServerConfigTargetNameServer
{ -- | Forwarding path for this TargetNameServer. If unset or set to DEFAULT, Cloud DNS makes forwarding decisions based on address ranges; that is, RFC1918 addresses go to the VPC network, non-RFC1918 addresses go to the internet. When set to PRIVATE, Cloud DNS always sends queries through the VPC network for this target.
forwardingPath ::
( Core.Maybe
PolicyAlternativeNameServerConfigTargetNameServer_ForwardingPath
),
-- | IPv4 address to forward to.
ipv4Address :: (Core.Maybe Core.Text),
kind :: Core.Text
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'PolicyAlternativeNameServerConfigTargetNameServer' with the minimum fields required to make a request.
newPolicyAlternativeNameServerConfigTargetNameServer ::
PolicyAlternativeNameServerConfigTargetNameServer
newPolicyAlternativeNameServerConfigTargetNameServer =
PolicyAlternativeNameServerConfigTargetNameServer
{ forwardingPath =
Core.Nothing,
ipv4Address = Core.Nothing,
kind =
"dns#policyAlternativeNameServerConfigTargetNameServer"
}
instance
Core.FromJSON
PolicyAlternativeNameServerConfigTargetNameServer
where
parseJSON =
Core.withObject
"PolicyAlternativeNameServerConfigTargetNameServer"
( \o ->
PolicyAlternativeNameServerConfigTargetNameServer
Core.<$> (o Core..:? "forwardingPath")
Core.<*> (o Core..:? "ipv4Address")
Core.<*> ( o
Core..:? "kind"
Core..!= "dns#policyAlternativeNameServerConfigTargetNameServer"
)
)
instance
Core.ToJSON
PolicyAlternativeNameServerConfigTargetNameServer
where
toJSON PolicyAlternativeNameServerConfigTargetNameServer {..} =
Core.object
( Core.catMaybes
[ ("forwardingPath" Core..=) Core.<$> forwardingPath,
("ipv4Address" Core..=) Core.<$> ipv4Address,
Core.Just ("kind" Core..= kind)
]
)
--
-- /See:/ 'newPolicyNetwork' smart constructor.
data PolicyNetwork = PolicyNetwork
{ kind :: Core.Text,
-- | The fully qualified URL of the VPC network to bind to. This should be formatted like https:\/\/www.googleapis.com\/compute\/v1\/projects\/{project}\/global\/networks\/{network}
networkUrl :: (Core.Maybe Core.Text)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'PolicyNetwork' with the minimum fields required to make a request.
newPolicyNetwork ::
PolicyNetwork
newPolicyNetwork =
PolicyNetwork
{ kind = "dns#policyNetwork",
networkUrl = Core.Nothing
}
instance Core.FromJSON PolicyNetwork where
parseJSON =
Core.withObject
"PolicyNetwork"
( \o ->
PolicyNetwork
Core.<$> (o Core..:? "kind" Core..!= "dns#policyNetwork")
Core.<*> (o Core..:? "networkUrl")
)
instance Core.ToJSON PolicyNetwork where
toJSON PolicyNetwork {..} =
Core.object
( Core.catMaybes
[ Core.Just ("kind" Core..= kind),
("networkUrl" Core..=) Core.<$> networkUrl
]
)
-- | A project resource. The project is a top level container for resources including Cloud DNS ManagedZones. Projects can be created only in the APIs console. Next tag: 7.
--
-- /See:/ 'newProject' smart constructor.
data Project = Project
{ -- | User assigned unique identifier for the resource (output only).
id :: (Core.Maybe Core.Text),
kind :: Core.Text,
-- | Unique numeric identifier for the resource; defined by the server (output only).
number :: (Core.Maybe Core.Word64),
-- | Quotas assigned to this project (output only).
quota :: (Core.Maybe Quota)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'Project' with the minimum fields required to make a request.
newProject ::
Project
newProject =
Project
{ id = Core.Nothing,
kind = "dns#project",
number = Core.Nothing,
quota = Core.Nothing
}
instance Core.FromJSON Project where
parseJSON =
Core.withObject
"Project"
( \o ->
Project
Core.<$> (o Core..:? "id")
Core.<*> (o Core..:? "kind" Core..!= "dns#project")
Core.<*> (o Core..:? "number" Core.<&> Core.fmap Core.fromAsText)
Core.<*> (o Core..:? "quota")
)
instance Core.ToJSON Project where
toJSON Project {..} =
Core.object
( Core.catMaybes
[ ("id" Core..=) Core.<$> id,
Core.Just ("kind" Core..= kind),
("number" Core..=) Core.. Core.AsText Core.<$> number,
("quota" Core..=) Core.<$> quota
]
)
-- | Limits associated with a Project.
--
-- /See:/ 'newQuota' smart constructor.
data Quota = Quota
{ -- | Maximum allowed number of DnsKeys per ManagedZone.
dnsKeysPerManagedZone :: (Core.Maybe Core.Int32),
-- | Maximum allowed number of items per routing policy.
itemsPerRoutingPolicy :: (Core.Maybe Core.Int32),
kind :: Core.Text,
-- | Maximum allowed number of managed zones in the project.
managedZones :: (Core.Maybe Core.Int32),
-- | Maximum allowed number of managed zones which can be attached to a network.
managedZonesPerNetwork :: (Core.Maybe Core.Int32),
-- | Maximum allowed number of networks to which a privately scoped zone can be attached.
networksPerManagedZone :: (Core.Maybe Core.Int32),
-- | Maximum allowed number of networks per policy.
networksPerPolicy :: (Core.Maybe Core.Int32),
-- | Maximum allowed number of consumer peering zones per target network owned by this producer project
peeringZonesPerTargetNetwork :: (Core.Maybe Core.Int32),
-- | Maximum allowed number of policies per project.
policies :: (Core.Maybe Core.Int32),
-- | Maximum allowed number of ResourceRecords per ResourceRecordSet.
resourceRecordsPerRrset :: (Core.Maybe Core.Int32),
-- | Maximum allowed number of ResourceRecordSets to add per ChangesCreateRequest.
rrsetAdditionsPerChange :: (Core.Maybe Core.Int32),
-- | Maximum allowed number of ResourceRecordSets to delete per ChangesCreateRequest.
rrsetDeletionsPerChange :: (Core.Maybe Core.Int32),
-- | Maximum allowed number of ResourceRecordSets per zone in the project.
rrsetsPerManagedZone :: (Core.Maybe Core.Int32),
-- | Maximum allowed number of target name servers per managed forwarding zone.
targetNameServersPerManagedZone :: (Core.Maybe Core.Int32),
-- | Maximum allowed number of alternative target name servers per policy.
targetNameServersPerPolicy :: (Core.Maybe Core.Int32),
-- | Maximum allowed size for total rrdata in one ChangesCreateRequest in bytes.
totalRrdataSizePerChange :: (Core.Maybe Core.Int32),
-- | DNSSEC algorithm and key length types that can be used for DnsKeys.
whitelistedKeySpecs :: (Core.Maybe [DnsKeySpec])
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'Quota' with the minimum fields required to make a request.
newQuota ::
Quota
newQuota =
Quota
{ dnsKeysPerManagedZone = Core.Nothing,
itemsPerRoutingPolicy = Core.Nothing,
kind = "dns#quota",
managedZones = Core.Nothing,
managedZonesPerNetwork = Core.Nothing,
networksPerManagedZone = Core.Nothing,
networksPerPolicy = Core.Nothing,
peeringZonesPerTargetNetwork = Core.Nothing,
policies = Core.Nothing,
resourceRecordsPerRrset = Core.Nothing,
rrsetAdditionsPerChange = Core.Nothing,
rrsetDeletionsPerChange = Core.Nothing,
rrsetsPerManagedZone = Core.Nothing,
targetNameServersPerManagedZone = Core.Nothing,
targetNameServersPerPolicy = Core.Nothing,
totalRrdataSizePerChange = Core.Nothing,
whitelistedKeySpecs = Core.Nothing
}
instance Core.FromJSON Quota where
parseJSON =
Core.withObject
"Quota"
( \o ->
Quota
Core.<$> (o Core..:? "dnsKeysPerManagedZone")
Core.<*> (o Core..:? "itemsPerRoutingPolicy")
Core.<*> (o Core..:? "kind" Core..!= "dns#quota")
Core.<*> (o Core..:? "managedZones")
Core.<*> (o Core..:? "managedZonesPerNetwork")
Core.<*> (o Core..:? "networksPerManagedZone")
Core.<*> (o Core..:? "networksPerPolicy")
Core.<*> (o Core..:? "peeringZonesPerTargetNetwork")
Core.<*> (o Core..:? "policies")
Core.<*> (o Core..:? "resourceRecordsPerRrset")
Core.<*> (o Core..:? "rrsetAdditionsPerChange")
Core.<*> (o Core..:? "rrsetDeletionsPerChange")
Core.<*> (o Core..:? "rrsetsPerManagedZone")
Core.<*> (o Core..:? "targetNameServersPerManagedZone")
Core.<*> (o Core..:? "targetNameServersPerPolicy")
Core.<*> (o Core..:? "totalRrdataSizePerChange")
Core.<*> (o Core..:? "whitelistedKeySpecs")
)
instance Core.ToJSON Quota where
toJSON Quota {..} =
Core.object
( Core.catMaybes
[ ("dnsKeysPerManagedZone" Core..=) Core.<$> dnsKeysPerManagedZone,
("itemsPerRoutingPolicy" Core..=) Core.<$> itemsPerRoutingPolicy,
Core.Just ("kind" Core..= kind),
("managedZones" Core..=) Core.<$> managedZones,
("managedZonesPerNetwork" Core..=) Core.<$> managedZonesPerNetwork,
("networksPerManagedZone" Core..=) Core.<$> networksPerManagedZone,
("networksPerPolicy" Core..=) Core.<$> networksPerPolicy,
("peeringZonesPerTargetNetwork" Core..=)
Core.<$> peeringZonesPerTargetNetwork,
("policies" Core..=) Core.<$> policies,
("resourceRecordsPerRrset" Core..=)
Core.<$> resourceRecordsPerRrset,
("rrsetAdditionsPerChange" Core..=)
Core.<$> rrsetAdditionsPerChange,
("rrsetDeletionsPerChange" Core..=)
Core.<$> rrsetDeletionsPerChange,
("rrsetsPerManagedZone" Core..=) Core.<$> rrsetsPerManagedZone,
("targetNameServersPerManagedZone" Core..=)
Core.<$> targetNameServersPerManagedZone,
("targetNameServersPerPolicy" Core..=)
Core.<$> targetNameServersPerPolicy,
("totalRrdataSizePerChange" Core..=)
Core.<$> totalRrdataSizePerChange,
("whitelistedKeySpecs" Core..=) Core.<$> whitelistedKeySpecs
]
)
-- | A RRSetRoutingPolicy represents ResourceRecordSet data that is returned dynamically with the response varying based on configured properties such as geolocation or by weighted random selection.
--
-- /See:/ 'newRRSetRoutingPolicy' smart constructor.
data RRSetRoutingPolicy = RRSetRoutingPolicy
{ geo :: (Core.Maybe RRSetRoutingPolicyGeoPolicy),
kind :: Core.Text,
wrr :: (Core.Maybe RRSetRoutingPolicyWrrPolicy)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'RRSetRoutingPolicy' with the minimum fields required to make a request.
newRRSetRoutingPolicy ::
RRSetRoutingPolicy
newRRSetRoutingPolicy =
RRSetRoutingPolicy
{ geo = Core.Nothing,
kind = "dns#rRSetRoutingPolicy",
wrr = Core.Nothing
}
instance Core.FromJSON RRSetRoutingPolicy where
parseJSON =
Core.withObject
"RRSetRoutingPolicy"
( \o ->
RRSetRoutingPolicy
Core.<$> (o Core..:? "geo")
Core.<*> (o Core..:? "kind" Core..!= "dns#rRSetRoutingPolicy")
Core.<*> (o Core..:? "wrr")
)
instance Core.ToJSON RRSetRoutingPolicy where
toJSON RRSetRoutingPolicy {..} =
Core.object
( Core.catMaybes
[ ("geo" Core..=) Core.<$> geo,
Core.Just ("kind" Core..= kind),
("wrr" Core..=) Core.<$> wrr
]
)
-- | Configures a RRSetRoutingPolicy that routes based on the geo location of the querying user.
--
-- /See:/ 'newRRSetRoutingPolicyGeoPolicy' smart constructor.
data RRSetRoutingPolicyGeoPolicy = RRSetRoutingPolicyGeoPolicy
{ -- | The primary geo routing configuration. If there are multiple items with the same location, an error is returned instead.
items :: (Core.Maybe [RRSetRoutingPolicyGeoPolicyGeoPolicyItem]),
kind :: Core.Text
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'RRSetRoutingPolicyGeoPolicy' with the minimum fields required to make a request.
newRRSetRoutingPolicyGeoPolicy ::
RRSetRoutingPolicyGeoPolicy
newRRSetRoutingPolicyGeoPolicy =
RRSetRoutingPolicyGeoPolicy
{ items = Core.Nothing,
kind = "dns#rRSetRoutingPolicyGeoPolicy"
}
instance Core.FromJSON RRSetRoutingPolicyGeoPolicy where
parseJSON =
Core.withObject
"RRSetRoutingPolicyGeoPolicy"
( \o ->
RRSetRoutingPolicyGeoPolicy
Core.<$> (o Core..:? "items")
Core.<*> (o Core..:? "kind" Core..!= "dns#rRSetRoutingPolicyGeoPolicy")
)
instance Core.ToJSON RRSetRoutingPolicyGeoPolicy where
toJSON RRSetRoutingPolicyGeoPolicy {..} =
Core.object
( Core.catMaybes
[ ("items" Core..=) Core.<$> items,
Core.Just ("kind" Core..= kind)
]
)
-- | ResourceRecordSet data for one geo location.
--
-- /See:/ 'newRRSetRoutingPolicyGeoPolicyGeoPolicyItem' smart constructor.
data RRSetRoutingPolicyGeoPolicyGeoPolicyItem = RRSetRoutingPolicyGeoPolicyGeoPolicyItem
{ kind :: Core.Text,
-- | The geo-location granularity is a GCP region. This location string should correspond to a GCP region. e.g. \"us-east1\", \"southamerica-east1\", \"asia-east1\", etc.
location :: (Core.Maybe Core.Text),
rrdatas :: (Core.Maybe [Core.Text]),
-- | DNSSEC generated signatures for all the rrdata within this item. Note that if health checked targets are provided for DNSSEC enabled zones, there\'s a restriction of 1 ip per item. .
signatureRrdatas :: (Core.Maybe [Core.Text])
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'RRSetRoutingPolicyGeoPolicyGeoPolicyItem' with the minimum fields required to make a request.
newRRSetRoutingPolicyGeoPolicyGeoPolicyItem ::
RRSetRoutingPolicyGeoPolicyGeoPolicyItem
newRRSetRoutingPolicyGeoPolicyGeoPolicyItem =
RRSetRoutingPolicyGeoPolicyGeoPolicyItem
{ kind =
"dns#rRSetRoutingPolicyGeoPolicyGeoPolicyItem",
location = Core.Nothing,
rrdatas = Core.Nothing,
signatureRrdatas = Core.Nothing
}
instance Core.FromJSON RRSetRoutingPolicyGeoPolicyGeoPolicyItem where
parseJSON =
Core.withObject
"RRSetRoutingPolicyGeoPolicyGeoPolicyItem"
( \o ->
RRSetRoutingPolicyGeoPolicyGeoPolicyItem
Core.<$> ( o
Core..:? "kind"
Core..!= "dns#rRSetRoutingPolicyGeoPolicyGeoPolicyItem"
)
Core.<*> (o Core..:? "location")
Core.<*> (o Core..:? "rrdatas")
Core.<*> (o Core..:? "signatureRrdatas")
)
instance Core.ToJSON RRSetRoutingPolicyGeoPolicyGeoPolicyItem where
toJSON RRSetRoutingPolicyGeoPolicyGeoPolicyItem {..} =
Core.object
( Core.catMaybes
[ Core.Just ("kind" Core..= kind),
("location" Core..=) Core.<$> location,
("rrdatas" Core..=) Core.<$> rrdatas,
("signatureRrdatas" Core..=) Core.<$> signatureRrdatas
]
)
-- | Configures a RRSetRoutingPolicy that routes in a weighted round robin fashion.
--
-- /See:/ 'newRRSetRoutingPolicyWrrPolicy' smart constructor.
data RRSetRoutingPolicyWrrPolicy = RRSetRoutingPolicyWrrPolicy
{ items :: (Core.Maybe [RRSetRoutingPolicyWrrPolicyWrrPolicyItem]),
kind :: Core.Text
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'RRSetRoutingPolicyWrrPolicy' with the minimum fields required to make a request.
newRRSetRoutingPolicyWrrPolicy ::
RRSetRoutingPolicyWrrPolicy
newRRSetRoutingPolicyWrrPolicy =
RRSetRoutingPolicyWrrPolicy
{ items = Core.Nothing,
kind = "dns#rRSetRoutingPolicyWrrPolicy"
}
instance Core.FromJSON RRSetRoutingPolicyWrrPolicy where
parseJSON =
Core.withObject
"RRSetRoutingPolicyWrrPolicy"
( \o ->
RRSetRoutingPolicyWrrPolicy
Core.<$> (o Core..:? "items")
Core.<*> (o Core..:? "kind" Core..!= "dns#rRSetRoutingPolicyWrrPolicy")
)
instance Core.ToJSON RRSetRoutingPolicyWrrPolicy where
toJSON RRSetRoutingPolicyWrrPolicy {..} =
Core.object
( Core.catMaybes
[ ("items" Core..=) Core.<$> items,
Core.Just ("kind" Core..= kind)
]
)
-- | A routing block which contains the routing information for one WRR item.
--
-- /See:/ 'newRRSetRoutingPolicyWrrPolicyWrrPolicyItem' smart constructor.
data RRSetRoutingPolicyWrrPolicyWrrPolicyItem = RRSetRoutingPolicyWrrPolicyWrrPolicyItem
{ kind :: Core.Text,
rrdatas :: (Core.Maybe [Core.Text]),
-- | DNSSEC generated signatures for all the rrdata within this item. Note that if health checked targets are provided for DNSSEC enabled zones, there\'s a restriction of 1 ip per item. .
signatureRrdatas :: (Core.Maybe [Core.Text]),
-- | The weight corresponding to this subset of rrdata. When multiple WeightedRoundRobinPolicyItems are configured, the probability of returning an rrset is proportional to its weight relative to the sum of weights configured for all items. This weight should be non-negative.
weight :: (Core.Maybe Core.Double)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'RRSetRoutingPolicyWrrPolicyWrrPolicyItem' with the minimum fields required to make a request.
newRRSetRoutingPolicyWrrPolicyWrrPolicyItem ::
RRSetRoutingPolicyWrrPolicyWrrPolicyItem
newRRSetRoutingPolicyWrrPolicyWrrPolicyItem =
RRSetRoutingPolicyWrrPolicyWrrPolicyItem
{ kind =
"dns#rRSetRoutingPolicyWrrPolicyWrrPolicyItem",
rrdatas = Core.Nothing,
signatureRrdatas = Core.Nothing,
weight = Core.Nothing
}
instance Core.FromJSON RRSetRoutingPolicyWrrPolicyWrrPolicyItem where
parseJSON =
Core.withObject
"RRSetRoutingPolicyWrrPolicyWrrPolicyItem"
( \o ->
RRSetRoutingPolicyWrrPolicyWrrPolicyItem
Core.<$> ( o
Core..:? "kind"
Core..!= "dns#rRSetRoutingPolicyWrrPolicyWrrPolicyItem"
)
Core.<*> (o Core..:? "rrdatas")
Core.<*> (o Core..:? "signatureRrdatas")
Core.<*> (o Core..:? "weight")
)
instance Core.ToJSON RRSetRoutingPolicyWrrPolicyWrrPolicyItem where
toJSON RRSetRoutingPolicyWrrPolicyWrrPolicyItem {..} =
Core.object
( Core.catMaybes
[ Core.Just ("kind" Core..= kind),
("rrdatas" Core..=) Core.<$> rrdatas,
("signatureRrdatas" Core..=) Core.<$> signatureRrdatas,
("weight" Core..=) Core.<$> weight
]
)
-- | A unit of data that is returned by the DNS servers.
--
-- /See:/ 'newResourceRecordSet' smart constructor.
data ResourceRecordSet = ResourceRecordSet
{ kind :: Core.Text,
-- | For example, www.example.com.
name :: (Core.Maybe Core.Text),
-- | Configures dynamic query responses based on geo location of querying user or a weighted round robin based routing policy. A ResourceRecordSet should only have either rrdata (static) or routing_policy (dynamic). An error is returned otherwise.
routingPolicy :: (Core.Maybe RRSetRoutingPolicy),
-- | As defined in RFC 1035 (section 5) and RFC 1034 (section 3.6.1) -- see examples.
rrdatas :: (Core.Maybe [Core.Text]),
-- | As defined in RFC 4034 (section 3.2).
signatureRrdatas :: (Core.Maybe [Core.Text]),
-- | Number of seconds that this ResourceRecordSet can be cached by resolvers.
ttl :: (Core.Maybe Core.Int32),
-- | The identifier of a supported record type. See the list of Supported DNS record types.
type' :: (Core.Maybe Core.Text)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ResourceRecordSet' with the minimum fields required to make a request.
newResourceRecordSet ::
ResourceRecordSet
newResourceRecordSet =
ResourceRecordSet
{ kind = "dns#resourceRecordSet",
name = Core.Nothing,
routingPolicy = Core.Nothing,
rrdatas = Core.Nothing,
signatureRrdatas = Core.Nothing,
ttl = Core.Nothing,
type' = Core.Nothing
}
instance Core.FromJSON ResourceRecordSet where
parseJSON =
Core.withObject
"ResourceRecordSet"
( \o ->
ResourceRecordSet
Core.<$> (o Core..:? "kind" Core..!= "dns#resourceRecordSet")
Core.<*> (o Core..:? "name")
Core.<*> (o Core..:? "routingPolicy")
Core.<*> (o Core..:? "rrdatas")
Core.<*> (o Core..:? "signatureRrdatas")
Core.<*> (o Core..:? "ttl")
Core.<*> (o Core..:? "type")
)
instance Core.ToJSON ResourceRecordSet where
toJSON ResourceRecordSet {..} =
Core.object
( Core.catMaybes
[ Core.Just ("kind" Core..= kind),
("name" Core..=) Core.<$> name,
("routingPolicy" Core..=) Core.<$> routingPolicy,
("rrdatas" Core..=) Core.<$> rrdatas,
("signatureRrdatas" Core..=) Core.<$> signatureRrdatas,
("ttl" Core..=) Core.<$> ttl,
("type" Core..=) Core.<$> type'
]
)
--
-- /See:/ 'newResourceRecordSetsListResponse' smart constructor.
data ResourceRecordSetsListResponse = ResourceRecordSetsListResponse
{ header :: (Core.Maybe ResponseHeader),
-- | Type of resource.
kind :: Core.Text,
-- | The presence of this field indicates that there exist more results following your last page of results in pagination order. To fetch them, make another list request using this value as your pagination token. This lets you retrieve complete contents of even larger collections, one page at a time. However, if the contents of the collection change between the first and last paginated list request, the set of elements returned are an inconsistent view of the collection. You cannot retrieve a consistent snapshot of a collection larger than the maximum page size.
nextPageToken :: (Core.Maybe Core.Text),
-- | The resource record set resources.
rrsets :: (Core.Maybe [ResourceRecordSet])
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ResourceRecordSetsListResponse' with the minimum fields required to make a request.
newResourceRecordSetsListResponse ::
ResourceRecordSetsListResponse
newResourceRecordSetsListResponse =
ResourceRecordSetsListResponse
{ header = Core.Nothing,
kind = "dns#resourceRecordSetsListResponse",
nextPageToken = Core.Nothing,
rrsets = Core.Nothing
}
instance Core.FromJSON ResourceRecordSetsListResponse where
parseJSON =
Core.withObject
"ResourceRecordSetsListResponse"
( \o ->
ResourceRecordSetsListResponse
Core.<$> (o Core..:? "header")
Core.<*> (o Core..:? "kind" Core..!= "dns#resourceRecordSetsListResponse")
Core.<*> (o Core..:? "nextPageToken")
Core.<*> (o Core..:? "rrsets")
)
instance Core.ToJSON ResourceRecordSetsListResponse where
toJSON ResourceRecordSetsListResponse {..} =
Core.object
( Core.catMaybes
[ ("header" Core..=) Core.<$> header,
Core.Just ("kind" Core..= kind),
("nextPageToken" Core..=) Core.<$> nextPageToken,
("rrsets" Core..=) Core.<$> rrsets
]
)
-- | Elements common to every response.
--
-- /See:/ 'newResponseHeader' smart constructor.
newtype ResponseHeader = ResponseHeader
{ -- | For mutating operation requests that completed successfully. This is the client/operation/id if the client specified it, otherwise it is generated by the server (output only).
operationId :: (Core.Maybe Core.Text)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ResponseHeader' with the minimum fields required to make a request.
newResponseHeader ::
ResponseHeader
newResponseHeader = ResponseHeader {operationId = Core.Nothing}
instance Core.FromJSON ResponseHeader where
parseJSON =
Core.withObject
"ResponseHeader"
(\o -> ResponseHeader Core.<$> (o Core..:? "operationId"))
instance Core.ToJSON ResponseHeader where
toJSON ResponseHeader {..} =
Core.object
(Core.catMaybes [("operationId" Core..=) Core.<$> operationId])
--
-- /See:/ 'newResponsePoliciesListResponse' smart constructor.
data ResponsePoliciesListResponse = ResponsePoliciesListResponse
{ header :: (Core.Maybe ResponseHeader),
-- | The presence of this field indicates that there exist more results following your last page of results in pagination order. To fetch them, make another list request using this value as your page token. This lets you the complete contents of even very large collections one page at a time. However, if the contents of the collection change between the first and last paginated list request, the set of all elements returned are an inconsistent view of the collection. You cannot retrieve a consistent snapshot of a collection larger than the maximum page size.
nextPageToken :: (Core.Maybe Core.Text),
-- | The Response Policy resources.
responsePolicies :: (Core.Maybe [ResponsePolicy])
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ResponsePoliciesListResponse' with the minimum fields required to make a request.
newResponsePoliciesListResponse ::
ResponsePoliciesListResponse
newResponsePoliciesListResponse =
ResponsePoliciesListResponse
{ header = Core.Nothing,
nextPageToken = Core.Nothing,
responsePolicies = Core.Nothing
}
instance Core.FromJSON ResponsePoliciesListResponse where
parseJSON =
Core.withObject
"ResponsePoliciesListResponse"
( \o ->
ResponsePoliciesListResponse
Core.<$> (o Core..:? "header")
Core.<*> (o Core..:? "nextPageToken")
Core.<*> (o Core..:? "responsePolicies")
)
instance Core.ToJSON ResponsePoliciesListResponse where
toJSON ResponsePoliciesListResponse {..} =
Core.object
( Core.catMaybes
[ ("header" Core..=) Core.<$> header,
("nextPageToken" Core..=) Core.<$> nextPageToken,
("responsePolicies" Core..=) Core.<$> responsePolicies
]
)
--
-- /See:/ 'newResponsePoliciesPatchResponse' smart constructor.
data ResponsePoliciesPatchResponse = ResponsePoliciesPatchResponse
{ header :: (Core.Maybe ResponseHeader),
responsePolicy :: (Core.Maybe ResponsePolicy)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ResponsePoliciesPatchResponse' with the minimum fields required to make a request.
newResponsePoliciesPatchResponse ::
ResponsePoliciesPatchResponse
newResponsePoliciesPatchResponse =
ResponsePoliciesPatchResponse
{ header = Core.Nothing,
responsePolicy = Core.Nothing
}
instance Core.FromJSON ResponsePoliciesPatchResponse where
parseJSON =
Core.withObject
"ResponsePoliciesPatchResponse"
( \o ->
ResponsePoliciesPatchResponse
Core.<$> (o Core..:? "header")
Core.<*> (o Core..:? "responsePolicy")
)
instance Core.ToJSON ResponsePoliciesPatchResponse where
toJSON ResponsePoliciesPatchResponse {..} =
Core.object
( Core.catMaybes
[ ("header" Core..=) Core.<$> header,
("responsePolicy" Core..=) Core.<$> responsePolicy
]
)
--
-- /See:/ 'newResponsePoliciesUpdateResponse' smart constructor.
data ResponsePoliciesUpdateResponse = ResponsePoliciesUpdateResponse
{ header :: (Core.Maybe ResponseHeader),
responsePolicy :: (Core.Maybe ResponsePolicy)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ResponsePoliciesUpdateResponse' with the minimum fields required to make a request.
newResponsePoliciesUpdateResponse ::
ResponsePoliciesUpdateResponse
newResponsePoliciesUpdateResponse =
ResponsePoliciesUpdateResponse
{ header = Core.Nothing,
responsePolicy = Core.Nothing
}
instance Core.FromJSON ResponsePoliciesUpdateResponse where
parseJSON =
Core.withObject
"ResponsePoliciesUpdateResponse"
( \o ->
ResponsePoliciesUpdateResponse
Core.<$> (o Core..:? "header")
Core.<*> (o Core..:? "responsePolicy")
)
instance Core.ToJSON ResponsePoliciesUpdateResponse where
toJSON ResponsePoliciesUpdateResponse {..} =
Core.object
( Core.catMaybes
[ ("header" Core..=) Core.<$> header,
("responsePolicy" Core..=) Core.<$> responsePolicy
]
)
-- | A Response Policy is a collection of selectors that apply to queries made against one or more Virtual Private Cloud networks.
--
-- /See:/ 'newResponsePolicy' smart constructor.
data ResponsePolicy = ResponsePolicy
{ -- | User-provided description for this Response Policy.
description :: (Core.Maybe Core.Text),
-- | The list of Google Kubernetes Engine clusters to which this response policy is applied.
gkeClusters :: (Core.Maybe [ResponsePolicyGKECluster]),
-- | Unique identifier for the resource; defined by the server (output only).
id :: (Core.Maybe Core.Int64),
kind :: Core.Text,
-- | List of network names specifying networks to which this policy is applied.
networks :: (Core.Maybe [ResponsePolicyNetwork]),
-- | User assigned name for this Response Policy.
responsePolicyName :: (Core.Maybe Core.Text)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ResponsePolicy' with the minimum fields required to make a request.
newResponsePolicy ::
ResponsePolicy
newResponsePolicy =
ResponsePolicy
{ description = Core.Nothing,
gkeClusters = Core.Nothing,
id = Core.Nothing,
kind = "dns#responsePolicy",
networks = Core.Nothing,
responsePolicyName = Core.Nothing
}
instance Core.FromJSON ResponsePolicy where
parseJSON =
Core.withObject
"ResponsePolicy"
( \o ->
ResponsePolicy
Core.<$> (o Core..:? "description")
Core.<*> (o Core..:? "gkeClusters")
Core.<*> (o Core..:? "id" Core.<&> Core.fmap Core.fromAsText)
Core.<*> (o Core..:? "kind" Core..!= "dns#responsePolicy")
Core.<*> (o Core..:? "networks")
Core.<*> (o Core..:? "responsePolicyName")
)
instance Core.ToJSON ResponsePolicy where
toJSON ResponsePolicy {..} =
Core.object
( Core.catMaybes
[ ("description" Core..=) Core.<$> description,
("gkeClusters" Core..=) Core.<$> gkeClusters,
("id" Core..=) Core.. Core.AsText Core.<$> id,
Core.Just ("kind" Core..= kind),
("networks" Core..=) Core.<$> networks,
("responsePolicyName" Core..=) Core.<$> responsePolicyName
]
)
--
-- /See:/ 'newResponsePolicyGKECluster' smart constructor.
data ResponsePolicyGKECluster = ResponsePolicyGKECluster
{ -- | The resource name of the cluster to bind this response policy to. This should be specified in the format like: projects\//\/locations\//\/clusters\/*. This is referenced from GKE projects.locations.clusters.get API: https:\/\/cloud.google.com\/kubernetes-engine\/docs\/reference\/rest\/v1\/projects.locations.clusters\/get
gkeClusterName :: (Core.Maybe Core.Text),
kind :: Core.Text
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ResponsePolicyGKECluster' with the minimum fields required to make a request.
newResponsePolicyGKECluster ::
ResponsePolicyGKECluster
newResponsePolicyGKECluster =
ResponsePolicyGKECluster
{ gkeClusterName = Core.Nothing,
kind = "dns#responsePolicyGKECluster"
}
instance Core.FromJSON ResponsePolicyGKECluster where
parseJSON =
Core.withObject
"ResponsePolicyGKECluster"
( \o ->
ResponsePolicyGKECluster
Core.<$> (o Core..:? "gkeClusterName")
Core.<*> (o Core..:? "kind" Core..!= "dns#responsePolicyGKECluster")
)
instance Core.ToJSON ResponsePolicyGKECluster where
toJSON ResponsePolicyGKECluster {..} =
Core.object
( Core.catMaybes
[ ("gkeClusterName" Core..=) Core.<$> gkeClusterName,
Core.Just ("kind" Core..= kind)
]
)
--
-- /See:/ 'newResponsePolicyNetwork' smart constructor.
data ResponsePolicyNetwork = ResponsePolicyNetwork
{ kind :: Core.Text,
-- | The fully qualified URL of the VPC network to bind to. This should be formatted like https:\/\/www.googleapis.com\/compute\/v1\/projects\/{project}\/global\/networks\/{network}
networkUrl :: (Core.Maybe Core.Text)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ResponsePolicyNetwork' with the minimum fields required to make a request.
newResponsePolicyNetwork ::
ResponsePolicyNetwork
newResponsePolicyNetwork =
ResponsePolicyNetwork
{ kind = "dns#responsePolicyNetwork",
networkUrl = Core.Nothing
}
instance Core.FromJSON ResponsePolicyNetwork where
parseJSON =
Core.withObject
"ResponsePolicyNetwork"
( \o ->
ResponsePolicyNetwork
Core.<$> (o Core..:? "kind" Core..!= "dns#responsePolicyNetwork")
Core.<*> (o Core..:? "networkUrl")
)
instance Core.ToJSON ResponsePolicyNetwork where
toJSON ResponsePolicyNetwork {..} =
Core.object
( Core.catMaybes
[ Core.Just ("kind" Core..= kind),
("networkUrl" Core..=) Core.<$> networkUrl
]
)
-- | A Response Policy Rule is a selector that applies its behavior to queries that match the selector. Selectors are DNS names, which may be wildcards or exact matches. Each DNS query subject to a Response Policy matches at most one ResponsePolicyRule, as identified by the dns_name field with the longest matching suffix.
--
-- /See:/ 'newResponsePolicyRule' smart constructor.
data ResponsePolicyRule = ResponsePolicyRule
{ -- | Answer this query with a behavior rather than DNS data.
behavior :: (Core.Maybe ResponsePolicyRule_Behavior),
-- | The DNS name (wildcard or exact) to apply this rule to. Must be unique within the Response Policy Rule.
dnsName :: (Core.Maybe Core.Text),
kind :: Core.Text,
-- | Answer this query directly with DNS data. These ResourceRecordSets override any other DNS behavior for the matched name; in particular they override private zones, the public internet, and GCP internal DNS. No SOA nor NS types are allowed.
localData :: (Core.Maybe ResponsePolicyRuleLocalData),
-- | An identifier for this rule. Must be unique with the ResponsePolicy.
ruleName :: (Core.Maybe Core.Text)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ResponsePolicyRule' with the minimum fields required to make a request.
newResponsePolicyRule ::
ResponsePolicyRule
newResponsePolicyRule =
ResponsePolicyRule
{ behavior = Core.Nothing,
dnsName = Core.Nothing,
kind = "dns#responsePolicyRule",
localData = Core.Nothing,
ruleName = Core.Nothing
}
instance Core.FromJSON ResponsePolicyRule where
parseJSON =
Core.withObject
"ResponsePolicyRule"
( \o ->
ResponsePolicyRule
Core.<$> (o Core..:? "behavior")
Core.<*> (o Core..:? "dnsName")
Core.<*> (o Core..:? "kind" Core..!= "dns#responsePolicyRule")
Core.<*> (o Core..:? "localData")
Core.<*> (o Core..:? "ruleName")
)
instance Core.ToJSON ResponsePolicyRule where
toJSON ResponsePolicyRule {..} =
Core.object
( Core.catMaybes
[ ("behavior" Core..=) Core.<$> behavior,
("dnsName" Core..=) Core.<$> dnsName,
Core.Just ("kind" Core..= kind),
("localData" Core..=) Core.<$> localData,
("ruleName" Core..=) Core.<$> ruleName
]
)
--
-- /See:/ 'newResponsePolicyRuleLocalData' smart constructor.
newtype ResponsePolicyRuleLocalData = ResponsePolicyRuleLocalData
{ -- | All resource record sets for this selector, one per resource record type. The name must match the dns_name.
localDatas :: (Core.Maybe [ResourceRecordSet])
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ResponsePolicyRuleLocalData' with the minimum fields required to make a request.
newResponsePolicyRuleLocalData ::
ResponsePolicyRuleLocalData
newResponsePolicyRuleLocalData =
ResponsePolicyRuleLocalData {localDatas = Core.Nothing}
instance Core.FromJSON ResponsePolicyRuleLocalData where
parseJSON =
Core.withObject
"ResponsePolicyRuleLocalData"
( \o ->
ResponsePolicyRuleLocalData Core.<$> (o Core..:? "localDatas")
)
instance Core.ToJSON ResponsePolicyRuleLocalData where
toJSON ResponsePolicyRuleLocalData {..} =
Core.object
(Core.catMaybes [("localDatas" Core..=) Core.<$> localDatas])
--
-- /See:/ 'newResponsePolicyRulesListResponse' smart constructor.
data ResponsePolicyRulesListResponse = ResponsePolicyRulesListResponse
{ header :: (Core.Maybe ResponseHeader),
-- | The presence of this field indicates that there exist more results following your last page of results in pagination order. To fetch them, make another list request using this value as your page token. This lets you the complete contents of even very large collections one page at a time. However, if the contents of the collection change between the first and last paginated list request, the set of all elements returned are an inconsistent view of the collection. You cannot retrieve a consistent snapshot of a collection larger than the maximum page size.
nextPageToken :: (Core.Maybe Core.Text),
-- | The Response Policy Rule resources.
responsePolicyRules :: (Core.Maybe [ResponsePolicyRule])
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ResponsePolicyRulesListResponse' with the minimum fields required to make a request.
newResponsePolicyRulesListResponse ::
ResponsePolicyRulesListResponse
newResponsePolicyRulesListResponse =
ResponsePolicyRulesListResponse
{ header = Core.Nothing,
nextPageToken = Core.Nothing,
responsePolicyRules = Core.Nothing
}
instance Core.FromJSON ResponsePolicyRulesListResponse where
parseJSON =
Core.withObject
"ResponsePolicyRulesListResponse"
( \o ->
ResponsePolicyRulesListResponse
Core.<$> (o Core..:? "header")
Core.<*> (o Core..:? "nextPageToken")
Core.<*> (o Core..:? "responsePolicyRules")
)
instance Core.ToJSON ResponsePolicyRulesListResponse where
toJSON ResponsePolicyRulesListResponse {..} =
Core.object
( Core.catMaybes
[ ("header" Core..=) Core.<$> header,
("nextPageToken" Core..=) Core.<$> nextPageToken,
("responsePolicyRules" Core..=) Core.<$> responsePolicyRules
]
)
--
-- /See:/ 'newResponsePolicyRulesPatchResponse' smart constructor.
data ResponsePolicyRulesPatchResponse = ResponsePolicyRulesPatchResponse
{ header :: (Core.Maybe ResponseHeader),
responsePolicyRule :: (Core.Maybe ResponsePolicyRule)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ResponsePolicyRulesPatchResponse' with the minimum fields required to make a request.
newResponsePolicyRulesPatchResponse ::
ResponsePolicyRulesPatchResponse
newResponsePolicyRulesPatchResponse =
ResponsePolicyRulesPatchResponse
{ header = Core.Nothing,
responsePolicyRule = Core.Nothing
}
instance Core.FromJSON ResponsePolicyRulesPatchResponse where
parseJSON =
Core.withObject
"ResponsePolicyRulesPatchResponse"
( \o ->
ResponsePolicyRulesPatchResponse
Core.<$> (o Core..:? "header")
Core.<*> (o Core..:? "responsePolicyRule")
)
instance Core.ToJSON ResponsePolicyRulesPatchResponse where
toJSON ResponsePolicyRulesPatchResponse {..} =
Core.object
( Core.catMaybes
[ ("header" Core..=) Core.<$> header,
("responsePolicyRule" Core..=) Core.<$> responsePolicyRule
]
)
--
-- /See:/ 'newResponsePolicyRulesUpdateResponse' smart constructor.
data ResponsePolicyRulesUpdateResponse = ResponsePolicyRulesUpdateResponse
{ header :: (Core.Maybe ResponseHeader),
responsePolicyRule :: (Core.Maybe ResponsePolicyRule)
}
deriving (Core.Eq, Core.Show, Core.Generic)
-- | Creates a value of 'ResponsePolicyRulesUpdateResponse' with the minimum fields required to make a request.
newResponsePolicyRulesUpdateResponse ::
ResponsePolicyRulesUpdateResponse
newResponsePolicyRulesUpdateResponse =
ResponsePolicyRulesUpdateResponse
{ header = Core.Nothing,
responsePolicyRule = Core.Nothing
}
instance Core.FromJSON ResponsePolicyRulesUpdateResponse where
parseJSON =
Core.withObject
"ResponsePolicyRulesUpdateResponse"
( \o ->
ResponsePolicyRulesUpdateResponse
Core.<$> (o Core..:? "header")
Core.<*> (o Core..:? "responsePolicyRule")
)
instance Core.ToJSON ResponsePolicyRulesUpdateResponse where
toJSON ResponsePolicyRulesUpdateResponse {..} =
Core.object
( Core.catMaybes
[ ("header" Core..=) Core.<$> header,
("responsePolicyRule" Core..=) Core.<$> responsePolicyRule
]
)