{-# 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
          ]
      )